Split up post model into post and thread to normalise models. Still need some refactoring

boards/migrations/0014_auto__add_thread__chg_field_post_thread.py

@@ -0,0 +1,115 b''
+# -*- coding: utf-8 -*-
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Adding model 'Thread'
+        db.create_table(u'boards_thread', (
+            (u'id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
+            ('bump_time', self.gf('django.db.models.fields.DateTimeField')()),
+            ('last_edit_time', self.gf('django.db.models.fields.DateTimeField')()),
+        ))
+        db.send_create_signal('boards', ['Thread'])
+
+        # Adding M2M table for field tags on 'Thread'
+        m2m_table_name = db.shorten_name(u'boards_thread_tags')
+        db.create_table(m2m_table_name, (
+            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
+            ('thread', models.ForeignKey(orm['boards.thread'], null=False)),
+            ('tag', models.ForeignKey(orm['boards.tag'], null=False))
+        ))
+        db.create_unique(m2m_table_name, ['thread_id', 'tag_id'])
+
+        db.delete_table(db.shorten_name(u'boards_tag_threads'))
+        # Adding M2M table for field threads on 'Tag'
+        m2m_table_name = db.shorten_name(u'boards_tag_threads')
+        db.create_table(m2m_table_name, (
+            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
+            ('thread', models.ForeignKey(orm['boards.thread'], null=False)),
+            ('tag', models.ForeignKey(orm['boards.tag'], null=False))
+        ))
+        db.create_unique(m2m_table_name, ['thread_id', 'tag_id'])
+
+        # Adding M2M table for field replies on 'Thread'
+        m2m_table_name = db.shorten_name(u'boards_thread_replies')
+        db.create_table(m2m_table_name, (
+            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
+            ('thread', models.ForeignKey(orm['boards.thread'], null=False)),
+            ('post', models.ForeignKey(orm['boards.post'], null=False))
+        ))
+        db.create_unique(m2m_table_name, ['thread_id', 'post_id'])
+
+        db.add_column(u'boards_post', 'thread_new',
+                      self.gf('django.db.models.fields.related.ForeignKey')(default=None, to=orm['boards.Thread'], null=True),
+                      keep_default=False)
+
+    def backwards(self, orm):
+        pass
+
+    models = {
+        'boards.ban': {
+            'Meta': {'object_name': 'Ban'},
+            'can_read': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'ip': ('django.db.models.fields.GenericIPAddressField', [], {'max_length': '39'}),
+            'reason': ('django.db.models.fields.CharField', [], {'default': "'Auto'", 'max_length': '200'})
+        },
+        'boards.post': {
+            'Meta': {'object_name': 'Post'},
+            '_text_rendered': ('django.db.models.fields.TextField', [], {}),
+            'bump_time': ('django.db.models.fields.DateTimeField', [], {}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'image': ('boards.thumbs.ImageWithThumbsField', [], {'max_length': '100', 'blank': 'True'}),
+            'image_height': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'image_width': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'last_edit_time': ('django.db.models.fields.DateTimeField', [], {}),
+            'poster_ip': ('django.db.models.fields.GenericIPAddressField', [], {'max_length': '39'}),
+            'poster_user_agent': ('django.db.models.fields.TextField', [], {}),
+            'pub_time': ('django.db.models.fields.DateTimeField', [], {}),
+            'referenced_posts': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'rfp+'", 'null': 'True', 'symmetrical': 'False', 'to': "orm['boards.Post']"}),
+            'replies': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'re+'", 'null': 'True', 'symmetrical': 'False', 'to': "orm['boards.Post']"}),
+            'tags': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['boards.Tag']", 'symmetrical': 'False'}),
+            'text': ('markupfield.fields.MarkupField', [], {'rendered_field': 'True'}),
+            'text_markup_type': ('django.db.models.fields.CharField', [], {'default': "'markdown'", 'max_length': '30'}),
+            'thread': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['boards.Thread']", 'null': 'True'}),
+            'title': ('django.db.models.fields.CharField', [], {'max_length': '50'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['boards.User']", 'null': 'True'})
+        },
+        'boards.setting': {
+            'Meta': {'object_name': 'Setting'},
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['boards.User']"}),
+            'value': ('django.db.models.fields.CharField', [], {'max_length': '50'})
+        },
+        'boards.tag': {
+            'Meta': {'object_name': 'Tag'},
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'linked': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['boards.Tag']", 'null': 'True', 'blank': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'threads': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'tag+'", 'null': 'True', 'symmetrical': 'False', 'to': "orm['boards.Thread']"})
+        },
+        'boards.thread': {
+            'Meta': {'object_name': 'Thread'},
+            'bump_time': ('django.db.models.fields.DateTimeField', [], {}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'last_edit_time': ('django.db.models.fields.DateTimeField', [], {}),
+            'replies': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'tre+'", 'null': 'True', 'symmetrical': 'False', 'to': "orm['boards.Post']"}),
+            'tags': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['boards.Tag']", 'symmetrical': 'False'})
+        },
+        'boards.user': {
+            'Meta': {'object_name': 'User'},
+            'fav_tags': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['boards.Tag']", 'null': 'True', 'blank': 'True'}),
+            'fav_threads': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'+'", 'null': 'True', 'symmetrical': 'False', 'to': "orm['boards.Post']"}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'rank': ('django.db.models.fields.IntegerField', [], {}),
+            'registration_time': ('django.db.models.fields.DateTimeField', [], {}),
+            'user_id': ('django.db.models.fields.CharField', [], {'max_length': '50'})
+        }
+    }
+
+    complete_apps = ['boards']
  No newline at end of file

boards/migrations/0015_post_to_thread.py

@@ -0,0 +1,98 b''
+# -*- coding: utf-8 -*-
+from south.utils import datetime_utils as datetime
+from south.db import db
+from south.v2 import DataMigration
+from django.db import models
+from boards import views
+
+
+class Migration(DataMigration):
+
+    def forwards(self, orm):
+        for post in orm.Post.objects.filter(thread=None):
+            thread = orm.Thread.objects.create(
+                bump_time=post.bump_time,
+                last_edit_time=post.last_edit_time)
+
+            thread.replies.add(post)
+            post.thread_new = thread
+            post.save()
+            print str(post.thread_new.id)
+
+            for reply in post.replies.all():
+                thread.replies.add(reply)
+                reply.thread_new = thread
+                reply.save()
+
+            for tag in post.tags.all():
+                thread.tags.add(tag)
+                tag.threads.add(thread)
+
+    def backwards(self, orm):
+        pass
+
+    models = {
+        'boards.ban': {
+            'Meta': {'object_name': 'Ban'},
+            'can_read': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'ip': ('django.db.models.fields.GenericIPAddressField', [], {'max_length': '39'}),
+            'reason': ('django.db.models.fields.CharField', [], {'default': "'Auto'", 'max_length': '200'})
+        },
+        'boards.post': {
+            'Meta': {'object_name': 'Post'},
+            '_text_rendered': ('django.db.models.fields.TextField', [], {}),
+            'bump_time': ('django.db.models.fields.DateTimeField', [], {}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'image': ('boards.thumbs.ImageWithThumbsField', [], {'max_length': '100', 'blank': 'True'}),
+            'image_height': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'image_width': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'last_edit_time': ('django.db.models.fields.DateTimeField', [], {}),
+            'poster_ip': ('django.db.models.fields.GenericIPAddressField', [], {'max_length': '39'}),
+            'poster_user_agent': ('django.db.models.fields.TextField', [], {}),
+            'pub_time': ('django.db.models.fields.DateTimeField', [], {}),
+            'referenced_posts': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'rfp+'", 'null': 'True', 'symmetrical': 'False', 'to': "orm['boards.Post']"}),
+            'replies': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'re+'", 'null': 'True', 'symmetrical': 'False', 'to': "orm['boards.Post']"}),
+            'tags': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['boards.Tag']", 'symmetrical': 'False'}),
+            'text': ('markupfield.fields.MarkupField', [], {'rendered_field': 'True'}),
+            'text_markup_type': ('django.db.models.fields.CharField', [], {'default': "'markdown'", 'max_length': '30'}),
+            'thread': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['boards.Post']", 'null': 'True'}),
+            'thread_new': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['boards.Thread']", 'null': 'True'}),
+            'title': ('django.db.models.fields.CharField', [], {'max_length': '50'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['boards.User']", 'null': 'True'})
+        },
+        'boards.setting': {
+            'Meta': {'object_name': 'Setting'},
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['boards.User']"}),
+            'value': ('django.db.models.fields.CharField', [], {'max_length': '50'})
+        },
+        'boards.tag': {
+            'Meta': {'object_name': 'Tag'},
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'linked': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['boards.Tag']", 'null': 'True', 'blank': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'threads': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'tag+'", 'null': 'True', 'symmetrical': 'False', 'to': "orm['boards.Thread']"})
+        },
+        'boards.thread': {
+            'Meta': {'object_name': 'Thread'},
+            'bump_time': ('django.db.models.fields.DateTimeField', [], {}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'last_edit_time': ('django.db.models.fields.DateTimeField', [], {}),
+            'replies': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'tre+'", 'null': 'True', 'symmetrical': 'False', 'to': "orm['boards.Post']"}),
+            'tags': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['boards.Tag']", 'symmetrical': 'False'})
+        },
+        'boards.user': {
+            'Meta': {'object_name': 'User'},
+            'fav_tags': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['boards.Tag']", 'null': 'True', 'blank': 'True'}),
+            'fav_threads': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'+'", 'null': 'True', 'symmetrical': 'False', 'to': "orm['boards.Post']"}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'rank': ('django.db.models.fields.IntegerField', [], {}),
+            'registration_time': ('django.db.models.fields.DateTimeField', [], {}),
+            'user_id': ('django.db.models.fields.CharField', [], {'max_length': '50'})
+        }
+    }
+
+    complete_apps = ['boards']
+    symmetrical = True

boards/migrations/0016_auto__del_field_post_bump_time.py

@@ -0,0 +1,110 b''
+# -*- coding: utf-8 -*-
+from south.utils import datetime_utils as datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Deleting field 'Post.bump_time'
+        db.delete_column(u'boards_post', 'bump_time')
+
+        # Removing M2M table for field tags on 'Post'
+        db.delete_table(db.shorten_name(u'boards_post_tags'))
+
+        # Removing M2M table for field replies on 'Post'
+        db.delete_table(db.shorten_name(u'boards_post_replies'))
+
+
+    def backwards(self, orm):
+
+        # User chose to not deal with backwards NULL issues for 'Post.bump_time'
+        raise RuntimeError("Cannot reverse this migration. 'Post.bump_time' and its values cannot be restored.")
+        
+        # The following code is provided here to aid in writing a correct migration        # Adding field 'Post.bump_time'
+        db.add_column(u'boards_post', 'bump_time',
+                      self.gf('django.db.models.fields.DateTimeField')(),
+                      keep_default=False)
+
+        # Adding M2M table for field tags on 'Post'
+        m2m_table_name = db.shorten_name(u'boards_post_tags')
+        db.create_table(m2m_table_name, (
+            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
+            ('post', models.ForeignKey(orm['boards.post'], null=False)),
+            ('tag', models.ForeignKey(orm['boards.tag'], null=False))
+        ))
+        db.create_unique(m2m_table_name, ['post_id', 'tag_id'])
+
+        # Adding M2M table for field replies on 'Post'
+        m2m_table_name = db.shorten_name(u'boards_post_replies')
+        db.create_table(m2m_table_name, (
+            ('id', models.AutoField(verbose_name='ID', primary_key=True, auto_created=True)),
+            ('from_post', models.ForeignKey(orm['boards.post'], null=False)),
+            ('to_post', models.ForeignKey(orm['boards.post'], null=False))
+        ))
+        db.create_unique(m2m_table_name, ['from_post_id', 'to_post_id'])
+
+
+    models = {
+        'boards.ban': {
+            'Meta': {'object_name': 'Ban'},
+            'can_read': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'ip': ('django.db.models.fields.GenericIPAddressField', [], {'max_length': '39'}),
+            'reason': ('django.db.models.fields.CharField', [], {'default': "'Auto'", 'max_length': '200'})
+        },
+        'boards.post': {
+            'Meta': {'object_name': 'Post'},
+            '_text_rendered': ('django.db.models.fields.TextField', [], {}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'image': ('boards.thumbs.ImageWithThumbsField', [], {'max_length': '100', 'blank': 'True'}),
+            'image_height': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'image_width': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'last_edit_time': ('django.db.models.fields.DateTimeField', [], {}),
+            'poster_ip': ('django.db.models.fields.GenericIPAddressField', [], {'max_length': '39'}),
+            'poster_user_agent': ('django.db.models.fields.TextField', [], {}),
+            'pub_time': ('django.db.models.fields.DateTimeField', [], {}),
+            'referenced_posts': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'rfp+'", 'null': 'True', 'symmetrical': 'False', 'to': "orm['boards.Post']"}),
+            'text': ('markupfield.fields.MarkupField', [], {'rendered_field': 'True'}),
+            'text_markup_type': ('django.db.models.fields.CharField', [], {'default': "'markdown'", 'max_length': '30'}),
+            'thread': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['boards.Post']", 'null': 'True'}),
+            'thread_new': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['boards.Thread']", 'null': 'True'}),
+            'title': ('django.db.models.fields.CharField', [], {'max_length': '50'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': "orm['boards.User']", 'null': 'True'})
+        },
+        'boards.setting': {
+            'Meta': {'object_name': 'Setting'},
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['boards.User']"}),
+            'value': ('django.db.models.fields.CharField', [], {'max_length': '50'})
+        },
+        'boards.tag': {
+            'Meta': {'object_name': 'Tag'},
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'linked': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['boards.Tag']", 'null': 'True', 'blank': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'threads': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'tag+'", 'null': 'True', 'symmetrical': 'False', 'to': "orm['boards.Thread']"})
+        },
+        'boards.thread': {
+            'Meta': {'object_name': 'Thread'},
+            'bump_time': ('django.db.models.fields.DateTimeField', [], {}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'last_edit_time': ('django.db.models.fields.DateTimeField', [], {}),
+            'replies': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'tre+'", 'null': 'True', 'symmetrical': 'False', 'to': "orm['boards.Post']"}),
+            'tags': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['boards.Tag']", 'symmetrical': 'False'})
+        },
+        'boards.user': {
+            'Meta': {'object_name': 'User'},
+            'fav_tags': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'to': "orm['boards.Tag']", 'null': 'True', 'blank': 'True'}),
+            'fav_threads': ('django.db.models.fields.related.ManyToManyField', [], {'blank': 'True', 'related_name': "'+'", 'null': 'True', 'symmetrical': 'False', 'to': "orm['boards.Post']"}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'rank': ('django.db.models.fields.IntegerField', [], {}),
+            'registration_time': ('django.db.models.fields.DateTimeField', [], {}),
+            'user_id': ('django.db.models.fields.CharField', [], {'max_length': '50'})
+        }
+    }
+
+    complete_apps = ['boards']
  No newline at end of file

boards/admin.py

@@ -1,25 +1,25 b''
 from django.contrib import admin
 from boards.models import Post, Tag, User, Ban
 
 
 class PostAdmin(admin.ModelAdmin):
 
     list_display = ('id', 'title', 'text')
-    list_filter = ('pub_time', 'tags')
+    list_filter = ('pub_time', 'thread_new')
     search_fields = ('id', 'title', 'text')
 
 
 class TagAdmin(admin.ModelAdmin):
 
     list_display = ('name', 'linked')
     list_filter = ('linked',)
 
 
 class UserAdmin(admin.ModelAdmin):
 
     list_display = ('user_id', 'rank')
 
 admin.site.register(Post, PostAdmin)
 admin.site.register(Tag, TagAdmin)
 admin.site.register(User, UserAdmin)
 admin.site.register(Ban)

boards/mdx_neboard.py

@@ -1,118 +1,119 b''
 from django.core.urlresolvers import reverse
 import markdown
 from markdown.inlinepatterns import Pattern
 from markdown.util import etree
 import boards
 
 __author__ = 'neko259'
 
 
 AUTOLINK_PATTERN = r'(https?://\S+)'
 QUOTE_PATTERN = r'^(?<!>)(>[^>].+)$'
 REFLINK_PATTERN = r'((>>)(\d+))'
 SPOILER_PATTERN = r'%%(.+)%%'
 COMMENT_PATTERN = r'^(//(.+))'
 STRIKETHROUGH_PATTERN = r'~(.+)~'
 
+
 class AutolinkPattern(Pattern):
     def handleMatch(self, m):
         link_element = etree.Element('a')
         href = m.group(2)
         link_element.set('href', href)
         link_element.text = href
 
         return link_element
 
 
 class QuotePattern(Pattern):
     def handleMatch(self, m):
         quote_element = etree.Element('span')
         quote_element.set('class', 'quote')
         quote_element.text = m.group(2)
 
         return quote_element
 
 
 class ReflinkPattern(Pattern):
     def handleMatch(self, m):
         post_id = m.group(4)
 
         posts = boards.models.Post.objects.filter(id=post_id)
         if posts.count() > 0:
             ref_element = etree.Element('a')
 
-	    post = posts[0]
+            post = posts[0]
             if post.thread:
                 link = reverse(boards.views.thread, kwargs={'post_id': post.thread.id}) \
                                                + '#' + post_id
             else:
-		link = reverse(boards.views.thread, kwargs={'post_id': post_id})
+                link = reverse(boards.views.thread, kwargs={'post_id': post_id})
 
             ref_element.set('href', link)
             ref_element.text = m.group(2)
 
-	    return ref_element
+            return ref_element
 
 
 class SpoilerPattern(Pattern):
     def handleMatch(self, m):
         quote_element = etree.Element('span')
         quote_element.set('class', 'spoiler')
         quote_element.text = m.group(2)
 
         return quote_element
 
 
 class CommentPattern(Pattern):
     def handleMatch(self, m):
         quote_element = etree.Element('span')
         quote_element.set('class', 'comment')
         quote_element.text = '//' + m.group(3)
 
         return quote_element
 
 
 class StrikeThroughPattern(Pattern):
     def handleMatch(self, m):
         quote_element = etree.Element('span')
         quote_element.set('class', 'strikethrough')
         quote_element.text = m.group(2)
 
         return quote_element
 
 
 class NeboardMarkdown(markdown.Extension):
     def extendMarkdown(self, md, md_globals):
         self._add_neboard_patterns(md)
         self._delete_patterns(md)
 
     def _delete_patterns(self, md):
         del md.parser.blockprocessors['quote']
 
         del md.inlinePatterns['image_link']
         del md.inlinePatterns['image_reference']
 
     def _add_neboard_patterns(self, md):
         autolink = AutolinkPattern(AUTOLINK_PATTERN, md)
         quote = QuotePattern(QUOTE_PATTERN, md)
         reflink = ReflinkPattern(REFLINK_PATTERN, md)
         spoiler = SpoilerPattern(SPOILER_PATTERN, md)
         comment = CommentPattern(COMMENT_PATTERN, md)
 	strikethrough = StrikeThroughPattern(STRIKETHROUGH_PATTERN, md)
 
         md.inlinePatterns[u'autolink_ext'] = autolink
         md.inlinePatterns[u'spoiler'] = spoiler
 	md.inlinePatterns[u'strikethrough'] = strikethrough
         md.inlinePatterns[u'comment'] = comment
         md.inlinePatterns[u'reflink'] = reflink
         md.inlinePatterns[u'quote'] = quote
 
 
 def makeExtension(configs=None):
     return NeboardMarkdown(configs=configs)
 
 neboard_extension = makeExtension()
 
 
 def markdown_extended(markup):
     return markdown.markdown(markup, [neboard_extension], safe_mode=True)

boards/models/__init__.py

@@ -1,7 +1,8 b''
 __author__ = 'neko259'
 
 from boards.models.post import Post
+from boards.models.post import Thread
 from boards.models.tag import Tag
 from boards.models.user import Ban
 from boards.models.user import Setting
 from boards.models.user import User

boards/models/post.py

@@ -1,272 +1,296 b''
 import os
 from random import random
 import time
 import math
 import re
 
 from django.db import models
 from django.http import Http404
 from django.utils import timezone
 from markupfield.fields import MarkupField
 
 from neboard import settings
 from boards import settings as boards_settings
 from boards import thumbs
 
 BAN_REASON_AUTO = 'Auto'
 
 IMAGE_THUMB_SIZE = (200, 150)
 
 TITLE_MAX_LENGTH = 50
 
 DEFAULT_MARKUP_TYPE = 'markdown'
 
 NO_PARENT = -1
 NO_IP = '0.0.0.0'
 UNKNOWN_UA = ''
 ALL_PAGES = -1
 IMAGES_DIRECTORY = 'images/'
 FILE_EXTENSION_DELIMITER = '.'
 
 SETTING_MODERATE = "moderate"
 
 REGEX_REPLY = re.compile('>>(\d+)')
 
 
 class PostManager(models.Manager):
 
     def create_post(self, title, text, image=None, thread=None,
                     ip=NO_IP, tags=None, user=None):
         posting_time = timezone.now()
+        if not thread:
+            thread = Thread.objects.create(bump_time=posting_time,
+                                           last_edit_time=posting_time)
+        else:
+            thread.bump()
+            thread.last_edit_time = posting_time
+            thread.save()
 
         post = self.create(title=title,
                            text=text,
                            pub_time=posting_time,
-                           thread=thread,
+                           thread_new=thread,
                            image=image,
                            poster_ip=ip,
                            poster_user_agent=UNKNOWN_UA,
                            last_edit_time=posting_time,
-                           bump_time=posting_time,
                            user=user)
 
+        thread.replies.add(post)
         if tags:
             linked_tags = []
             for tag in tags:
                 tag_linked_tags = tag.get_linked_tags()
                 if len(tag_linked_tags) > 0:
                     linked_tags.extend(tag_linked_tags)
 
             tags.extend(linked_tags)
-            map(post.tags.add, tags)
-            for tag in tags:
-                tag.threads.add(post)
+            map(thread.add_tag, tags)
 
-        if thread:
-            thread.replies.add(post)
-            thread.bump()
-            thread.last_edit_time = posting_time
-            thread.save()
-        else:
-            self._delete_old_threads()
-
+        self._delete_old_threads()
         self.connect_replies(post)
 
         return post
 
+    # TODO Remove this method after migration
     def delete_post(self, post):
-        if post.replies.count() > 0:
-            map(self.delete_post, post.replies.all())
-
-        # Update thread's last edit time
-        thread = post.thread
-        if thread:
-            thread.last_edit_time = timezone.now()
-            thread.save()
+        thread = post.thread_new
+        thread.last_edit_time = timezone.now()
+        thread.save()
 
         post.delete()
 
     def delete_posts_by_ip(self, ip):
         posts = self.filter(poster_ip=ip)
         map(self.delete_post, posts)
 
+    # TODO Remove this method after migration
     def get_threads(self, tag=None, page=ALL_PAGES,
                     order_by='-bump_time'):
         if tag:
             threads = tag.threads
 
-            if threads.count() == 0:
+            if not threads.exists():
                 raise Http404
         else:
-            threads = self.filter(thread=None)
+            threads = Thread.objects.all()
 
         threads = threads.order_by(order_by)
 
         if page != ALL_PAGES:
             thread_count = threads.count()
 
             if page < self._get_page_count(thread_count):
                 start_thread = page * settings.THREADS_PER_PAGE
                 end_thread = min(start_thread + settings.THREADS_PER_PAGE,
                                  thread_count)
                 threads = threads[start_thread:end_thread]
 
         return threads
 
+    # TODO Remove this method after migration
     def get_thread(self, opening_post_id):
         try:
-            opening_post = self.get(id=opening_post_id, thread=None)
+            opening_post = self.get(id=opening_post_id)
         except Post.DoesNotExist:
             raise Http404
 
-        if opening_post.replies:
-            thread = [opening_post]
-            thread.extend(opening_post.replies.all().order_by('pub_time'))
+        return opening_post.thread_new
 
-            return thread
-
+    # TODO Move this method to thread manager
     def get_thread_page_count(self, tag=None):
         if tag:
-            threads = self.filter(thread=None, tags=tag)
+            threads = Thread.objects.filter(tags=tag)
         else:
-            threads = self.filter(thread=None)
+            threads = Thread.objects.all()
 
         return self._get_page_count(threads.count())
 
+    # TODO Move this method to thread manager
     def _delete_old_threads(self):
         """
         Preserves maximum thread count. If there are too many threads,
         delete the old ones.
         """
 
         # TODO Move old threads to the archive instead of deleting them.
         # Maybe make some 'old' field in the model to indicate the thread
         # must not be shown and be able for replying.
 
-        threads = self.get_threads()
+        threads = Thread.objects.all()
         thread_count = threads.count()
 
         if thread_count > settings.MAX_THREAD_COUNT:
             num_threads_to_delete = thread_count - settings.MAX_THREAD_COUNT
             old_threads = threads[thread_count - num_threads_to_delete:]
 
-            map(self.delete_post, old_threads)
+            map(Thread.delete_with_posts, old_threads)
 
     def connect_replies(self, post):
         """Connect replies to a post to show them as a refmap"""
 
         for reply_number in re.finditer(REGEX_REPLY, post.text.raw):
             post_id = reply_number.group(1)
             ref_post = self.filter(id=post_id)
             if ref_post.count() > 0:
                 referenced_post = ref_post[0]
                 referenced_post.referenced_posts.add(post)
                 referenced_post.last_edit_time = post.pub_time
                 referenced_post.save()
 
     def _get_page_count(self, thread_count):
         return int(math.ceil(thread_count / float(settings.THREADS_PER_PAGE)))
 
 
 class Post(models.Model):
     """A post is a message."""
 
     objects = PostManager()
 
     class Meta:
         app_label = 'boards'
 
     def _update_image_filename(self, filename):
         """Get unique image filename"""
 
         path = IMAGES_DIRECTORY
         new_name = str(int(time.mktime(time.gmtime())))
         new_name += str(int(random() * 1000))
         new_name += FILE_EXTENSION_DELIMITER
         new_name += filename.split(FILE_EXTENSION_DELIMITER)[-1:][0]
 
         return os.path.join(path, new_name)
 
     title = models.CharField(max_length=TITLE_MAX_LENGTH)
     pub_time = models.DateTimeField()
     text = MarkupField(default_markup_type=DEFAULT_MARKUP_TYPE,
                        escape_html=False)
 
     image_width = models.IntegerField(default=0)
     image_height = models.IntegerField(default=0)
 
     image = thumbs.ImageWithThumbsField(upload_to=_update_image_filename,
                                         blank=True, sizes=(IMAGE_THUMB_SIZE,),
                                         width_field='image_width',
                                         height_field='image_height')
 
     poster_ip = models.GenericIPAddressField()
     poster_user_agent = models.TextField()
 
     thread = models.ForeignKey('Post', null=True, default=None)
-    tags = models.ManyToManyField('Tag')
+    thread_new = models.ForeignKey('Thread', null=True, default=None)
     last_edit_time = models.DateTimeField()
-    bump_time = models.DateTimeField()
     user = models.ForeignKey('User', null=True, default=None)
 
-    replies = models.ManyToManyField('Post', symmetrical=False, null=True,
-                                     blank=True, related_name='re+')
     referenced_posts = models.ManyToManyField('Post', symmetrical=False,
                                               null=True,
                                               blank=True, related_name='rfp+')
 
     def __unicode__(self):
         return '#' + str(self.id) + ' ' + self.title + ' (' + \
                self.text.raw[:50] + ')'
 
     def get_title(self):
         title = self.title
         if len(title) == 0:
             title = self.text.raw[:20]
 
         return title
 
+    def get_sorted_referenced_posts(self):
+        return self.referenced_posts.order_by('id')
+
+    def is_referenced(self):
+        return self.referenced_posts.all().exists()
+
+
+class Thread(models.Model):
+
+    class Meta:
+        app_label = 'boards'
+
+    tags = models.ManyToManyField('Tag')
+    bump_time = models.DateTimeField()
+    last_edit_time = models.DateTimeField()
+    replies = models.ManyToManyField('Post', symmetrical=False, null=True,
+                                     blank=True, related_name='tre+')
+
+    def get_tags(self):
+        """Get a sorted tag list"""
+
+        return self.tags.order_by('name')
+
+    def bump(self):
+        """Bump (move to up) thread"""
+
+        if self.can_bump():
+            self.bump_time = timezone.now()
+
     def get_reply_count(self):
         return self.replies.count()
 
     def get_images_count(self):
-        images_count = 1 if self.image else 0
-        images_count += self.replies.filter(image_width__gt=0).count()
-
-        return images_count
+        return self.replies.filter(image_width__gt=0).count()
 
     def can_bump(self):
         """Check if the thread can be bumped by replying"""
 
         post_count = self.get_reply_count()
 
         return post_count <= settings.MAX_POSTS_PER_THREAD
 
-    def bump(self):
-        """Bump (move to up) thread"""
+    def delete_with_posts(self):
+        """Completely delete thread"""
 
-        if self.can_bump():
-            self.bump_time = timezone.now()
+        if self.replies.count() > 0:
+            map(Post.objects.delete_post, self.replies.all())
+
+        self.delete()
 
     def get_last_replies(self):
+        """Get last replies, not including opening post"""
+
         if settings.LAST_REPLIES_COUNT > 0:
             reply_count = self.get_reply_count()
 
             if reply_count > 0:
                 reply_count_to_show = min(settings.LAST_REPLIES_COUNT,
-                                          reply_count)
+                                          reply_count - 1)
                 last_replies = self.replies.all().order_by('pub_time')[
                                reply_count - reply_count_to_show:]
 
                 return last_replies
 
-    def get_tags(self):
-        """Get a sorted tag list"""
+    def get_replies(self):
+        """Get sorted thread posts"""
 
-        return self.tags.order_by('name')
+        return self.replies.all().order_by('pub_time')
 
-    def get_sorted_referenced_posts(self):
-        return self.referenced_posts.order_by('id')
+    def add_tag(self, tag):
+        """Connect thread to a tag and tag to a thread"""
 
-    def is_referenced(self):
-        return self.referenced_posts.all().exists()
+        self.tags.add(tag)
+        tag.threads.add(self)
+
+    def __unicode__(self):
+        return str(self.get_replies()[0].id)
  No newline at end of file

boards/models/tag.py

@@ -1,83 +1,84 b''
-from boards.models import Post
+from boards.models import Thread
 from django.db import models
 from django.db.models import Count
 
 __author__ = 'neko259'
 
 TAG_FONT_MULTIPLIER = 0.1
 MAX_TAG_FONT = 10
 OPENING_POST_POPULARITY_WEIGHT = 2
 
 
 class TagManager(models.Manager):
 
     def get_not_empty_tags(self):
         tags = self.annotate(Count('threads')) \
             .filter(threads__count__gt=0).order_by('name')
 
         return tags
 
 
 class Tag(models.Model):
     """
-    A tag is a text node assigned to the post. The tag serves as a board
-    section. There can be multiple tags for each message
+    A tag is a text node assigned to the thread. The tag serves as a board
+    section. There can be multiple tags for each thread
     """
 
     objects = TagManager()
 
     class Meta:
         app_label = 'boards'
 
     name = models.CharField(max_length=100)
-    threads = models.ManyToManyField('Post', null=True,
+    threads = models.ManyToManyField(Thread, null=True,
                                      blank=True, related_name='tag+')
     linked = models.ForeignKey('Tag', null=True, blank=True)
 
     def __unicode__(self):
         return self.name
 
     def is_empty(self):
         return self.get_post_count() == 0
 
     def get_post_count(self):
         return self.threads.count()
 
-    def get_popularity(self):
-        posts_with_tag = Post.objects.get_threads(tag=self)
-        reply_count = 0
-        for post in posts_with_tag:
-            reply_count += post.get_reply_count()
-            reply_count += OPENING_POST_POPULARITY_WEIGHT
-
-        return reply_count
+    # TODO Reenable this method after migration
+    # def get_popularity(self):
+    #     posts_with_tag = Thread.objects.get_threads(tag=self)
+    #     reply_count = 0
+    #     for post in posts_with_tag:
+    #         reply_count += post.get_reply_count()
+    #         reply_count += OPENING_POST_POPULARITY_WEIGHT
+    #
+    #     return reply_count
 
     def get_linked_tags(self):
         tag_list = []
         self.get_linked_tags_list(tag_list)
 
         return tag_list
 
     def get_linked_tags_list(self, tag_list=[]):
         """
         Returns the list of tags linked to current. The list can be got
         through returned value or tag_list parameter
         """
 
         linked_tag = self.linked
 
         if linked_tag and not (linked_tag in tag_list):
             tag_list.append(linked_tag)
 
             linked_tag.get_linked_tags_list(tag_list)
 
     def get_font_value(self):
         """Get tag font value to differ most popular tags in the list"""
 
         post_count = self.get_post_count()
         if post_count > MAX_TAG_FONT:
             post_count = MAX_TAG_FONT
 
         font_value = str(1 + (post_count - 1) * TAG_FONT_MULTIPLIER)
 
         return font_value
  No newline at end of file

boards/static/css/md/base_page.css

@@ -1,354 +1,354 b''
 html {
     background: #555;
     color: #ffffff;
 }
 
 #admin_panel {
     background: #FF0000;
     color: #00FF00
 }
 
 .input_field {
 
 }
 
 .input_field_name {
 
 }
 
 .input_field_error {
     color: #FF0000;
 }
 
 
 .title {
     font-weight: bold;
     color: #ffcc00;
 }
 
 .link, a {
     color: #afdcec;
 }
 
 .block {
     display: inline-block;
     vertical-align: top;
 }
 
 .tag {
     color: #b4cfec;
 }
 
 .post_id {
     color: #fff380;
 }
 
 .post, .dead_post, #posts-table {
     background: #333;
     margin: 5px;
     padding: 10px;
     border: solid 1px #888;
     clear: left;
     word-wrap: break-word;
 }
 
 .metadata {
     padding-top: 5px;
     margin-top: 10px;
     border-top: solid 1px #666;
     font-size: 0.9em;
     color: #ddd;
 }
 
 .navigation_panel, .tag_info {
     background: #444;
     margin: 5px;
     padding: 10px;
     border: solid 1px #888;
     color: #eee;
 }
 
 .navigation_panel .link {
     border-right: 1px solid #fff;
     font-weight: bold;
     margin-right: 1ex;
     padding-right: 1ex;
 }
 .navigation_panel .link:last-child {
     border-left: 1px solid #fff;
     border-right: none;
     float: right;
     margin-left: 1ex;
     margin-right: 0;
     padding-left: 1ex;
     padding-right: 0;
 }
 
 .navigation_panel::after, .post::after {
     clear: both;
     content: ".";
     display: block;
     height: 0;
     line-height: 0;
     visibility: hidden;
 }
 
 p {
     margin-top: .5em;
     margin-bottom: .5em;
 }
 
 .post-form-w {
     display: table;
     background: #333344;
     border: solid 1px #888;
     color: #fff;
     padding: 10px;
-    margin: 5;
+    margin: 5px;
 }
 
 .form-row {
     display: table-row;
 }
 
 .form-label, .form-input, .form-errors {
     display: table-cell;
 }
 
 .form-label {
     padding: .25em 1ex .25em 0;
     vertical-align: top;
 }
 
 .form-input {
     padding: .25em 0;
 }
 
 .form-errors {
     padding-left: 1ex;
     font-weight: bold;
     vertical-align: middle;
 }
 
 .post-form input, .post-form textarea {
     background: #333;
     color: #fff;
     border: solid 1px;
     padding: 0;
     width: 100%;
     font: medium sans;
 }
 
 .form-submit {
     border-bottom: 2px solid #ddd;
     margin-bottom: .5em;
     padding-bottom: .5em;
 }
 
 .form-title {
     font-weight: bold;
     font-size: 2.5ex;
     text-decoration: underline;
 }
 
 input[type="submit"] {
     background: #222;
     border: solid 1px #fff;
     color: #fff;
 }
 
 blockquote {
     border-left: solid 2px;
     padding-left: 5px;
     color: #B1FB17;
     margin: 0;
 }
 
 .post > .image {
     float: left;
     margin: 0 1ex .5ex 0;
     min-width: 1px;
     text-align: center;
     display: table-row;
 
     height: 150px;
 }
 
 .post > .metadata {
     clear: left;
 }
 
 .get {
     font-weight: bold;
     color: #d55;
 }
 
 * {
     text-decoration: none;
 }
 
 .dead_post {
     background-color: #442222;
 }
 
 .mark_btn {
     padding: 2px 4px;
     border: 1px solid;
 }
 
 .mark_btn:hover {
     background: #555;
 }
 
 .quote {
     color: #92cf38;
     font-style: italic;
 }
 
 .spoiler {
     background: white;
     color: white;
 }
 
 .spoiler:hover {
     color: black;
 }
 
 .comment {
     color: #eb2;
     font-style: italic;
 }
 
 a:hover {
     text-decoration: underline;
 }
 
 .last-replies {
     margin-left: 3ex;
 }
 
 .thread {
     margin-bottom: 3ex;
 }
 
 .post:target {
     border: solid 2px white;
 }
 
 pre{
     white-space:pre-wrap
 }
 
 li {
     list-style-position: inside;
 }
 
 .fancybox-skin {
     position: relative;
     background-color: #fff;
     color: #ddd;
     text-shadow: none;
 }
 
 .fancybox-image {
     border: 1px solid black;
 }
 
 .image-mode-tab {
     background: #444;
     color: #eee;
     display: table;
     margin: 5px;
     padding: 5px;
     border: 1px solid #888;
 }
 
 .image-mode-tab > label {
     margin: 0 1ex;
 }
 
 .image-mode-tab > label > input {
     margin-right: .5ex;
 }
 
 #posts-table {
     margin: 5px;
 }
 
 .tag_info {
     display: table;
 }
 
 .tag_info > h2 {
     margin: 0;
 }
 
 .post-info {
     color: #ddd;
 }
 
 .moderator_info {
     color: #e99d41;
     border: dashed 1px;
     padding: 3px;
 }
 
 .refmap {
     font-size: 0.9em;
     color: #ccc;
     margin-top: 1em;
 }
 
 input[type="submit"]:hover {
         background: #555;
 }
 
 .fav {
     color: yellow;
 }
 
 .not_fav {
     color: #ccc;
 }
 
 .role {
     text-decoration: underline;
 }
 
 .form-email {
     display: none;
 }
 
 .footer {
     margin: 5px;
 }
 
 .bar-value {
     background: rgba(50, 55, 164, 0.45);
     font-size: 0.9em;
     height: 1.5em;
 }
 
 .bar-bg {
     position: relative;
     border: solid 1px #888;
     margin: 5px;
     overflow: hidden;
 }
 
 .bar-text {
     padding: 2px;
     position: absolute;
     left: 0;
     top: 0;
 }
 
 .page_link {
     display: table;
     background: #444;
     margin: 5px;
     border: solid 1px #888;
     padding: 5px;
     font-weight: bolder;
     color: #eee;
 }

boards/templates/boards/post.html

@@ -1,68 +1,68 b''
 {% load i18n %}
 {% load board %}
 
 {% if can_bump %}
     <div class="post" id="{{ post.id }}">
 {% else %}
     <div class="post dead_post" id="{{ post.id }}">
 {% endif %}
 
 {% if post.image %}
     <div class="image">
         <a
                 class="thumb"
                 href="{{ post.image.url }}"><img
                 src="{{ post.image.url_200x150 }}"
                 alt="{{ post.id }}"
                 data-width="{{ post.image_width }}"
                 data-height="{{ post.image_height }}"/>
         </a>
     </div>
 {% endif %}
 <div class="message">
     <div class="post-info">
         <span class="title">{{ post.title }}</span>
         <a class="post_id" href="#{{ post.id }}">
             ({{ post.id }})</a>
         [{{ post.pub_time }}]
         [<a href="#" onclick="javascript:addQuickReply('{{ post.id }}')
             ; return false;">&gt;&gt;</a>]
 
         {% if moderator %}
             <span class="moderator_info">
                             [<a href="{% url 'delete' post_id=post.id %}"
                     >{% trans 'Delete' %}</a>]
                             ({{ post.poster_ip }})
                             [<a href="{% url 'ban' post_id=post.id %}?next={{ request.path }}"
                     >{% trans 'Ban IP' %}</a>]
                         </span>
         {% endif %}
     </div>
     {% autoescape off %}
         {% if truncated %}
             {{ post.text.rendered|truncatewords_html:50 }}
         {% else %}
             {{ post.text.rendered }}
         {% endif %}
     {% endautoescape %}
     {% if post.is_referenced %}
         <div class="refmap">
         {% trans "Replies" %}:
         {% for ref_post in post.get_sorted_referenced_posts %}
         <a href="{% post_url ref_post.id %}">&gt;&gt;{{ ref_post.id }}</a
             >{% if not forloop.last %},{% endif %}
         {% endfor %}
         </div>
     {% endif %}
 </div>
-{% if post.tags.exists %}
+{% if post.thread.tags.exists %}
     <div class="metadata">
         <span class="tags">{% trans 'Tags' %}:
-            {% for tag in post.tags.all %}
+            {% for tag in post.thread.get_tags %}
                 <a class="tag" href="{% url 'tag' tag.name %}">
                     {{ tag.name }}</a>
             {% endfor %}
         </span>
     </div>
 {% endif %}
 </div>

boards/templates/boards/posting_general.html

@@ -1,274 +1,277 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load cache %}
 {% load board %}
 
 {% block head %}
     {% if tag %}
         <title>Neboard - {{ tag.name }}</title>
     {% else %}
         <title>Neboard</title>
     {% endif %}
 
     {% if prev_page %}
         <link rel="next" href="
             {% if tag %}
                 {% url "tag" tag_name=tag page=prev_page %}
             {% else %}
                 {% url "index" page=prev_page %}
             {% endif %}
 	" />
     {% endif %}
     {% if next_page %}
         <link rel="next" href="
             {% if tag %}
                 {% url "tag" tag_name=tag page=next_page %}
             {% else %}
                 {% url "index" page=next_page %}
             {% endif %}
 	" />
     {% endif %}
 
 {% endblock %}
 
 {% block content %}
 
     {% get_current_language as LANGUAGE_CODE %}
 
 {% if tag %}
     <div class="tag_info">
         <h2>
             {% if tag in user.fav_tags.all %}
                 <a href="{% url 'tag_unsubscribe' tag.name %}?next={{ request.path }}"
                    class="fav">★</a>
             {% else %}
                 <a href="{% url 'tag_subscribe' tag.name %}?next={{ request.path }}"
                    class="not_fav">★</a>
             {% endif %}
             #{{ tag.name }}
         </h2>
     </div>
 {% endif %}
 
     {% if threads %}
         {% if prev_page %}
             <div class="page_link">
                 <a href="
             {% if tag %}
                 {% url "tag" tag_name=tag page=prev_page %}
             {% else %}
                 {% url "index" page=prev_page %}
             {% endif %}
                 ">{% trans "Previous page" %}</a>
             </div>
         {% endif %}
 
         {% for thread in threads %}
             {% cache 600 thread_short thread.thread.last_edit_time moderator LANGUAGE_CODE %}
             <div class="thread">
             {% if thread.bumpable %}
-		        <div class="post" id="{{ thread.thread.id }}">
+		        <div class="post" id="{{ thread.op.id }}">
             {% else %}
-		        <div class="post dead_post" id="{{ thread.thread.id }}">
+		        <div class="post dead_post" id="{{ thread.op.id }}">
             {% endif %}
-            {% if thread.thread.image %}
+            {% if thread.op.image %}
                 <div class="image">
                     <a class="thumb"
-                       href="{{ thread.thread.image.url }}"><img
-                            src="{{ thread.thread.image.url_200x150 }}"
-                            alt="{{ thread.thread.id }}"
-                            data-width="{{ thread.thread.image_width }}"
-                            data-height="{{ thread.thread.image_height }}" />
+                       href="{{ thread.op.image.url }}"><img
+                            src="{{ thread.op.image.url_200x150 }}"
+                            alt="{{ thread.op.id }}"
+                            data-width="{{ thread.op.image_width }}"
+                            data-height="{{ thread.op.image_height }}"/>
                     </a>
                 </div>
             {% endif %}
             <div class="message">
                 <div class="post-info">
-                    <span class="title">{{ thread.thread.title }}</span>
-                    <a class="post_id" href="{% url 'thread' thread.thread.id %}"
-                    >({{ thread.thread.id }})</a>
-                    [{{ thread.thread.pub_time }}]
-                    [<a class="link" href="{% url 'thread' thread.thread.id %}#form"
+                    <span class="title">{{ thread.op.title }}</span>
+                    <a class="post_id" href="{% url 'thread' thread.op.id %}"
+                    >({{ thread.op.id }})</a>
+                    [{{ thread.op.pub_time }}]
+                    [<a class="link" href="
+                    {% url 'thread' thread.op.id %}#form"
                         >{% trans "Reply" %}</a>]
 
                     {% if moderator %}
                         <span class="moderator_info">
-                            [<a href="{% url 'delete' post_id=thread.thread.id %}?next={{ request.path }}"
+                            [<a href="
+                            {% url 'delete' post_id=thread.op.id %}?next={{ request.path }}"
                                 >{% trans 'Delete' %}</a>]
                             ({{ thread.thread.poster_ip }})
-                            [<a href="{% url 'ban' post_id=thread.thread.id %}?next={{ request.path }}"
+                            [<a href="
+                            {% url 'ban' post_id=thread.op.id %}?next={{ request.path }}"
                                 >{% trans 'Ban IP' %}</a>]
                         </span>
                     {% endif %}
                 </div>
                 {% autoescape off %}
-                    {{ thread.thread.text.rendered|truncatewords_html:50 }}
+                    {{ thread.op.text.rendered|truncatewords_html:50 }}
                 {% endautoescape %}
-		{% if thread.thread.is_referenced %}
+		{% if thread.op.is_referenced %}
 		    <div class="refmap">
 			{% trans "Replies" %}:
-			{% for ref_post in thread.thread.get_sorted_referenced_posts %}
+			{% for ref_post in thread.op.get_sorted_referenced_posts %}
 			<a href="{% post_url ref_post.id %}">&gt;&gt;{{ ref_post.id }}</a
                     >{% if not forloop.last %},{% endif %}
 			{% endfor %}
 		    </div>
 		{% endif %}
             </div>
             <div class="metadata">
                 {{ thread.thread.get_reply_count }} {% trans 'replies' %},
                 {{ thread.thread.get_images_count }} {% trans 'images' %}.
                 {% if thread.thread.tags %}
                     <span class="tags">
                         {% for tag in thread.thread.get_tags %}
                             <a class="tag" href="
                                     {% url 'tag' tag_name=tag.name %}">
                                 #{{ tag.name }}</a
                                     >{% if not forloop.last %},{% endif %}
                         {% endfor %}
                     </span>
                 {% endif %}
             </div>
             </div>
             {% if thread.last_replies.exists %}
                 <div class="last-replies">
                     {% for post in thread.last_replies %}
                         {% if thread.bumpable %}
 			                <div class="post" id="{{ post.id }}">
                         {% else %}
 			                <div class="post dead_post" id="{{ post.id }}">
                         {% endif %}
                             {% if post.image %}
                                 <div class="image">
                                     <a class="thumb"
                                        href="{{ post.image.url }}"><img
                                             src=" {{ post.image.url_200x150 }}"
                                             alt="{{ post.id }}"
                                             data-width="{{ post.image_width }}"
                                             data-height="{{ post.image_height }}"/>
                                     </a>
                                 </div>
                             {% endif %}
                             <div class="message">
                                 <div class="post-info">
                                     <span class="title">{{ post.title }}</span>
                                     <a class="post_id" href="
-                                {% url 'thread' thread.thread.id %}#{{ post.id }}">
+                                {% url 'thread' thread.op.id %}#{{ post.id }}">
                                         ({{ post.id }})</a>
                                     [{{ post.pub_time }}]
                                 </div>
                                 {% autoescape off %}
                                     {{ post.text.rendered|truncatewords_html:50 }}
                                 {% endautoescape %}
                         </div>
 			    {% if post.is_referenced %}
 				<div class="refmap">
 				    {% trans "Replies" %}:
 				    {% for ref_post in post.get_sorted_referenced_posts %}
 				    <a href="{% post_url ref_post.id %}">&gt;&gt;{{ ref_post.id }}</a
                             >{% if not forloop.last %},{% endif %}
 				    {% endfor %}
 				</div>
 			    {% endif %}
                         </div>
                     {% endfor %}
                 </div>
             {% endif %}
         </div>
         {% endcache %}
         {% endfor %}
 
         {% if next_page %}
             <div class="page_link">
                 <a href="
             {% if tag %}
                 {% url "tag" tag_name=tag page=next_page %}
             {% else %}
                 {% url "index" page=next_page %}
             {% endif %}
                 ">{% trans "Next page" %}</a>
             </div>
         {% endif %}
     {% else %}
         <div class="post">
             {% trans 'No threads exist. Create the first one!' %}</div>
 	{% endif %}
 
     <form enctype="multipart/form-data" method="post">{% csrf_token %}
     <div class="post-form-w">
 
         <div class="form-title">{% trans "Create new thread" %}</div>
         <div class="post-form">
             <div class="form-row">
                 <div class="form-label">{% trans 'Title' %}</div>
                 <div class="form-input">{{ form.title }}</div>
                 <div class="form-errors">{{ form.title.errors }}</div>
             </div>
             <div class="form-row">
                 <div class="form-label">{% trans 'Formatting' %}</div>
                 <div class="form-input" id="mark_panel">
                     <span class="mark_btn" id="quote"><span class="quote">&gt;{% trans 'quote' %}</span></span>
                     <span class="mark_btn" id="italic"><i>{% trans 'italic' %}</i></span>
                     <span class="mark_btn" id="bold"><b>{% trans 'bold' %}</b></span>
                     <span class="mark_btn" id="spoiler"><span class="spoiler">{% trans 'spoiler' %}</span></span>
                     <span class="mark_btn" id="comment"><span class="comment">// {% trans 'comment' %}</span></span>
                 </div>
             </div>
             <div class="form-row">
                 <div class="form-label">{% trans 'Text' %}</div>
                 <div class="form-input">{{ form.text }}</div>
                 <div class="form-errors">{{ form.text.errors }}</div>
             </div>
             <div class="form-row">
                 <div class="form-label">{% trans 'Image' %}</div>
                 <div class="form-input">{{ form.image }}</div>
                 <div class="form-errors">{{ form.image.errors }}</div>
             </div>
             <div class="form-row">
                 <div class="form-label">{% trans 'Tags' %}</div>
                 <div class="form-input">{{ form.tags }}</div>
                 <div class="form-errors">{{ form.tags.errors }}</div>
             </div>
             <div class="form-row form-email">
                 <div class="form-label">{% trans 'e-mail' %}</div>
                 <div class="form-input">{{ form.email }}</div>
                 <div class="form-errors">{{ form.email.errors }}</div>
             </div>
             <div class="form-row">
                 {{ form.captcha }}
                 <div class="form-errors">{{ form.captcha.errors }}</div>
             </div>
             <div class="form-row">
                 <div class="form-errors">{{ form.other.errors }}</div>
             </div>
         </div>
         <div class="form-submit">
             <input type="submit" value="{% trans "Post" %}"/></div>
         <div>
             {% trans 'Tags must be delimited by spaces. Text or image is required.' %}
         </div>
         <div><a href="{% url "staticpage" name="help" %}">
             {% trans 'Text syntax' %}</a></div>
     </div>
     </form>
 
 {% endblock %}
 
 {% block metapanel %}
 
     <span class="metapanel">
-        <b><a href="{% url "authors" %}">Neboard</a> 1.3</b>
+        <b><a href="{% url "authors" %}">Neboard</a> 1.4</b>
         {% trans "Pages:" %}
         {% for page in pages %}
             [<a href="
             {% if tag %}
                 {% url "tag" tag_name=tag page=page %}
             {% else %}
                 {% url "index" page=page %}
             {% endif %}
             ">{{ page }}</a>]
         {% endfor %}
         [<a href="rss/">RSS</a>]
     </span>
 
 {% endblock %}

boards/templates/boards/thread.html

@@ -1,163 +1,161 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load cache %}
 {% load static from staticfiles %}
 {% load board %}
 
 {% block head %}
     <title>Neboard - {{ posts.0.get_title }}</title>
 {% endblock %}
 
 {% block content %}
     {% get_current_language as LANGUAGE_CODE %}
 
     <script src="{% static 'js/thread_update.js' %}"></script>
     <script src="{% static 'js/thread.js' %}"></script>
 
-    {% if posts %}
-        {% cache 600 thread_view posts.0.last_edit_time moderator LANGUAGE_CODE %}
-            {% if bumpable %}
-                <div class="bar-bg">
-                    <div class="bar-value" style="width:{{ bumplimit_progress }}%">
-                    </div>
-                    <div class="bar-text">
-                        {{ posts_left }} {% trans 'posts to bumplimit' %}
-                    </div>
+    {% cache 600 thread_view thread.last_edit_time moderator LANGUAGE_CODE %}
+        {% if bumpable %}
+            <div class="bar-bg">
+                <div class="bar-value" style="width:{{ bumplimit_progress }}%">
                 </div>
-            {% endif %}
-        <div class="thread">
-        {% for post in posts %}
-            {% if bumpable %}
-                <div class="post" id="{{ post.id }}">
-            {% else %}
-                <div class="post dead_post" id="{{ post.id }}">
-            {% endif %}
-            {% if post.image %}
-                <div class="image">
-                    <a
-                            class="thumb"
-                            href="{{ post.image.url }}"><img
-                            src="{{ post.image.url_200x150 }}"
-                            alt="{{ post.id }}"
-                            data-width="{{ post.image_width }}"
-                            data-height="{{ post.image_height }}"/>
-                    </a>
+                <div class="bar-text">
+                    {{ posts_left }} {% trans 'posts to bumplimit' %}
                 </div>
-            {% endif %}
-            <div class="message">
-                <div class="post-info">
-                    <span class="title">{{ post.title }}</span>
-                    <a class="post_id" href="#{{ post.id }}">
-                        ({{ post.id }})</a>
-                    [{{ post.pub_time }}]
-                [<a href="#" onclick="javascript:addQuickReply('{{ post.id }}')
-                    ; return false;">&gt;&gt;</a>]
-
-                    {% if moderator %}
-                        <span class="moderator_info">
-                            [<a href="{% url 'delete' post_id=post.id %}"
-                                >{% trans 'Delete' %}</a>]
-                            ({{ post.poster_ip }})
-                            [<a href="{% url 'ban' post_id=post.id %}?next={{ request.path }}"
-                                >{% trans 'Ban IP' %}</a>]
-                        </span>
-                    {% endif %}
-                </div>
-                {% autoescape off %}
-                {{ post.text.rendered }}
-                {% endautoescape %}
-        {% if post.is_referenced %}
-            <div class="refmap">
-            {% trans "Replies" %}:
-            {% for ref_post in post.get_sorted_referenced_posts %}
-            <a href="{% post_url ref_post.id %}">&gt;&gt;{{ ref_post.id }}</a
-                    >{% if not forloop.last %},{% endif %}
-            {% endfor %}
+            </div>
+        {% endif %}
+    <div class="thread">
+    {% for post in thread.get_replies %}
+        {% if bumpable %}
+            <div class="post" id="{{ post.id }}">
+        {% else %}
+            <div class="post dead_post" id="{{ post.id }}">
+        {% endif %}
+        {% if post.image %}
+            <div class="image">
+                <a
+                        class="thumb"
+                        href="{{ post.image.url }}"><img
+                        src="{{ post.image.url_200x150 }}"
+                        alt="{{ post.id }}"
+                        data-width="{{ post.image_width }}"
+                        data-height="{{ post.image_height }}"/>
+                </a>
             </div>
         {% endif %}
+        <div class="message">
+            <div class="post-info">
+                <span class="title">{{ post.title }}</span>
+                <a class="post_id" href="#{{ post.id }}">
+                    ({{ post.id }})</a>
+                [{{ post.pub_time }}]
+            [<a href="#" onclick="javascript:addQuickReply('{{ post.id }}')
+                ; return false;">&gt;&gt;</a>]
+
+                {% if moderator %}
+                    <span class="moderator_info">
+                        [<a href="{% url 'delete' post_id=post.id %}"
+                            >{% trans 'Delete' %}</a>]
+                        ({{ post.poster_ip }})
+                        [<a href="{% url 'ban' post_id=post.id %}?next={{ request.path }}"
+                            >{% trans 'Ban IP' %}</a>]
+                    </span>
+                {% endif %}
             </div>
-            {% if forloop.first %}
-                <div class="metadata">
-                    <span class="tags">
-                        {% for tag in post.get_tags %}
-                            <a class="tag" href="{% url 'tag' tag.name %}">
-                                #{{ tag.name }}</a
-                                    >{% if not forloop.last %},{% endif %}
-                        {% endfor %}
-                    </span>
-                </div>
-            {% endif %}
-            </div>
+            {% autoescape off %}
+            {{ post.text.rendered }}
+            {% endautoescape %}
+    {% if post.is_referenced %}
+        <div class="refmap">
+        {% trans "Replies" %}:
+        {% for ref_post in post.get_sorted_referenced_posts %}
+        <a href="{% post_url ref_post.id %}">&gt;&gt;{{ ref_post.id }}</a
+                >{% if not forloop.last %},{% endif %}
         {% endfor %}
         </div>
-        {% endcache %}
     {% endif %}
+        </div>
+        {% if forloop.first %}
+            <div class="metadata">
+                <span class="tags">
+                    {% for tag in thread.get_tags %}
+                        <a class="tag" href="{% url 'tag' tag.name %}">
+                            #{{ tag.name }}</a
+                                >{% if not forloop.last %},{% endif %}
+                    {% endfor %}
+                </span>
+            </div>
+        {% endif %}
+        </div>
+    {% endfor %}
+    </div>
+    {% endcache %}
 
     <form id="form" enctype="multipart/form-data" method="post"
             >{% csrf_token %}
         <div class="post-form-w">
         <div class="form-title">{% trans "Reply to thread" %} #{{ posts.0.id }}</div>
             <div class="post-form">
                 <div class="form-row">
                     <div class="form-label">{% trans 'Title' %}</div>
                     <div class="form-input">{{ form.title }}</div>
                     <div class="form-errors">{{ form.title.errors }}</div>
                 </div>
                 <div class="form-row">
                     <div class="form-label">{% trans 'Formatting' %}</div>
                     <div class="form-input" id="mark_panel">
                         <span class="mark_btn" id="quote"><span class="quote">&gt;{% trans 'quote' %}</span></span>
                         <span class="mark_btn" id="italic"><i>{% trans 'italic' %}</i></span>
                         <span class="mark_btn" id="bold"><b>{% trans 'bold' %}</b></span>
                         <span class="mark_btn" id="spoiler"><span class="spoiler">{% trans 'spoiler' %}</span></span>
                         <span class="mark_btn" id="comment"><span class="comment">// {% trans 'comment' %}</span></span>
                     </div>
                 </div>
                 <div class="form-row">
                     <div class="form-label">{% trans 'Text' %}</div>
                     <div class="form-input">{{ form.text }}</div>
                     <div class="form-errors">{{ form.text.errors }}</div>
                 </div>
                 <div class="form-row">
                     <div class="form-label">{% trans 'Image' %}</div>
                     <div class="form-input">{{ form.image }}</div>
                     <div class="form-errors">{{ form.image.errors }}</div>
                 </div>
                 <div class="form-row form-email">
                     <div class="form-label">{% trans 'e-mail' %}</div>
                     <div class="form-input">{{ form.email }}</div>
                     <div class="form-errors">{{ form.email.errors }}</div>
                 </div>
                 <div class="form-row">
                     {{ form.captcha }}
                     <div class="form-errors">{{ form.captcha.errors }}</div>
                 </div>
                 <div class="form-row">
                     <div class="form-errors">{{ form.other.errors }}</div>
                 </div>
             </div>
 
             <div class="form-submit"><input type="submit"
                                             value="{% trans "Post" %}"/></div>
             <div><a href="{% url "staticpage" name="help" %}">
                 {% trans 'Text syntax' %}</a></div>
         </div>
     </form>
 
 {% endblock %}
 
 {% block metapanel %}
 
     {% get_current_language as LANGUAGE_CODE %}
 
     <span class="metapanel" data-last-update="{{ last_update }}">
-        {% cache 600 thread_meta posts.0.last_edit_time moderator LANGUAGE_CODE %}
-            <span id="reply-count">{{ posts.0.get_reply_count }}</span> {% trans 'replies' %},
-            <span id="image-count">{{ posts.0.get_images_count }}</span> {% trans 'images' %}.
-            {% trans 'Last update: ' %}{{ posts.0.last_edit_time }}
+        {% cache 600 thread_meta thread.last_edit_time moderator LANGUAGE_CODE %}
+            <span id="reply-count">{{ thread.get_reply_count }}</span> {% trans 'replies' %},
+            <span id="image-count">{{ thread.get_images_count }}</span> {% trans 'images' %}.
+            {% trans 'Last update: ' %}{{ thread.last_edit_time }}
             [<a href="rss/">RSS</a>]
         {% endcache %}
     </span>
 
 {% endblock %}

boards/tests.py

@@ -1,218 +1,224 b''
 # coding=utf-8
 from django.test import TestCase
 from django.test.client import Client
 import time
 
 from boards.models import Post, Tag
 from neboard import settings
 
 PAGE_404 = 'boards/404.html'
 
 TEST_TEXT = 'test text'
 
 NEW_THREAD_PAGE = '/'
 THREAD_PAGE_ONE = '/thread/1/'
 THREAD_PAGE = '/thread/'
 TAG_PAGE = '/tag/'
 HTTP_CODE_REDIRECT = 302
 HTTP_CODE_OK = 200
 HTTP_CODE_NOT_FOUND = 404
 
 
 class PostTests(TestCase):
 
     def _create_post(self):
         return Post.objects.create_post(title='title',
                                         text='text')
 
     def test_post_add(self):
         """Test adding post"""
 
         post = self._create_post()
 
-        self.assertIsNotNone(post)
-        self.assertIsNone(post.thread, 'Opening post has a thread')
+        self.assertIsNotNone(post, 'No post was created')
 
     def test_delete_post(self):
         """Test post deletion"""
 
         post = self._create_post()
         post_id = post.id
 
         Post.objects.delete_post(post)
 
         self.assertFalse(Post.objects.filter(id=post_id).exists())
 
     def test_delete_thread(self):
         """Test thread deletion"""
 
-        thread = self._create_post()
+        opening_post = self._create_post()
+        thread = opening_post.thread_new
         reply = Post.objects.create_post("", "", thread=thread)
 
-        Post.objects.delete_post(thread)
+        thread.delete_with_posts()
 
         self.assertFalse(Post.objects.filter(id=reply.id).exists())
 
     def test_post_to_thread(self):
         """Test adding post to a thread"""
 
         op = self._create_post()
-        post = Post.objects.create_post("", "", thread=op)
+        post = Post.objects.create_post("", "", thread=op.thread_new)
 
         self.assertIsNotNone(post, 'Reply to thread wasn\'t created')
-        self.assertEqual(op.last_edit_time, post.pub_time,
+        self.assertEqual(op.thread_new.last_edit_time, post.pub_time,
                          'Post\'s create time doesn\'t match thread last edit'
                          ' time')
 
     def test_delete_posts_by_ip(self):
         """Test deleting posts with the given ip"""
 
         post = self._create_post()
         post_id = post.id
 
         Post.objects.delete_posts_by_ip('0.0.0.0')
 
         self.assertFalse(Post.objects.filter(id=post_id).exists())
 
     def test_get_thread(self):
         """Test getting all posts of a thread"""
 
         opening_post = self._create_post()
 
         for i in range(0, 2):
-            Post.objects.create_post('title', 'text', thread=opening_post)
+            Post.objects.create_post('title', 'text',
+                                     thread=opening_post.thread_new)
 
         thread = Post.objects.get_thread(opening_post.id)
 
-        self.assertEqual(3, len(thread))
+        self.assertEqual(3, thread.replies.count())
 
     def test_create_post_with_tag(self):
         """Test adding tag to post"""
 
         tag = Tag.objects.create(name='test_tag')
         post = Post.objects.create_post(title='title', text='text', tags=[tag])
-        self.assertIsNotNone(post)
+
+        thread = post.thread_new
+        self.assertIsNotNone(post, 'Post not created')
+        self.assertTrue(tag in thread.tags.all(), 'Tag not added to thread')
+        self.assertTrue(thread in tag.threads.all(), 'Thread not added to tag')
 
     def test_thread_max_count(self):
         """Test deletion of old posts when the max thread count is reached"""
 
         for i in range(settings.MAX_THREAD_COUNT + 1):
             self._create_post()
 
         self.assertEqual(settings.MAX_THREAD_COUNT,
                          len(Post.objects.get_threads()))
 
     def test_pages(self):
         """Test that the thread list is properly split into pages"""
 
         for i in range(settings.MAX_THREAD_COUNT):
             self._create_post()
 
         all_threads = Post.objects.get_threads()
 
         posts_in_second_page = Post.objects.get_threads(page=1)
         first_post = posts_in_second_page[0]
 
         self.assertEqual(all_threads[settings.THREADS_PER_PAGE].id,
                          first_post.id)
 
     def test_linked_tag(self):
         """Test adding a linked tag"""
 
         linked_tag = Tag.objects.create(name=u'tag1')
         tag = Tag.objects.create(name=u'tag2', linked=linked_tag)
 
         post = Post.objects.create_post("", "", tags=[tag])
 
-        self.assertTrue(linked_tag in post.tags.all(),
+        self.assertTrue(linked_tag in post.thread_new.tags.all(),
                         'Linked tag was not added')
 
 
 class PagesTest(TestCase):
 
     def test_404(self):
         """Test receiving error 404 when opening a non-existent page"""
 
         tag_name = u'test_tag'
         tag = Tag.objects.create(name=tag_name)
         client = Client()
 
         Post.objects.create_post('title', TEST_TEXT, tags=[tag])
 
         existing_post_id = Post.objects.all()[0].id
         response_existing = client.get(THREAD_PAGE + str(existing_post_id) +
                                        '/')
         self.assertEqual(HTTP_CODE_OK, response_existing.status_code,
                          u'Cannot open existing thread')
 
         response_not_existing = client.get(THREAD_PAGE + str(
             existing_post_id + 1) + '/')
         self.assertEqual(PAGE_404,
                          response_not_existing.templates[0].name,
                          u'Not existing thread is opened')
 
         response_existing = client.get(TAG_PAGE + tag_name + '/')
         self.assertEqual(HTTP_CODE_OK,
                          response_existing.status_code,
                          u'Cannot open existing tag')
 
         response_not_existing = client.get(TAG_PAGE + u'not_tag' + '/')
         self.assertEqual(PAGE_404,
                          response_not_existing.templates[0].name,
                          u'Not existing tag is opened')
 
         reply_id = Post.objects.create_post('', TEST_TEXT,
-                                            thread=Post.objects.all()[0])
+                                            thread=Post.objects.all()[0]
+                                            .thread)
         response_not_existing = client.get(THREAD_PAGE + str(
             reply_id) + '/')
         self.assertEqual(PAGE_404,
                          response_not_existing.templates[0].name,
                          u'Reply is opened as a thread')
 
 
 class FormTest(TestCase):
     def test_post_validation(self):
         """Test the validation of the post form"""
 
         # Disable captcha for the test
         captcha_enabled = settings.ENABLE_CAPTCHA
         settings.ENABLE_CAPTCHA = False
 
         client = Client()
 
         valid_tags = u'tag1 tag_2 тег_3'
         invalid_tags = u'$%_356 ---'
 
         response = client.post(NEW_THREAD_PAGE, {'title': 'test title',
                                                  'text': TEST_TEXT,
                                                  'tags': valid_tags})
         self.assertEqual(response.status_code, HTTP_CODE_REDIRECT,
                          msg='Posting new message failed: got code ' +
                              str(response.status_code))
 
         self.assertEqual(1, Post.objects.count(),
                          msg='No posts were created')
 
         client.post(NEW_THREAD_PAGE, {'text': TEST_TEXT,
                                       'tags': invalid_tags})
         self.assertEqual(1, Post.objects.count(), msg='The validation passed '
                                                       'where it should fail')
 
         # Change posting delay so we don't have to wait for 30 seconds or more
         old_posting_delay = settings.POSTING_DELAY
         # Wait fot the posting delay or we won't be able to post
         settings.POSTING_DELAY = 1
         time.sleep(settings.POSTING_DELAY + 1)
         response = client.post(THREAD_PAGE_ONE, {'text': TEST_TEXT,
                                                  'tags': valid_tags})
         self.assertEqual(HTTP_CODE_REDIRECT, response.status_code,
                          msg=u'Posting new message failed: got code ' +
                              str(response.status_code))
         # Restore posting delay
         settings.POSTING_DELAY = old_posting_delay
 
         self.assertEqual(2, Post.objects.count(),
                          msg=u'No posts were created')
 
         # Restore captcha setting
         settings.ENABLE_CAPTCHA = captcha_enabled

boards/views.py

@@ -1,561 +1,567 b''
 import hashlib
 import json
 import string
 import time
 from datetime import datetime
 import re
 
 from django.core import serializers
 from django.core.urlresolvers import reverse
 from django.http import HttpResponseRedirect
 from django.http.response import HttpResponse
 from django.template import RequestContext
 from django.shortcuts import render, redirect, get_object_or_404
 from django.utils import timezone
 from django.db import transaction
 
 from boards import forms
 import boards
 from boards import utils
 from boards.forms import ThreadForm, PostForm, SettingsForm, PlainErrorList, \
     ThreadCaptchaForm, PostCaptchaForm, LoginForm, ModeratorSettingsForm
 from boards.models import Post, Tag, Ban, User
 from boards.models.post import SETTING_MODERATE, REGEX_REPLY
 from boards.models.user import RANK_USER
 from boards import authors
 from boards.utils import get_client_ip
 import neboard
 
 
 BAN_REASON_SPAM = 'Autoban: spam bot'
 
 
 def index(request, page=0):
     context = _init_default_context(request)
 
     if utils.need_include_captcha(request):
         threadFormClass = ThreadCaptchaForm
         kwargs = {'request': request}
     else:
         threadFormClass = ThreadForm
         kwargs = {}
 
     if request.method == 'POST':
         form = threadFormClass(request.POST, request.FILES,
                                error_class=PlainErrorList, **kwargs)
         form.session = request.session
 
         if form.is_valid():
             return _new_post(request, form)
         if form.need_to_ban:
             # Ban user because he is suspected to be a bot
             _ban_current_user(request)
     else:
         form = threadFormClass(error_class=PlainErrorList, **kwargs)
 
     threads = []
-    for thread in Post.objects.get_threads(page=int(page)):
+    for thread_to_show in Post.objects.get_threads(page=int(page)):
         threads.append({
-            'thread': thread,
-            'bumpable': thread.can_bump(),
-            'last_replies': thread.get_last_replies(),
+            'thread': thread_to_show,
+            'op': thread_to_show.get_replies()[0],
+            'bumpable': thread_to_show.can_bump(),
+            'last_replies': thread_to_show.get_last_replies(),
         })
 
     # TODO Make this generic for tag and threads list pages
     context['threads'] = None if len(threads) == 0 else threads
     context['form'] = form
 
     page_count = Post.objects.get_thread_page_count()
     context['pages'] = range(page_count)
     page = int(page)
     if page < page_count - 1:
         context['next_page'] = str(page + 1)
     if page > 0:
         context['prev_page'] = str(page - 1)
 
     return render(request, 'boards/posting_general.html',
                   context)
 
 
 @transaction.atomic
 def _new_post(request, form, opening_post=None):
     """Add a new post (in thread or as a reply)."""
 
     ip = get_client_ip(request)
     is_banned = Ban.objects.filter(ip=ip).exists()
 
     if is_banned:
         return redirect(you_are_banned)
 
     data = form.cleaned_data
 
     title = data['title']
     text = data['text']
 
     text = _remove_invalid_links(text)
 
     if 'image' in data.keys():
         image = data['image']
     else:
         image = None
 
     tags = []
 
     if not opening_post:
         tag_strings = data['tags']
 
         if tag_strings:
             tag_strings = tag_strings.split(' ')
             for tag_name in tag_strings:
                 tag_name = string.lower(tag_name.strip())
                 if len(tag_name) > 0:
                     tag, created = Tag.objects.get_or_create(name=tag_name)
                     tags.append(tag)
+        post_thread = None
+    else:
+        post_thread = opening_post.thread_new
 
     post = Post.objects.create_post(title=title, text=text, ip=ip,
-                                    thread=opening_post, image=image,
+                                    thread=post_thread, image=image,
                                     tags=tags, user=_get_user(request))
 
     thread_to_show = (opening_post.id if opening_post else post.id)
 
     if opening_post:
         return redirect(reverse(thread, kwargs={'post_id': thread_to_show}) +
                         '#' + str(post.id))
     else:
         return redirect(thread, post_id=thread_to_show)
 
 
 def tag(request, tag_name, page=0):
     """
     Get all tag threads. Threads are split in pages, so some page is
     requested. Default page is 0.
     """
 
     tag = get_object_or_404(Tag, name=tag_name)
     threads = []
-    for thread in Post.objects.get_threads(tag=tag, page=int(page)):
+    for thread_to_show in Post.objects.get_threads(page=int(page)):
         threads.append({
-            'thread': thread,
-            'bumpable': thread.can_bump(),
-            'last_replies': thread.get_last_replies(),
-        })
+            'thread': thread_to_show,
+            'op': thread_to_show.get_replies()[0],
+            'bumpable': thread_to_show.can_bump(),
+            'last_replies': thread_to_show.get_last_replies(),
+            })
 
     if request.method == 'POST':
         form = ThreadForm(request.POST, request.FILES,
                           error_class=PlainErrorList)
         form.session = request.session
 
         if form.is_valid():
             return _new_post(request, form)
         if form.need_to_ban:
             # Ban user because he is suspected to be a bot
             _ban_current_user(request)
     else:
         form = forms.ThreadForm(initial={'tags': tag_name},
                                 error_class=PlainErrorList)
 
     context = _init_default_context(request)
     context['threads'] = None if len(threads) == 0 else threads
     context['tag'] = tag
 
     page_count = Post.objects.get_thread_page_count(tag=tag)
     context['pages'] = range(page_count)
     page = int(page)
     if page < page_count - 1:
         context['next_page'] = str(page + 1)
     if page > 0:
         context['prev_page'] = str(page - 1)
 
     context['form'] = form
 
     return render(request, 'boards/posting_general.html',
                   context)
 
 
 def thread(request, post_id):
     """Get all thread posts"""
 
     if utils.need_include_captcha(request):
         postFormClass = PostCaptchaForm
         kwargs = {'request': request}
     else:
         postFormClass = PostForm
         kwargs = {}
 
     if request.method == 'POST':
         form = postFormClass(request.POST, request.FILES,
                              error_class=PlainErrorList, **kwargs)
         form.session = request.session
 
         opening_post = get_object_or_404(Post, id=post_id)
         if form.is_valid():
             return _new_post(request, form, opening_post)
         if form.need_to_ban:
             # Ban user because he is suspected to be a bot
             _ban_current_user(request)
     else:
         form = postFormClass(error_class=PlainErrorList, **kwargs)
 
-    posts = Post.objects.get_thread(post_id)
+    thread_to_show = get_object_or_404(Post, id=post_id).thread_new
 
     context = _init_default_context(request)
 
-    context['posts'] = posts
+    posts = thread_to_show.get_replies()
     context['form'] = form
-    context['bumpable'] = posts[0].can_bump()
+    context['bumpable'] = thread_to_show.can_bump()
     if context['bumpable']:
-        context['posts_left'] = neboard.settings.MAX_POSTS_PER_THREAD - len(
-            posts)
+        context['posts_left'] = neboard.settings.MAX_POSTS_PER_THREAD - posts\
+            .count()
         context['bumplimit_progress'] = str(
             float(context['posts_left']) /
             neboard.settings.MAX_POSTS_PER_THREAD * 100)
-    context["last_update"] = _datetime_to_epoch(posts[0].last_edit_time)
+    context["last_update"] = _datetime_to_epoch(thread_to_show.last_edit_time)
+    context["thread"] = thread_to_show
 
     return render(request, 'boards/thread.html', context)
 
 
 def login(request):
     """Log in with user id"""
 
     context = _init_default_context(request)
 
     if request.method == 'POST':
         form = LoginForm(request.POST, request.FILES,
                          error_class=PlainErrorList)
         form.session = request.session
 
         if form.is_valid():
             user = User.objects.get(user_id=form.cleaned_data['user_id'])
             request.session['user_id'] = user.id
             return redirect(index)
 
     else:
         form = LoginForm()
 
     context['form'] = form
 
     return render(request, 'boards/login.html', context)
 
 
 def settings(request):
     """User's settings"""
 
     context = _init_default_context(request)
     user = _get_user(request)
     is_moderator = user.is_moderator()
 
     if request.method == 'POST':
         with transaction.commit_on_success():
             if is_moderator:
                 form = ModeratorSettingsForm(request.POST,
                                              error_class=PlainErrorList)
             else:
                 form = SettingsForm(request.POST, error_class=PlainErrorList)
 
             if form.is_valid():
                 selected_theme = form.cleaned_data['theme']
 
                 user.save_setting('theme', selected_theme)
 
                 if is_moderator:
                     moderate = form.cleaned_data['moderate']
                     user.save_setting(SETTING_MODERATE, moderate)
 
             return redirect(settings)
     else:
         selected_theme = _get_theme(request)
 
         if is_moderator:
             form = ModeratorSettingsForm(initial={'theme': selected_theme,
                                          'moderate': context['moderator']},
                                          error_class=PlainErrorList)
         else:
             form = SettingsForm(initial={'theme': selected_theme},
                                 error_class=PlainErrorList)
 
     context['form'] = form
 
     return render(request, 'boards/settings.html', context)
 
 
 def all_tags(request):
     """All tags list"""
 
     context = _init_default_context(request)
     context['all_tags'] = Tag.objects.get_not_empty_tags()
 
     return render(request, 'boards/tags.html', context)
 
 
 def jump_to_post(request, post_id):
     """Determine thread in which the requested post is and open it's page"""
 
     post = get_object_or_404(Post, id=post_id)
 
     if not post.thread:
         return redirect(thread, post_id=post.id)
     else:
         return redirect(reverse(thread, kwargs={'post_id': post.thread.id})
                         + '#' + str(post.id))
 
 
 def authors(request):
     """Show authors list"""
 
     context = _init_default_context(request)
     context['authors'] = boards.authors.authors
 
     return render(request, 'boards/authors.html', context)
 
 
 @transaction.atomic
 def delete(request, post_id):
     """Delete post"""
 
     user = _get_user(request)
     post = get_object_or_404(Post, id=post_id)
 
     if user.is_moderator():
         # TODO Show confirmation page before deletion
         Post.objects.delete_post(post)
 
     if not post.thread:
         return _redirect_to_next(request)
     else:
         return redirect(thread, post_id=post.thread.id)
 
 
 @transaction.atomic
 def ban(request, post_id):
     """Ban user"""
 
     user = _get_user(request)
     post = get_object_or_404(Post, id=post_id)
 
     if user.is_moderator():
         # TODO Show confirmation page before ban
         ban, created = Ban.objects.get_or_create(ip=post.poster_ip)
         if created:
             ban.reason = 'Banned for post ' + str(post_id)
             ban.save()
 
     return _redirect_to_next(request)
 
 
 def you_are_banned(request):
     """Show the page that notifies that user is banned"""
 
     context = _init_default_context(request)
 
     ban = get_object_or_404(Ban, ip=utils.get_client_ip(request))
     context['ban_reason'] = ban.reason
     return render(request, 'boards/staticpages/banned.html', context)
 
 
 def page_404(request):
     """Show page 404 (not found error)"""
 
     context = _init_default_context(request)
     return render(request, 'boards/404.html', context)
 
 
 @transaction.atomic
 def tag_subscribe(request, tag_name):
     """Add tag to favorites"""
 
     user = _get_user(request)
     tag = get_object_or_404(Tag, name=tag_name)
 
     if not tag in user.fav_tags.all():
         user.add_tag(tag)
 
     return _redirect_to_next(request)
 
 
 @transaction.atomic
 def tag_unsubscribe(request, tag_name):
     """Remove tag from favorites"""
 
     user = _get_user(request)
     tag = get_object_or_404(Tag, name=tag_name)
 
     if tag in user.fav_tags.all():
         user.remove_tag(tag)
 
     return _redirect_to_next(request)
 
 
 def static_page(request, name):
     """Show a static page that needs only tags list and a CSS"""
 
     context = _init_default_context(request)
     return render(request, 'boards/staticpages/' + name + '.html', context)
 
 
 def api_get_post(request, post_id):
     """
     Get the JSON of a post. This can be
     used as and API for external clients.
     """
 
     post = get_object_or_404(Post, id=post_id)
 
     json = serializers.serialize("json", [post], fields=(
         "pub_time", "_text_rendered", "title", "text", "image",
         "image_width", "image_height", "replies", "tags"
     ))
 
     return HttpResponse(content=json)
 
 
 @transaction.atomic
 def api_get_threaddiff(request, thread_id, last_update_time):
     """Get posts that were changed or added since time"""
 
     thread = get_object_or_404(Post, id=thread_id)
 
     filter_time = datetime.fromtimestamp(float(last_update_time) / 1000000,
                                          timezone.get_current_timezone())
 
     json_data = {
         'added': [],
         'updated': [],
         'last_update': None,
     }
     added_posts = Post.objects.filter(thread=thread,
                                       pub_time__gt=filter_time)\
         .order_by('pub_time')
     updated_posts = Post.objects.filter(thread=thread,
                                         pub_time__lte=filter_time,
                                         last_edit_time__gt=filter_time)
     for post in added_posts:
         json_data['added'].append(get_post(request, post.id).content.strip())
     for post in updated_posts:
         json_data['updated'].append(get_post(request, post.id).content.strip())
     json_data['last_update'] = _datetime_to_epoch(thread.last_edit_time)
 
     return HttpResponse(content=json.dumps(json_data))
 
 
 def get_post(request, post_id):
     """Get the html of a post. Used for popups."""
 
     post = get_object_or_404(Post, id=post_id)
     thread = post.thread
     if not thread:
         thread = post
 
     context = RequestContext(request)
     context["post"] = post
     context["can_bump"] = thread.can_bump()
     if "truncated" in request.GET:
         context["truncated"] = True
 
     return render(request, 'boards/post.html', context)
 
 
 def _get_theme(request, user=None):
     """Get user's CSS theme"""
 
     if not user:
         user = _get_user(request)
     theme = user.get_setting('theme')
     if not theme:
         theme = neboard.settings.DEFAULT_THEME
 
     return theme
 
 
 def _init_default_context(request):
     """Create context with default values that are used in most views"""
 
     context = RequestContext(request)
 
     user = _get_user(request)
     context['user'] = user
     context['tags'] = user.get_sorted_fav_tags()
 
     theme = _get_theme(request, user)
     context['theme'] = theme
     context['theme_css'] = 'css/' + theme + '/base_page.css'
 
     # This shows the moderator panel
     moderate = user.get_setting(SETTING_MODERATE)
     if moderate == 'True':
         context['moderator'] = user.is_moderator()
     else:
         context['moderator'] = False
 
     return context
 
 
 def _get_user(request):
     """
     Get current user from the session. If the user does not exist, create
     a new one.
     """
 
     session = request.session
     if not 'user_id' in session:
         request.session.save()
 
         md5 = hashlib.md5()
         md5.update(session.session_key)
         new_id = md5.hexdigest()
 
         time_now = timezone.now()
         user = User.objects.create(user_id=new_id, rank=RANK_USER,
                                    registration_time=time_now)
 
         session['user_id'] = user.id
     else:
         user = User.objects.get(id=session['user_id'])
 
     return user
 
 
 def _redirect_to_next(request):
     """
     If a 'next' parameter was specified, redirect to the next page. This is
     used when the user is required to return to some page after the current
     view has finished its work.
     """
 
     if 'next' in request.GET:
         next_page = request.GET['next']
         return HttpResponseRedirect(next_page)
     else:
         return redirect(index)
 
 
 @transaction.atomic
 def _ban_current_user(request):
     """Add current user to the IP ban list"""
 
     ip = utils.get_client_ip(request)
     ban, created = Ban.objects.get_or_create(ip=ip)
     if created:
         ban.can_read = False
         ban.reason = BAN_REASON_SPAM
     ban.save()
 
 
 def _remove_invalid_links(text):
     """
     Replace invalid links in posts so that they won't be parsed.
     Invalid links are links to non-existent posts
     """
 
     for reply_number in re.finditer(REGEX_REPLY, text):
         post_id = reply_number.group(1)
         post = Post.objects.filter(id=post_id)
         if not post.exists():
             text = string.replace(text, '>>' + post_id, post_id)
 
     return text
 
 
 def _datetime_to_epoch(datetime):
     return int(time.mktime(timezone.localtime(
         datetime,timezone.get_current_timezone()).timetuple())
                * 1000000 + datetime.microsecond)

todo.txt

@@ -1,48 +1,48 b''
 = Features =
 [DONE] Connecting tags to each other
 [DONE] Connect posts to the replies (in messages), get rid of the JS reply map
 [DONE] Better django admin pages to simplify admin operations
 [DONE] Regen script to update all posts
 [DONE] Remove jump links from refmaps
 [DONE] Ban reasons. Split bans into 2 types "read-only" and "read
 denied". Use second only for autoban for spam
 [DONE] Clean up tests and make them run ALWAYS
 [DONE] Use transactions in tests
 [DONE] Thread autoupdate (JS + API)
+[IN PROGRESS] Split up post model into post and thread,
+and move everything that is used only in 1st post to thread model.
 
 [NOT STARTED] Tree view (JS)
 [NOT STARTED] Adding tags to images filename
 [NOT STARTED] Federative network for s2s communication
 [NOT STARTED] XMPP gate
 [NOT STARTED] Bitmessage gate
 [NOT STARTED] Notification engine
 [NOT STARTED] Javascript disabling engine
 [NOT STARTED] Group tags by first letter in all tags list
 [NOT STARTED] Show board speed in the lower panel (posts per day)
 [NOT STARTED] Character counter in the post field
 [NOT STARTED] Save image thumbnails size to the separate field
 [NOT STARTED] Whitelist functionality. Permin autoban of an address
-[NOT STARTED] Split up post model into post and thread,
-and move everything that is used only in 1st post to thread model.
 [NOT STARTED] Statistics module. Count views (optional, may result in bad
  performance), posts per day/week/month, users (or IPs)
 [NOT STARTED] Quote button next to "reply" for posts in thread to include full
 post or its part (delimited by N characters) into quote of the new post.
 [NOT STARTED] Ban confirmation page with reason
 [NOT STARTED] Post deletion confirmation page
 [NOT STARTED] Moderating page. Tags editing and adding
 [NOT STARTED] Get thread graph image using pygraphviz
 [NOT STARTED] Creating post via AJAX without reloading page
 [NOT STARTED] Subscribing to tag via AJAX
 
 = Bugs =
 [DONE] Fix bug with creating threads from tag view
 [DONE] Quote characters within quote causes quote parsing to fail
 
 [IN PROGRESS] Replies, images, last update time in bottom panel doesn't change when
 thread updates
 
 = Testing =
 [NOT STARTED] Make tests for every view
 [NOT STARTED] Make tests for every model
 [NOT STARTED] Make tests for every form