Adapt to django-2.0

boards/admin.py

@@ -1,193 +1,193 b''
-from boards.abstracts.sticker_factory import StickerFactory
+from django.contrib import admin
+from django.urls import reverse
+from django.utils.translation import ugettext_lazy as _
+
+from boards.models import Post, Tag, Ban, Thread, Banner, Attachment, \
+    KeyPair, GlobalId, TagAlias, STATUS_ACTIVE
 from boards.models.attachment import FILE_TYPES_IMAGE, AttachmentSticker, \
     StickerPack
-from django.contrib import admin
-from django.utils.translation import ugettext_lazy as _
-from django.core.urlresolvers import reverse
-from boards.models import Post, Tag, Ban, Thread, Banner, Attachment, \
-        KeyPair, GlobalId, TagAlias, STATUS_ACTIVE
 from boards.models.source import ThreadSource
 
 
 @admin.register(Post)
 class PostAdmin(admin.ModelAdmin):
 
     list_display = ('id', 'title', 'text', 'poster_ip', 'linked_images',
             'foreign', 'tags')
     list_filter = ('pub_time',)
     search_fields = ('id', 'title', 'text', 'poster_ip')
     exclude = ('referenced_posts', 'refmap', 'images', 'global_id')
     readonly_fields = ('poster_ip', 'thread', 'linked_images',
             'attachments', 'uid', 'url', 'pub_time', 'opening', 'linked_global_id',
             'foreign', 'tags')
 
     def ban_poster(self, request, queryset):
         bans = 0
         for post in queryset:
             poster_ip = post.poster_ip
             ban, created = Ban.objects.get_or_create(ip=poster_ip)
             if created:
                 bans += 1
         self.message_user(request, _('{} posters were banned').format(bans))
 
     def ban_latter_with_delete(self, request, queryset):
         bans = 0
         hidden = 0
         for post in queryset:
             poster_ip = post.poster_ip
             ban, created = Ban.objects.get_or_create(ip=poster_ip)
             if created:
                 bans += 1
             posts = Post.objects.filter(poster_ip=poster_ip, id__gte=post.id)
             hidden += posts.count()
             posts.delete()
         self.message_user(request, _('{} posters were banned, {} messages were removed.').format(bans, hidden))
     ban_latter_with_delete.short_description = _('Ban user and delete posts starting from this one and later')
 
     def linked_images(self, obj: Post):
         images = obj.attachments.filter(mimetype__in=FILE_TYPES_IMAGE)
         image_urls = ['<a href="{}"><img src="{}" /></a>'.format(
             reverse('admin:%s_%s_change' % (image._meta.app_label,
                                             image._meta.model_name),
                     args=[image.id]), image.get_thumb_url()) for image in images]
         return ', '.join(image_urls)
     linked_images.allow_tags = True
 
     def linked_global_id(self, obj: Post):
         global_id = obj.global_id
         if global_id is not None:
             return '<a href="{}">{}</a>'.format(
                 reverse('admin:%s_%s_change' % (global_id._meta.app_label,
                                                 global_id._meta.model_name),
                         args=[global_id.id]), str(global_id))
     linked_global_id.allow_tags = True
 
     def tags(self, obj: Post):
         return ', '.join([tag.get_name() for tag in obj.get_tags()])
 
     def save_model(self, request, obj, form, change):
         obj.save()
         obj.clear_cache()
 
     def foreign(self, obj: Post):
         return obj is not None and obj.global_id is not None and\
                 not obj.global_id.is_local()
 
     actions = ['ban_poster', 'ban_latter_with_delete']
 
 
 @admin.register(Tag)
 class TagAdmin(admin.ModelAdmin):
     def thread_count(self, obj: Tag) -> int:
         return obj.get_thread_count()
 
     def display_children(self, obj: Tag):
         return ', '.join([str(child) for child in obj.get_children().all()])
 
     def name(self, obj: Tag):
         return obj.get_name()
 
     def save_model(self, request, obj, form, change):
         super().save_model(request, obj, form, change)
         for thread in obj.get_threads().all():
             thread.refresh_tags()
 
     list_display = ('name', 'thread_count', 'display_children')
     search_fields = ('id',)
     readonly_fields = ('name',)
 
 
 @admin.register(TagAlias)
 class TagAliasAdmin(admin.ModelAdmin):
     list_display = ('locale', 'name', 'parent')
     list_filter = ('locale',)
     search_fields = ('name',)
 
 
 @admin.register(Thread)
 class ThreadAdmin(admin.ModelAdmin):
 
     def title(self, obj: Thread) -> str:
         return obj.get_opening_post().get_title()
 
     def reply_count(self, obj: Thread) -> int:
         return obj.get_reply_count()
 
     def ip(self, obj: Thread):
         return obj.get_opening_post().poster_ip
 
     def display_tags(self, obj: Thread):
         return ', '.join([str(tag) for tag in obj.get_tags().all()])
 
     def op(self, obj: Thread):
         return obj.get_opening_post_id()
 
     # Save parent tags when editing tags
     def save_related(self, request, form, formsets, change):
         super().save_related(request, form, formsets, change)
         form.instance.refresh_tags()
 
     def save_model(self, request, obj, form, change):
         op = obj.get_opening_post()
         obj.save()
         op.clear_cache()
 
     list_display = ('id', 'op', 'title', 'reply_count', 'status', 'ip',
             'display_tags')
     list_filter = ('bump_time', 'status')
     search_fields = ('id', 'title')
     filter_horizontal = ('tags',)
 
 
 @admin.register(KeyPair)
 class KeyPairAdmin(admin.ModelAdmin):
     list_display = ('public_key', 'primary')
     list_filter = ('primary',)
     search_fields = ('public_key',)
 
 
 @admin.register(Ban)
 class BanAdmin(admin.ModelAdmin):
     list_display = ('ip', 'can_read')
     list_filter = ('can_read',)
     search_fields = ('ip',)
 
 
 @admin.register(Banner)
 class BannerAdmin(admin.ModelAdmin):
     list_display = ('title', 'text')
 
 
 @admin.register(Attachment)
 class AttachmentAdmin(admin.ModelAdmin):
     list_display = ('__str__', 'mimetype', 'file', 'url')
 
 
 @admin.register(AttachmentSticker)
 class AttachmentStickerAdmin(admin.ModelAdmin):
     search_fields = ('name',)
 
 
 @admin.register(StickerPack)
 class StickerPackAdmin(admin.ModelAdmin):
     search_fields = ('name',)
 
 
 @admin.register(GlobalId)
 class GlobalIdAdmin(admin.ModelAdmin):
     def is_linked(self, obj):
         return Post.objects.filter(global_id=obj).exists()
 
     list_display = ('__str__', 'is_linked',)
     readonly_fields = ('content',)
 
 
 @admin.register(ThreadSource)
 class ThreadSourceAdmin(admin.ModelAdmin):
     search_fields = ('name', 'source')
 
     def formfield_for_foreignkey(self, db_field, request, **kwargs):
         if db_field.name == 'thread':
             kwargs['queryset'] = Thread.objects.filter(status=STATUS_ACTIVE)
         return super().formfield_for_foreignkey(db_field, request, **kwargs)
 

boards/mdx_neboard.py

@@ -1,288 +1,289 b''
 # coding=utf-8
+from xml import etree
 
 import re
 import random
 import bbcode
 
 from urllib.parse import unquote
 
 from django.core.exceptions import ObjectDoesNotExist
-from django.core.urlresolvers import reverse
+from django.urls import reverse
 
 import boards
 from boards import settings
 from neboard.settings import ALLOWED_HOSTS
 
 
 __author__ = 'neko259'
 
 
 REFLINK_PATTERN = re.compile(r'^\d+$')
 GLOBAL_REFLINK_PATTERN = re.compile(r'(\w+)::([^:]+)::(\d+)')
 MULTI_NEWLINES_PATTERN = re.compile(r'(\r?\n){2,}')
 ONE_NEWLINE = '\n'
 REGEX_URL = re.compile(r'https?\://[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}(/\S*)?')
 LINE_BREAK_HTML = '<div class="br"></div>'
 SPOILER_SPACE = '&nbsp;'
 
 MAX_SPOILER_MULTIPLIER = 2
 MAX_SPOILER_SPACE_COUNT = 20
 
 
 class TextFormatter():
     """
     An interface for formatter that can be used in the text format panel
     """
 
     def __init__(self):
         pass
 
     name = ''
 
     # Left and right tags for the button preview
     preview_left = ''
     preview_right = ''
 
     # Left and right characters for the textarea input
     format_left = ''
     format_right = ''
 
 
 class AutolinkPattern():
     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(TextFormatter):
     name = '>q'
     preview_left = '<span class="quote">'
     preview_right = '</span>'
 
     format_left = '[quote]'
     format_right = '[/quote]'
 
 
 class SpoilerPattern(TextFormatter):
     name = 'spoiler'
     preview_left = '<span class="spoiler">'
     preview_right = '</span>'
 
     format_left = '[spoiler]'
     format_right = '[/spoiler]'
 
 
 class CommentPattern(TextFormatter):
     name = ''
     preview_left = '<span class="comment">// '
     preview_right = '</span>'
 
     format_left = '[comment]'
     format_right = '[/comment]'
 
 
 # TODO Use <s> tag here
 class StrikeThroughPattern(TextFormatter):
     name = 's'
     preview_left = '<span class="strikethrough">'
     preview_right = '</span>'
 
     format_left = '[s]'
     format_right = '[/s]'
 
 
 class ItalicPattern(TextFormatter):
     name = 'i'
     preview_left = '<i>'
     preview_right = '</i>'
 
     format_left = '[i]'
     format_right = '[/i]'
 
 
 class BoldPattern(TextFormatter):
     name = 'b'
     preview_left = '<b>'
     preview_right = '</b>'
 
     format_left = '[b]'
     format_right = '[/b]'
 
 
 class CodePattern(TextFormatter):
     name = 'code'
     preview_left = '<code>'
     preview_right = '</code>'
 
     format_left = '[code]'
     format_right = '[/code]'
 
 
 class HintPattern(TextFormatter):
     name = 'hint'
     preview_left = '<span class="hint">'
     preview_right = '</span>'
 
     format_left = '[hint]'
     format_right = '[/hint]'
 
 
 def render_reflink(tag_name, value, options, parent, context):
     result = '>>%s' % value
 
     post = None
     if REFLINK_PATTERN.match(value):
         post_id = int(value)
 
         try:
             post = boards.models.Post.objects.get(id=post_id)
 
         except ObjectDoesNotExist:
             pass
     elif GLOBAL_REFLINK_PATTERN.match(value):
         match = GLOBAL_REFLINK_PATTERN.search(value)
         try:
             global_id = boards.models.GlobalId.objects.get(
                 key_type=match.group(1), key=match.group(2),
                 local_id=match.group(3))
             post = global_id.post
         except ObjectDoesNotExist:
             pass
 
     if post is not None:
         result = post.get_link_view()
 
     return result
 
 
 def render_quote(tag_name, value, options, parent, context):
     source = ''
     if 'source' in options:
         source = options['source']
     elif 'quote' in options:
         source = options['quote']
 
     if source:
         result = '<div class="multiquote"><div class="quote-header">%s</div><div class="quote-text">%s</div></div>' % (source, value)
     else:
         # Insert a ">" at the start of every line
         result = '<span class="quote">&gt;{}</span>'.format(
                 value.replace(LINE_BREAK_HTML,
                     '{}&gt;'.format(LINE_BREAK_HTML)))
 
     return result
 
 
 def render_hint(tag_name, value, options, parent, context):
     if 'hint' in options:
         hint = options['hint']
         result = '<span class="hint" title="{}">{}</span>'.format(hint, value)
     else:
         result = value
     return result
 
 
 def render_notification(tag_name, value, options, parent, content):
     username = value.lower()
 
     return '<a href="{}" class="user-cast">@{}</a>'.format(
         reverse('notifications', kwargs={'username': username}), username)
 
 
 def render_tag(tag_name, value, options, parent, context):
     tag_name = value.lower()
 
     try:
         url = boards.models.Tag.objects.get(name=tag_name).get_view()
     except ObjectDoesNotExist:
         url = tag_name
 
     return url
 
 
 def render_spoiler(tag_name, value, options, parent, context):
     if settings.get_bool('Forms', 'AdditionalSpoilerSpaces'):
         text_len = len(value)
         space_count = min(random.randint(0, text_len * MAX_SPOILER_MULTIPLIER),
                 MAX_SPOILER_SPACE_COUNT)
         side_spaces = SPOILER_SPACE * (space_count // 2)
     else:
         side_spaces = ''
     return '<span class="spoiler">{}{}{}</span>'.format(side_spaces,
             value, side_spaces)
 
 
 formatters = [
     QuotePattern,
     SpoilerPattern,
     ItalicPattern,
     BoldPattern,
     CommentPattern,
     StrikeThroughPattern,
     CodePattern,
     HintPattern,
 ]
 
 
 PREPARSE_PATTERNS = {
     r'(?<!>)>>(\d+)': r'[post]\1[/post]',  # Reflink ">>123"
     r'^>([^>].+)': r'[quote]\1[/quote]',  # Quote ">text"
     r'^//\s?(.+)': r'[comment]\1[/comment]',  # Comment "//text"
     r'\B@(\w+)': r'[user]\1[/user]',  # User notification "@user"
 }
 
 for hostname in ALLOWED_HOSTS:
     if hostname != '*':
         PREPARSE_PATTERNS[r'https?://{}/thread/\d+/#(\d+)/?'.format(hostname)] = r'[post]\1[/post]'
         PREPARSE_PATTERNS[r'https?://{}/thread/(\d+)/?'.format(hostname)] = r'[post]\1[/post]'
 
 
 class Parser:
     def __init__(self):
         # The newline hack is added because br's margin does not work in all
         # browsers except firefox, when the div's does.
         self.parser = bbcode.Parser(newline=LINE_BREAK_HTML)
 
         self.parser.add_formatter('post', render_reflink, strip=True)
         self.parser.add_formatter('quote', render_quote, strip=True)
         self.parser.add_formatter('hint', render_hint, strip=True)
         self.parser.add_formatter('user', render_notification, strip=True)
         self.parser.add_formatter('tag', render_tag, strip=True)
         self.parser.add_formatter('spoiler', render_spoiler, strip=True)
         self.parser.add_simple_formatter(
             'comment', '<span class="comment">// %(value)s</span>', strip=True)
         self.parser.add_simple_formatter(
             's', '<span class="strikethrough">%(value)s</span>')
         self.parser.add_simple_formatter('code',
                                          '<pre><code>%(value)s</pre></code>',
                                          render_embedded=False,
                                          escape_html=True,
                                          replace_links=False,
                                          replace_cosmetic=False)
 
     def preparse(self, text):
         """
         Performs manual parsing before the bbcode parser is used.
         Preparsed text is saved as raw and the text before preparsing is lost.
         """
         new_text = MULTI_NEWLINES_PATTERN.sub(ONE_NEWLINE, text)
 
         for key, value in PREPARSE_PATTERNS.items():
             new_text = re.sub(key, value, new_text, flags=re.MULTILINE)
 
         for link in REGEX_URL.findall(text):
             new_text = new_text.replace(link, unquote(link))
 
         return new_text
 
     def parse(self, text):
         return self.parser.format(text)
 
 
 parser = Parser()
 def get_parser():
     return parser

boards/middlewares.py

@@ -1,44 +1,54 b''
 import pytz
 
 from django.shortcuts import redirect
 from django.utils import timezone
 
 from boards import utils
 from boards.models import Ban
 
 SESSION_TIMEZONE = 'django_timezone'
 
 RESPONSE_CONTENT_TYPE = 'Content-Type'
 
 TYPE_HTML = 'text/html'
 
 
 class BanMiddleware:
     """
     This is run before showing the thread. Banned users don't need to see
     anything
     """
 
-    def __init__(self):
-        pass
+    def __init__(self, get_response):
+        self.get_response = get_response
 
-    def process_view(self, request, view_func, view_args, view_kwargs):
+    def __call__(self, request):
+        response = self.get_response(request)
 
         if request.path != '/banned/':
             ip = utils.get_client_ip(request)
             bans = Ban.objects.filter(ip=ip)
 
             if bans.exists():
                 ban = bans[0]
                 if not ban.can_read:
                     return redirect('banned')
 
+        return response
+
 
 class TimezoneMiddleware(object):
-    def process_request(self, request):
+    def __init__(self, get_response):
+        self.get_response = get_response
+
+    def __call__(self, request):
+        response = self.get_response(request)
+
         tzname = request.session.get(SESSION_TIMEZONE)
         if tzname:
             timezone.activate(pytz.timezone(tzname))
         else:
             timezone.deactivate()
 
+        return response
+

boards/migrations/0001_initial.py

@@ -1,112 +1,112 b''
 # -*- coding: utf-8 -*-
 from __future__ import unicode_literals
 
 from django.db import models, migrations
 import boards.models.base
 import boards.thumbs
 
 
 class Migration(migrations.Migration):
 
     dependencies = [
     ]
 
     operations = [
         migrations.CreateModel(
             name='Ban',
             fields=[
                 ('id', models.AutoField(serialize=False, auto_created=True, primary_key=True, verbose_name='ID')),
                 ('ip', models.GenericIPAddressField()),
                 ('reason', models.CharField(max_length=200, default='Auto')),
                 ('can_read', models.BooleanField(default=True)),
             ],
             options={
             },
             bases=(models.Model,),
         ),
         migrations.CreateModel(
             name='Post',
             fields=[
                 ('id', models.AutoField(serialize=False, auto_created=True, primary_key=True, verbose_name='ID')),
                 ('title', models.CharField(max_length=200)),
                 ('pub_time', models.DateTimeField()),
                 ('text', models.TextField(null=True, blank=True)),
                 ('text_markup_type', models.CharField(choices=[('', '--'), ('bbcode', 'bbcode')], max_length=30, default='bbcode')),
                 ('poster_ip', models.GenericIPAddressField()),
                 ('_text_rendered', models.TextField(editable=False)),
                 ('poster_user_agent', models.TextField()),
                 ('last_edit_time', models.DateTimeField()),
                 ('refmap', models.TextField(null=True, blank=True)),
             ],
             options={
                 'ordering': ('id',),
             },
             bases=(models.Model, boards.models.base.Viewable),
         ),
         migrations.CreateModel(
             name='PostImage',
             fields=[
                 ('id', models.AutoField(serialize=False, auto_created=True, primary_key=True, verbose_name='ID')),
                 ('width', models.IntegerField(default=0)),
                 ('height', models.IntegerField(default=0)),
                 ('pre_width', models.IntegerField(default=0)),
                 ('pre_height', models.IntegerField(default=0)),
                 ('image', boards.thumbs.ImageWithThumbsField(height_field='height', width_field='width', blank=True)),
                 ('hash', models.CharField(max_length=36)),
             ],
             options={
                 'ordering': ('id',),
             },
             bases=(models.Model,),
         ),
         migrations.CreateModel(
             name='Tag',
             fields=[
                 ('id', models.AutoField(serialize=False, auto_created=True, primary_key=True, verbose_name='ID')),
                 ('name', models.CharField(db_index=True, max_length=100)),
             ],
             options={
                 'ordering': ('name',),
             },
             bases=(models.Model, boards.models.base.Viewable),
         ),
         migrations.CreateModel(
             name='Thread',
             fields=[
                 ('id', models.AutoField(serialize=False, auto_created=True, primary_key=True, verbose_name='ID')),
                 ('bump_time', models.DateTimeField()),
                 ('last_edit_time', models.DateTimeField()),
                 ('archived', models.BooleanField(default=False)),
                 ('bumpable', models.BooleanField(default=True)),
                 ('replies', models.ManyToManyField(null=True, related_name='tre+', to='boards.Post', blank=True)),
                 ('tags', models.ManyToManyField(to='boards.Tag')),
             ],
             options={
             },
             bases=(models.Model,),
         ),
         migrations.AddField(
             model_name='tag',
             name='threads',
             field=models.ManyToManyField(null=True, related_name='tag+', to='boards.Thread', blank=True),
             preserve_default=True,
         ),
         migrations.AddField(
             model_name='post',
             name='images',
             field=models.ManyToManyField(null=True, db_index=True, related_name='ip+', to='boards.PostImage', blank=True),
             preserve_default=True,
         ),
         migrations.AddField(
             model_name='post',
             name='referenced_posts',
             field=models.ManyToManyField(null=True, db_index=True, related_name='rfp+', to='boards.Post', blank=True),
             preserve_default=True,
         ),
         migrations.AddField(
             model_name='post',
             name='thread_new',
-            field=models.ForeignKey(null=True, default=None, to='boards.Thread'),
+            field=models.ForeignKey(on_delete=models.CASCADE, null=True, default=None, to='boards.Thread'),
             preserve_default=True,
         ),
     ]

boards/migrations/0009_post_thread.py

@@ -1,28 +1,28 b''
 # -*- coding: utf-8 -*-
 from __future__ import unicode_literals
 
 from django.db import models, migrations
 
 
 class Migration(migrations.Migration):
 
     def first_thread_to_thread(apps, schema_editor):
         Post = apps.get_model('boards', 'Post')
         for post in Post.objects.all():
             post.thread = post.threads.first()
             post.save(update_fields=['thread'])
 
 
     dependencies = [
         ('boards', '0008_auto_20150205_1304'),
     ]
 
     operations = [
         migrations.AddField(
             model_name='post',
             name='thread',
-            field=models.ForeignKey(related_name='pt+', to='boards.Thread', default=None, null=True),
+            field=models.ForeignKey(on_delete=models.CASCADE, related_name='pt+', to='boards.Thread', default=None, null=True),
             preserve_default=False,
         ),
         migrations.RunPython(first_thread_to_thread),
     ]

boards/migrations/0010_auto_20150208_1451.py

@@ -1,44 +1,44 b''
 # -*- coding: utf-8 -*-
 from __future__ import unicode_literals
 
 from django.db import models, migrations
 
 
 class Migration(migrations.Migration):
 
     def clean_duplicate_tags(apps, schema_editor):
         Tag = apps.get_model('boards', 'Tag')
         for tag in Tag.objects.all():
             tags_with_same_name = Tag.objects.filter(name=tag.name).all()
             if len(tags_with_same_name) > 1:
                 for tag_duplicate in tags_with_same_name[1:]:
                     threads = tag_duplicate.thread_set.all()
                     for thread in threads:
                         thread.tags.add(tag)
                     tag_duplicate.delete()
 
     dependencies = [
         ('boards', '0009_post_thread'),
     ]
 
     operations = [
         migrations.AlterField(
             model_name='post',
             name='thread',
-            field=models.ForeignKey(to='boards.Thread', related_name='pt+'),
+            field=models.ForeignKey(on_delete=models.CASCADE, to='boards.Thread', related_name='pt+'),
             preserve_default=True,
         ),
         migrations.RunPython(clean_duplicate_tags),
         migrations.AlterField(
             model_name='tag',
             name='name',
             field=models.CharField(db_index=True, unique=True, max_length=100),
             preserve_default=True,
         ),
         migrations.AlterField(
             model_name='tag',
             name='required',
             field=models.BooleanField(db_index=True, default=False),
             preserve_default=True,
         ),
     ]

boards/migrations/0011_notification.py

@@ -1,25 +1,25 b''
 # -*- coding: utf-8 -*-
 from __future__ import unicode_literals
 
 from django.db import models, migrations
 
 
 class Migration(migrations.Migration):
 
     dependencies = [
         ('boards', '0010_auto_20150208_1451'),
     ]
 
     operations = [
         migrations.CreateModel(
             name='Notification',
             fields=[
                 ('id', models.AutoField(serialize=False, verbose_name='ID', auto_created=True, primary_key=True)),
                 ('name', models.TextField()),
-                ('post', models.ForeignKey(to='boards.Post')),
+                ('post', models.ForeignKey(on_delete=models.CASCADE, to='boards.Post')),
             ],
             options={
             },
             bases=(models.Model,),
         ),
     ]

boards/migrations/0014_auto_20150418_1749.py

@@ -1,33 +1,33 b''
 # -*- coding: utf-8 -*-
 from __future__ import unicode_literals
-from django.core.urlresolvers import reverse
+from django.urls import reverse
 
 from django.db import models, migrations
 
 
 class Migration(migrations.Migration):
 
     def update_urls(apps, schema_editor):
         Post = apps.get_model('boards', 'Post')
         for post in Post.objects.all():
             thread = post.thread
             opening_id = Post.objects.filter(threads__in=[thread]).order_by('pub_time').first().id
             post_url = reverse('thread', kwargs={'post_id': opening_id})
             if post.id != opening_id:
                 post_url += '#' + str(post.id)
             post.url = post_url
             post.save(update_fields=['url'])
 
     dependencies = [
         ('boards', '0013_auto_20150408_1210'),
     ]
 
     operations = [
         migrations.AddField(
             model_name='post',
             name='url',
             field=models.TextField(default=''),
             preserve_default=False,
         ),
         migrations.RunPython(update_urls),
     ]

boards/migrations/0018_banner.py

@@ -1,23 +1,23 b''
 # -*- coding: utf-8 -*-
 from __future__ import unicode_literals
 
 from django.db import models, migrations
 
 
 class Migration(migrations.Migration):
 
     dependencies = [
         ('boards', '0017_auto_20150503_1847'),
     ]
 
     operations = [
         migrations.CreateModel(
             name='Banner',
             fields=[
                 ('id', models.AutoField(serialize=False, primary_key=True, verbose_name='ID', auto_created=True)),
                 ('title', models.TextField()),
                 ('text', models.TextField()),
-                ('post', models.ForeignKey(to='boards.Post')),
+                ('post', models.ForeignKey(on_delete=models.CASCADE, to='boards.Post')),
             ],
         ),
     ]

boards/migrations/0026_auto_20150830_2006.py

@@ -1,48 +1,48 b''
 # -*- coding: utf-8 -*-
 from __future__ import unicode_literals
 
 from django.db import models, migrations
 
 
 class Migration(migrations.Migration):
 
     dependencies = [
         ('boards', '0025_auto_20150825_2049'),
     ]
 
     operations = [
         migrations.CreateModel(
             name='GlobalId',
             fields=[
                 ('id', models.AutoField(serialize=False, verbose_name='ID', primary_key=True, auto_created=True)),
                 ('key', models.TextField()),
                 ('key_type', models.TextField()),
                 ('local_id', models.IntegerField()),
             ],
         ),
         migrations.CreateModel(
             name='KeyPair',
             fields=[
                 ('id', models.AutoField(serialize=False, verbose_name='ID', primary_key=True, auto_created=True)),
                 ('public_key', models.TextField()),
                 ('private_key', models.TextField()),
                 ('key_type', models.TextField()),
                 ('primary', models.BooleanField(default=False)),
             ],
         ),
         migrations.CreateModel(
             name='Signature',
             fields=[
                 ('id', models.AutoField(serialize=False, verbose_name='ID', primary_key=True, auto_created=True)),
                 ('key_type', models.TextField()),
                 ('key', models.TextField()),
                 ('signature', models.TextField()),
-                ('global_id', models.ForeignKey(to='boards.GlobalId')),
+                ('global_id', models.ForeignKey(on_delete=models.CASCADE, to='boards.GlobalId')),
             ],
         ),
         migrations.AddField(
             model_name='post',
             name='global_id',
-            field=models.OneToOneField(to='boards.GlobalId', null=True, blank=True),
+            field=models.OneToOneField(on_delete=models.CASCADE, to='boards.GlobalId', null=True, blank=True),
         ),
     ]

boards/migrations/0029_tag_parent.py

@@ -1,19 +1,19 b''
 # -*- coding: utf-8 -*-
 from __future__ import unicode_literals
 
 from django.db import models, migrations
 
 
 class Migration(migrations.Migration):
 
     dependencies = [
         ('boards', '0028_auto_20150928_2211'),
     ]
 
     operations = [
         migrations.AddField(
             model_name='tag',
             name='parent',
-            field=models.ForeignKey(to='boards.Tag', null=True),
+            field=models.ForeignKey(on_delete=models.CASCADE, to='boards.Tag', null=True),
         ),
     ]

boards/migrations/0030_auto_20150929_1816.py

@@ -1,19 +1,19 b''
 # -*- coding: utf-8 -*-
 from __future__ import unicode_literals
 
 from django.db import models, migrations
 
 
 class Migration(migrations.Migration):
 
     dependencies = [
         ('boards', '0029_tag_parent'),
     ]
 
     operations = [
         migrations.AlterField(
             model_name='tag',
             name='parent',
-            field=models.ForeignKey(related_name='children', null=True, to='boards.Tag'),
+            field=models.ForeignKey(on_delete=models.CASCADE, related_name='children', null=True, to='boards.Tag'),
         ),
     ]

boards/migrations/0033_auto_20151014_2224.py

@@ -1,19 +1,19 b''
 # -*- coding: utf-8 -*-
 from __future__ import unicode_literals
 
 from django.db import migrations, models
 
 
 class Migration(migrations.Migration):
 
     dependencies = [
         ('boards', '0032_auto_20151014_2222'),
     ]
 
     operations = [
         migrations.AlterField(
             model_name='tag',
             name='parent',
-            field=models.ForeignKey(blank=True, related_name='children', to='boards.Tag', null=True),
+            field=models.ForeignKey(on_delete=models.CASCADE, blank=True, related_name='children', to='boards.Tag', null=True),
         ),
     ]

boards/models/attachment/__init__.py

@@ -1,185 +1,185 b''
 from itertools import zip_longest
 
 import boards
 from boards.models import STATUS_ARCHIVE
 from django.core.files.images import get_image_dimensions
 from django.db import models
 
 from boards import utils
 from boards.models.attachment.viewers import get_viewers, AbstractViewer, \
     FILE_TYPES_IMAGE
 from boards.utils import get_upload_filename, get_extension, cached_result, \
         get_file_mimetype
 
 
 class AttachmentManager(models.Manager):
     def create_with_hash(self, file):
         file_hash = utils.get_file_hash(file)
         attachment = self.get_existing_duplicate(file_hash, file)
         if not attachment:
             file_type = get_file_mimetype(file)
             attachment = self.create(file=file, mimetype=file_type,
                                      hash=file_hash)
 
         return attachment
 
     def create_from_url(self, url):
         existing = self.filter(url=url)
         if len(existing) > 0:
             attachment = existing[0]
         else:
             attachment = self.create(url=url)
         return attachment
 
     def get_random_images(self, count, tags=None):
         images = self.filter(mimetype__in=FILE_TYPES_IMAGE).exclude(
             attachment_posts__thread__status=STATUS_ARCHIVE)
         if tags is not None:
             images = images.filter(attachment_posts__threads__tags__in=tags)
         return images.order_by('?')[:count]
 
     def get_existing_duplicate(self, file_hash, file):
         """
         Gets an attachment with the same file if one exists.
         """
         existing = self.filter(hash=file_hash)
         attachment = None
         for existing_attachment in existing:
             existing_file = existing_attachment.file
 
             file_chunks = file.chunks()
             existing_file_chunks = existing_file.chunks()
 
             if self._compare_chunks(file_chunks, existing_file_chunks):
                 attachment = existing_attachment
         return attachment
 
     def get_by_alias(self, name):
         pack_name, sticker_name = name.split('/')
         try:
             return AttachmentSticker.objects.get(name=sticker_name, stickerpack__name=pack_name).attachment
         except AttachmentSticker.DoesNotExist:
             return None
 
     def _compare_chunks(self, chunks1, chunks2):
         """
         Compares 2 chunks of different sizes (e.g. first chunk array contains
         all data in 1 chunk, and other one -- in a multiple of smaller ones.
         """
         equal = True
 
         position1 = 0
         position2 = 0
         chunk1 = None
         chunk2 = None
         chunk1ended = False
         chunk2ended = False
         while True:
             if not chunk1 or len(chunk1) <= position1:
                 try:
                     chunk1 = chunks1.__next__()
                     position1 = 0
                 except StopIteration:
                     chunk1ended = True
             if not chunk2 or len(chunk2) <= position2:
                 try:
                     chunk2 = chunks2.__next__()
                     position2 = 0
                 except StopIteration:
                     chunk2ended = True
 
             if chunk1ended and chunk2ended:
                 # Same size chunksm checked for equality previously
                 break
             elif chunk1ended or chunk2ended:
                 # Different size chunks, not equal
                 equal = False
                 break
             elif chunk1[position1] != chunk2[position2]:
                 # Different bytes, not equal
                 equal = False
                 break
             else:
                 position1 += 1
                 position2 += 1
         return equal
 
 
 class Attachment(models.Model):
     objects = AttachmentManager()
 
     class Meta:
         app_label = 'boards'
         ordering = ('id',)
 
     file = models.FileField(upload_to=get_upload_filename, null=True)
     mimetype = models.CharField(max_length=200, null=True)
     hash = models.CharField(max_length=36, null=True)
     url = models.TextField(blank=True, default='')
 
     def get_view(self):
         file_viewer = None
         for viewer in get_viewers():
             if viewer.supports(self.mimetype):
                 file_viewer = viewer
                 break
         if file_viewer is None:
             file_viewer = AbstractViewer
 
         return file_viewer(self.file, self.mimetype, self.id, self.url).get_view()
 
     def __str__(self):
         return self.url or self.file.url
 
     def get_random_associated_post(self):
         posts = boards.models.Post.objects.filter(attachments__in=[self])
         return posts.order_by('?').first()
 
     @cached_result()
     def get_size(self):
         if self.file:
             if self.mimetype in FILE_TYPES_IMAGE:
                 return get_image_dimensions(self.file)
             else:
                 return 200, 150
 
     def get_thumb_url(self):
         split = self.file.url.rsplit('.', 1)
         w, h = 200, 150
         return '%s.%sx%s.%s' % (split[0], w, h, split[1])
 
     @cached_result()
     def get_preview_size(self):
         size = 200, 150
         if self.mimetype in FILE_TYPES_IMAGE:
             preview_path = self.file.path.replace('.', '.200x150.')
             try:
                 size = get_image_dimensions(preview_path)
             except Exception:
                 pass
 
         return size
 
     def is_internal(self):
         return self.url is None or len(self.url) == 0
 
 
 class StickerPack(models.Model):
     name = models.TextField(unique=True)
     tripcode = models.TextField(blank=True)
 
     def __str__(self):
         return self.name
 
 
 class AttachmentSticker(models.Model):
-    attachment = models.ForeignKey('Attachment')
+    attachment = models.ForeignKey('Attachment', on_delete=models.CASCADE)
     name = models.TextField(unique=True)
-    stickerpack = models.ForeignKey('StickerPack')
+    stickerpack = models.ForeignKey('StickerPack', on_delete=models.CASCADE)
 
     def __str__(self):
         # Local stickers do not have a sticker pack
         if hasattr(self, 'stickerpack'):
             return '{}/{}'.format(str(self.stickerpack), self.name)
         else:
             return self.name

boards/models/attachment/viewers.py

@@ -1,244 +1,237 b''
-import re
-
-from PIL import Image
-
 from django.contrib.staticfiles import finders
 from django.contrib.staticfiles.templatetags.staticfiles import static
 from django.core.files.images import get_image_dimensions
 from django.template.defaultfilters import filesizeformat
-from django.core.urlresolvers import reverse
-from django.utils.translation import ugettext_lazy as _, ungettext_lazy
 
+from boards import settings
 from boards.utils import get_domain, cached_result, get_extension
-from boards import settings
-
 
 FILE_STUB_IMAGE = 'images/file.png'
 FILE_STUB_URL = 'url'
 FILE_FILEFORMAT = 'images/fileformats/{}.png'
 
 
 FILE_TYPES_VIDEO = (
     'video/webm',
     'video/mp4',
     'video/mpeg',
     'video/ogv',
 )
 FILE_TYPE_SVG = 'image/svg+xml'
 FILE_TYPES_AUDIO = (
     'audio/ogg',
     'audio/mpeg',
     'audio/opus',
     'audio/x-flac',
     'audio/mpeg',
 )
 FILE_TYPES_IMAGE = (
     'image/jpeg',
     'image/jpg',
     'image/png',
     'image/bmp',
     'image/gif',
 )
 
 PLAIN_FILE_FORMATS = {
     'zip': 'archive',
     'tar': 'archive',
     'gz': 'archive',
     'mid' : 'midi',
 }
 
 URL_PROTOCOLS = {
     'magnet': 'magnet',
 }
 
 CSS_CLASS_IMAGE = 'image'
 CSS_CLASS_THUMB = 'thumb'
 
 ABSTRACT_VIEW = '<div class="image">'\
         '{}'\
         '<div class="image-metadata"><a href="{}" download >{}, {}</a>'\
         ' <a class="file-menu" href="#" data-type="{}" data-search-url="{}" data-filename="{}" data-id="{}">&#8942; </a></div>'\
         '</div>'
 URL_VIEW = '<div class="image">' \
         '{}' \
         '<div class="image-metadata">{}</div>' \
         '</div>'
 ABSTRACT_FORMAT_VIEW = '<a href="{}">'\
         '<img class="url-image" src="{}" width="{}" height="{}"/>'\
         '</a>'
 VIDEO_FORMAT_VIEW = '<video width="200" height="150" controls src="{}"></video>'
 AUDIO_FORMAT_VIEW = '<audio controls src="{}"></audio>'
 IMAGE_FORMAT_VIEW = '<a class="{}" href="{full}">' \
         '<img class="post-image-preview"' \
         ' src="{}"' \
         ' alt="{}"' \
         ' width="{}"' \
         ' height="{}"' \
         ' data-width="{}"' \
         ' data-height="{}" />' \
         '</a>'
 SVG_FORMAT_VIEW = '<a class="thumb" href="{}">'\
         '<img class="post-image-preview" width="200" height="150" src="{}" />'\
         '</a>'
 URL_FORMAT_VIEW = '<a href="{}">' \
         '<img class="url-image" src="{}" width="{}" height="{}"/>' \
         '</a>'
 
 
 def get_viewers():
     return AbstractViewer.__subclasses__()
 
 
 def get_static_dimensions(filename):
     file_path = finders.find(filename)
     return get_image_dimensions(file_path)
 
 
 # TODO Move this to utils
 def file_exists(filename):
     return finders.find(filename) is not None
 
 
 class AbstractViewer:
     def __init__(self, file, file_type, id, url):
         self.file = file
         self.file_type = file_type
         self.id = id
         self.url = url
         self.extension = get_extension(self.file.name).lower()
 
     @staticmethod
     def supports(file_type):
         return True
 
     def get_view(self):
         search_host = settings.get('External', 'ImageSearchHost')
         if search_host:
             if search_host.endswith('/'):
                 search_host = search_host[:-1]
             search_url = search_host + self.file.url
         else:
             search_url = ''
 
         return ABSTRACT_VIEW.format(self.get_format_view(), self.file.url,
                 self.file_type, filesizeformat(self.file.size),
                 self.file_type, search_url, self.file.name, self.id)
 
     def get_format_view(self):
         image_name = PLAIN_FILE_FORMATS.get(self.extension, self.extension)
         file_name = FILE_FILEFORMAT.format(image_name)
 
         if file_exists(file_name):
             image = file_name
         else:
             image = FILE_STUB_IMAGE
 
         w, h = get_static_dimensions(image)
 
         return ABSTRACT_FORMAT_VIEW.format(self.file.url, static(image), w, h)
 
 
 class VideoViewer(AbstractViewer):
     @staticmethod
     def supports(file_type):
         return file_type in FILE_TYPES_VIDEO
 
     def get_format_view(self):
         return VIDEO_FORMAT_VIEW.format(self.file.url)
 
 
 class AudioViewer(AbstractViewer):
     @staticmethod
     def supports(file_type):
         return file_type in FILE_TYPES_AUDIO
 
     def get_format_view(self):
         return AUDIO_FORMAT_VIEW.format(self.file.url)
 
 
 class SvgViewer(AbstractViewer):
     @staticmethod
     def supports(file_type):
         return file_type == FILE_TYPE_SVG
 
     def get_format_view(self):
         return SVG_FORMAT_VIEW.format(self.file.url, self.file.url)
 
 
 class ImageViewer(AbstractViewer):
     @staticmethod
     def supports(file_type):
         return file_type in FILE_TYPES_IMAGE
 
     def get_format_view(self):
         metadata = '{}, {}'.format(self.file.name.split('.')[-1],
                                    filesizeformat(self.file.size))
 
         try:
             width, height = get_image_dimensions(self.file.path)
         except Exception:
             # If the image is a decompression bomb, treat it as just a regular
             # file
             return super().get_format_view()
 
         preview_path = self.file.path.replace('.', '.200x150.')
         try:
             pre_width, pre_height = get_image_dimensions(preview_path)
         except Exception:
             return super().get_format_view()
 
         split = self.file.url.rsplit('.', 1)
         w, h = 200, 150
         thumb_url = '%s.%sx%s.%s' % (split[0], w, h, split[1])
 
         return IMAGE_FORMAT_VIEW.format(CSS_CLASS_THUMB,
                 thumb_url,
                 self.id,
                 str(pre_width),
                 str(pre_height), str(width), str(height),
                 full=self.file.url, image_meta=metadata)
 
 
 class UrlViewer(AbstractViewer):
     @staticmethod
     def supports(file_type):
         return file_type is None
 
     def get_view(self):
         return URL_VIEW.format(self.get_format_view(), get_domain(self.url))
 
     def get_format_view(self):
         protocol = self.url.split(':')[0]
 
         domain = get_domain(self.url)
 
         if protocol in URL_PROTOCOLS:
             url_image_name = URL_PROTOCOLS.get(protocol)
         elif domain:
             url_image_name = self._find_image_for_domains(domain) or FILE_STUB_URL
         else:
             url_image_name = FILE_STUB_URL
 
         image_path = 'images/{}.png'.format(url_image_name)
         image = static(image_path)
         w, h = get_static_dimensions(image_path)
 
         return URL_FORMAT_VIEW.format(self.url, image, w, h)
 
     @cached_result()
     def _find_image_for_domains(self, domain):
         """
         Searches for the domain image for every domain level except top.
         E.g. for l3.example.co.uk it will search for l3.example.co.uk, then
         example.co.uk, then co.uk
         """
         levels = domain.split('.')
         while len(levels) > 1:
             domain = '.'.join(levels)
 
             filename = 'images/domains/{}.png'.format(domain)
             if file_exists(filename):
                 return 'domains/' + domain
             else:
                 del levels[0]
 

boards/models/banner.py

@@ -1,13 +1,13 b''
 from django.db import models
 
 
 class Banner(models.Model):
     title = models.TextField()
     text = models.TextField(blank=True, null=True)
-    post = models.ForeignKey('Post')
+    post = models.ForeignKey('Post', on_delete=models.CASCADE)
 
     def __str__(self):
         return self.title
 
     def get_text(self) -> str:
         return self.text or self.post.get_text()

boards/models/post/__init__.py

@@ -1,360 +1,360 b''
 import uuid
+
 import hashlib
 import re
+from django.db import models
+from django.db.models import TextField
+from django.template.defaultfilters import truncatewords, striptags
+from django.template.loader import render_to_string
+from django.urls import reverse
 
-from boards import settings
 from boards.abstracts.tripcode import Tripcode
 from boards.models import Attachment, KeyPair, GlobalId
 from boards.models.attachment import FILE_TYPES_IMAGE
 from boards.models.base import Viewable
 from boards.models.post.export import get_exporter, DIFF_TYPE_JSON
 from boards.models.post.manager import PostManager, NO_IP
 from boards.utils import datetime_to_epoch
-from django.core.exceptions import ObjectDoesNotExist
-from django.core.urlresolvers import reverse
-from django.db import models
-from django.db.models import TextField, QuerySet, F
-from django.template.defaultfilters import truncatewords, striptags
-from django.template.loader import render_to_string
 
 CSS_CLS_HIDDEN_POST = 'hidden_post'
 CSS_CLS_DEAD_POST = 'dead_post'
 CSS_CLS_ARCHIVE_POST = 'archive_post'
 CSS_CLS_POST = 'post'
 CSS_CLS_MONOCHROME = 'monochrome'
 
 TITLE_MAX_WORDS = 10
 
 APP_LABEL_BOARDS = 'boards'
 
 BAN_REASON_AUTO = 'Auto'
 
 TITLE_MAX_LENGTH = 200
 
 REGEX_REPLY = re.compile(r'\[post\](\d+)\[/post\]')
 REGEX_GLOBAL_REPLY = re.compile(r'\[post\](\w+)::([^:]+)::(\d+)\[/post\]')
 REGEX_URL = re.compile(r'https?\://[a-zA-Z0-9\-\.]+\.[a-zA-Z]{2,3}(/\S*)?')
 REGEX_NOTIFICATION = re.compile(r'\[user\](\w+)\[/user\]')
 
 PARAMETER_TRUNCATED = 'truncated'
 PARAMETER_TAG = 'tag'
 PARAMETER_OFFSET = 'offset'
 PARAMETER_DIFF_TYPE = 'type'
 PARAMETER_CSS_CLASS = 'css_class'
 PARAMETER_THREAD = 'thread'
 PARAMETER_IS_OPENING = 'is_opening'
 PARAMETER_POST = 'post'
 PARAMETER_OP_ID = 'opening_post_id'
 PARAMETER_NEED_OPEN_LINK = 'need_open_link'
 PARAMETER_REPLY_LINK = 'reply_link'
 PARAMETER_NEED_OP_DATA = 'need_op_data'
 
 POST_VIEW_PARAMS = (
     'need_op_data',
     'reply_link',
     'need_open_link',
     'truncated',
     'mode_tree',
     'perms',
     'tree_depth',
 )
 
 
 class Post(models.Model, Viewable):
     """A post is a message."""
 
     objects = PostManager()
 
     class Meta:
         app_label = APP_LABEL_BOARDS
         ordering = ('id',)
 
     title = models.CharField(max_length=TITLE_MAX_LENGTH, blank=True, default='')
     pub_time = models.DateTimeField(db_index=True)
     text = TextField(blank=True, default='')
     _text_rendered = TextField(blank=True, null=True, editable=False)
 
     attachments = models.ManyToManyField(Attachment, null=True, blank=True,
                                          related_name='attachment_posts')
 
     poster_ip = models.GenericIPAddressField()
 
     # Used for cache and threads updating
     last_edit_time = models.DateTimeField()
 
     referenced_posts = models.ManyToManyField('Post', symmetrical=False,
                                               null=True,
                                               blank=True, related_name='refposts',
                                               db_index=True)
     refmap = models.TextField(null=True, blank=True)
-    thread = models.ForeignKey('Thread', db_index=True, related_name='replies')
+    thread = models.ForeignKey('Thread', on_delete=models.CASCADE,
+                               db_index=True, related_name='replies')
 
     url = models.TextField()
     uid = models.TextField()
 
     # Global ID with author key. If the message was downloaded from another
     # server, this indicates the server.
     global_id = models.OneToOneField(GlobalId, null=True, blank=True,
                                      on_delete=models.CASCADE)
 
     tripcode = models.CharField(max_length=50, blank=True, default='')
     opening = models.BooleanField(db_index=True)
     hidden = models.BooleanField(default=False)
 
     def __str__(self):
         return 'P#{}/{}'.format(self.id, self.get_title())
 
     def get_title(self) -> str:
         return self.title
 
     def get_title_or_text(self):
         title = self.get_title()
         if not title:
             title = truncatewords(striptags(self.get_text()), TITLE_MAX_WORDS)
 
         return title
 
     def build_refmap(self, excluded_ids=None) -> None:
         """
         Builds a replies map string from replies list. This is a cache to stop
         the server from recalculating the map on every post show.
         """
 
         replies = self.referenced_posts
         if excluded_ids is not None:
             replies = replies.exclude(id__in=excluded_ids)
         else:
             replies = replies.all()
 
         post_urls = [refpost.get_link_view() for refpost in replies]
 
         self.refmap = ', '.join(post_urls)
 
     def is_referenced(self) -> bool:
         return self.refmap and len(self.refmap) > 0
 
     def is_opening(self) -> bool:
         """
         Checks if this is an opening post or just a reply.
         """
 
         return self.opening
 
     def get_absolute_url(self, thread=None):
         # Url is cached only for the "main" thread. When getting url
         # for other threads, do it manually.
         return self.url
 
     def get_thread(self):
         return self.thread
 
     def get_thread_id(self):
         return self.thread_id
 
     def _get_cache_key(self):
         return [datetime_to_epoch(self.last_edit_time)]
 
     def get_view_params(self, *args, **kwargs):
         """
         Gets the parameters required for viewing the post based on the arguments
         given and the post itself.
         """
         thread = kwargs.get('thread') or self.get_thread()
 
         css_classes = [CSS_CLS_POST]
         if thread.is_archived():
             css_classes.append(CSS_CLS_ARCHIVE_POST)
         elif not thread.can_bump():
             css_classes.append(CSS_CLS_DEAD_POST)
         if self.is_hidden():
             css_classes.append(CSS_CLS_HIDDEN_POST)
         if thread.is_monochrome():
             css_classes.append(CSS_CLS_MONOCHROME)
 
         params = dict()
         for param in POST_VIEW_PARAMS:
             if param in kwargs:
                 params[param] = kwargs[param]
 
         params.update({
             PARAMETER_POST: self,
             PARAMETER_IS_OPENING: self.is_opening(),
             PARAMETER_THREAD: thread,
             PARAMETER_CSS_CLASS: ' '.join(css_classes),
         })
 
         return params
 
     def get_view(self, *args, **kwargs) -> str:
         """
         Renders post's HTML view. Some of the post params can be passed over
         kwargs for the means of caching (if we view the thread, some params
         are same for every post and don't need to be computed over and over.
         """
         params = self.get_view_params(*args, **kwargs)
 
         return render_to_string('boards/post.html', params)
 
     def get_images(self) -> Attachment:
         return self.attachments.filter(mimetype__in=FILE_TYPES_IMAGE)
 
     def get_first_image(self) -> Attachment:
         try:
             return self.get_images().earliest('-id')
         except Attachment.DoesNotExist:
             return None
 
     def set_global_id(self, key_pair=None):
         """
         Sets global id based on the given key pair. If no key pair is given,
         default one is used.
         """
 
         if key_pair:
             key = key_pair
         else:
             try:
                 key = KeyPair.objects.get(primary=True)
             except KeyPair.DoesNotExist:
                 # Do not update the global id because there is no key defined
                 return
         global_id = GlobalId(key_type=key.key_type,
                              key=key.public_key,
                              local_id=self.id)
         global_id.save()
 
         self.global_id = global_id
 
         self.save(update_fields=['global_id'])
 
     def get_pub_time_str(self):
         return str(self.pub_time)
 
     def get_replied_ids(self):
         """
         Gets ID list of the posts that this post replies.
         """
 
         raw_text = self.get_raw_text()
 
         local_replied = REGEX_REPLY.findall(raw_text)
         global_replied = []
         for match in REGEX_GLOBAL_REPLY.findall(raw_text):
             key_type = match[0]
             key = match[1]
             local_id = match[2]
 
             try:
                 global_id = GlobalId.objects.get(key_type=key_type,
                                                  key=key, local_id=local_id)
                 for post in Post.objects.filter(global_id=global_id).only('id'):
                     global_replied.append(post.id)
             except GlobalId.DoesNotExist:
                 pass
         return local_replied + global_replied
 
     def get_post_data(self, format_type=DIFF_TYPE_JSON, request=None,
                       include_last_update=False) -> str:
         """
         Gets post HTML or JSON data that can be rendered on a page or used by
         API.
         """
 
         return get_exporter(format_type).export(self, request,
                                                 include_last_update)
 
     def _build_url(self):
         opening = self.is_opening()
         opening_id = self.id if opening else self.get_thread().get_opening_post_id()
         url = reverse('thread', kwargs={'post_id': opening_id})
         if not opening:
             url += '#' + str(self.id)
 
         return url
 
     def save(self, force_insert=False, force_update=False, using=None,
              update_fields=None):
         new_post = self.id is None
 
         self.uid = str(uuid.uuid4())
         if update_fields is not None and 'uid' not in update_fields:
             update_fields += ['uid']
 
         if not new_post:
             thread = self.get_thread()
             if thread:
                 thread.last_edit_time = self.last_edit_time
                 thread.save(update_fields=['last_edit_time', 'status'])
 
         super().save(force_insert, force_update, using, update_fields)
 
         if new_post:
             self.url = self._build_url()
             super().save(update_fields=['url'])
 
     def get_text(self) -> str:
         return self._text_rendered
 
     def get_raw_text(self) -> str:
         return self.text
 
     def get_sync_text(self) -> str:
         """
         Returns text applicable for sync. It has absolute post reflinks.
         """
 
         replacements = dict()
         for post_id in REGEX_REPLY.findall(self.get_raw_text()):
             try:
                 absolute_post_id = str(Post.objects.get(id=post_id).global_id)
                 replacements[post_id] = absolute_post_id
             except Post.DoesNotExist:
                 pass
 
         text = self.get_raw_text() or ''
         for key in replacements:
             text = text.replace('[post]{}[/post]'.format(key),
                                 '[post]{}[/post]'.format(replacements[key]))
         text = text.replace('\r\n', '\n').replace('\r', '\n')
 
         return text
 
     def get_tripcode(self):
         if self.tripcode:
             return Tripcode(self.tripcode)
 
     def get_link_view(self):
         """
         Gets view of a reflink to the post.
         """
         result = '<a href="{}">&gt;&gt;{}</a>'.format(self.get_absolute_url(),
                                                       self.id)
         if self.is_opening():
             result = '<b>{}</b>'.format(result)
 
         return result
 
     def is_hidden(self) -> bool:
         return self.hidden
 
     def set_hidden(self, hidden):
         self.hidden = hidden
 
     def clear_cache(self):
         """
         Clears sync data (content cache, signatures etc).
         """
         global_id = self.global_id
         if global_id is not None and global_id.is_local()\
                 and global_id.content is not None:
             global_id.clear_cache()
 
     def get_tags(self):
         return self.get_thread().get_tags()
 
     def get_ip_color(self):
         return hashlib.md5(self.poster_ip.encode()).hexdigest()[:6]
 
     def has_ip(self):
         return self.poster_ip != NO_IP
 

boards/models/signature.py

@@ -1,125 +1,125 b''
 import xml.etree.ElementTree as et
 
 from django.db import models
 
 from boards.models import KeyPair
 
 TAG_MODEL = 'model'
 TAG_REQUEST = 'request'
 TAG_ID = 'id'
 
 TYPE_GET = 'get'
 TYPE_LIST = 'list'
 
 ATTR_VERSION = 'version'
 ATTR_TYPE = 'type'
 ATTR_NAME = 'name'
 
 ATTR_KEY = 'key'
 ATTR_KEY_TYPE = 'type'
 ATTR_LOCAL_ID = 'local-id'
 
 
 class GlobalIdManager(models.Manager):
     def global_id_exists(self, global_id):
         """
         Checks if the same global id already exists in the system.
         """
 
         return self.filter(key=global_id.key,
                            key_type=global_id.key_type,
                            local_id=global_id.local_id).exists()
 
 
 class GlobalId(models.Model):
     """
     Global model ID and cache.
     Key, key type and local ID make a single global identificator of the model.
     Content is an XML cache of the model that can be passed along between nodes
     without manual serialization each time.
     """
     class Meta:
         app_label = 'boards'
 
     objects = GlobalIdManager()
 
     def __init__(self, *args, **kwargs):
         models.Model.__init__(self, *args, **kwargs)
 
         if 'key' in kwargs and 'key_type' in kwargs and 'local_id' in kwargs:
             self.key = kwargs['key']
             self.key_type = kwargs['key_type']
             self.local_id = kwargs['local_id']
 
     key = models.TextField()
     key_type = models.TextField()
     local_id = models.IntegerField()
     content = models.TextField(blank=True, null=True)
 
     def __str__(self):
         return '%s::%s::%d' % (self.key_type, self.key, self.local_id)
 
     def to_xml_element(self, element: et.Element):
         """
         Exports global id to an XML element.
         """
 
         element.set(ATTR_KEY, self.key)
         element.set(ATTR_KEY_TYPE, self.key_type)
         element.set(ATTR_LOCAL_ID, str(self.local_id))
 
     @staticmethod
     def from_xml_element(element: et.Element):
         """
         Parses XML id tag and gets global id from it.
 
         Arguments:
         element -- the XML 'id' element
 
         Returns:
         global_id -- id itself
         exists -- True if the global id was taken from database, False if it
         did not exist and was created.
         """
 
         try:
             return GlobalId.objects.get(key=element.get(ATTR_KEY),
                                         key_type=element.get(ATTR_KEY_TYPE),
                                         local_id=int(element.get(
                                             ATTR_LOCAL_ID))), True
         except GlobalId.DoesNotExist:
             return GlobalId(key=element.get(ATTR_KEY),
                             key_type=element.get(ATTR_KEY_TYPE),
                             local_id=int(element.get(ATTR_LOCAL_ID))), False
 
     def is_local(self):
         """Checks fo the ID is local model's"""
         return KeyPair.objects.filter(
                 key_type=self.key_type, public_key=self.key).exists()
 
     def clear_cache(self):
         """
         Removes content cache and signatures.
         """
         self.content = None
         self.save()
         self.signature_set.all().delete()
 
 
 class Signature(models.Model):
     class Meta:
         app_label = 'boards'
 
     def __init__(self, *args, **kwargs):
         models.Model.__init__(self, *args, **kwargs)
 
         if 'key' in kwargs and 'key_type' in kwargs and 'signature' in kwargs:
             self.key_type = kwargs['key_type']
             self.key = kwargs['key']
             self.signature = kwargs['signature']
 
     key_type = models.TextField()
     key = models.TextField()
     signature = models.TextField()
 
-    global_id = models.ForeignKey('GlobalId')
+    global_id = models.ForeignKey('GlobalId', on_delete=models.CASCADE)

boards/models/source.py

@@ -1,84 +1,84 b''
 import feedparser
 import logging
 import calendar
 
 from time import mktime
 from datetime import datetime
 
 from django.db import models, transaction
 from django.utils.dateparse import parse_datetime
 from django.utils.timezone import utc
 from django.utils import timezone
 from django.utils.html import strip_tags
 
 from boards.models import Post
 from boards.models.post import TITLE_MAX_LENGTH
 from boards.utils import get_tripcode_from_text
 from boards import settings
 
 
 SOURCE_TYPE_MAX_LENGTH = 100
 SOURCE_TYPE_RSS = 'RSS'
 TYPE_CHOICES = (
         (SOURCE_TYPE_RSS, SOURCE_TYPE_RSS),
 )
 
 
 class ThreadSource(models.Model):
     class Meta:
         app_label = 'boards'
 
     name = models.TextField()
-    thread = models.ForeignKey('Thread')
+    thread = models.ForeignKey('Thread', on_delete=models.CASCADE)
     timestamp = models.DateTimeField()
     source = models.TextField()
     source_type = models.CharField(max_length=SOURCE_TYPE_MAX_LENGTH,
             choices=TYPE_CHOICES)
 
     def __str__(self):
         return self.name
 
     @transaction.atomic
     def fetch_latest_posts(self):
         """Creates new posts with the info fetched since the timestamp."""
         logger = logging.getLogger('boards.source')
 
         if self.thread.is_archived():
             logger.error('The thread {} is archived, please try another one'.format(self.thread))
         else:
             tripcode = get_tripcode_from_text(
                     settings.get('External', 'SourceFetcherTripcode'))
             start_timestamp = self.timestamp
             last_timestamp = start_timestamp
             logger.info('Start timestamp is {}'.format(start_timestamp))
             if self.thread.is_bumplimit():
                 logger.warn('The thread {} has reached its bumplimit, please create a new one'.format(self.thread))
             if self.source_type == SOURCE_TYPE_RSS:
                 feed = feedparser.parse(self.source)
                 items = sorted(feed.entries, key=lambda entry: entry.published_parsed)
                 for item in items:
                     title = self.strip_title(item.title, TITLE_MAX_LENGTH)
                     timestamp = datetime.fromtimestamp(calendar.timegm(item.published_parsed), tz=utc)
                     if not timestamp:
                         logger.error('Invalid timestamp {} for {}'.format(item.published, title))
                     else:
                         if timestamp > last_timestamp:
                             last_timestamp = timestamp
                         if timestamp > start_timestamp:
                             Post.objects.create_post(title=title, text=self.parse_text(item.description),
                                     thread=self.thread, file_urls=[item.link], tripcode=tripcode)
                             logger.info('Fetched item {} from {} into thread {}'.format(
                                 title, self.name, self.thread))
             logger.info('New timestamp is {}'.format(last_timestamp))
             self.timestamp = last_timestamp
             self.save(update_fields=['timestamp'])
 
     def parse_text(self, text):
         return strip_tags(text)
 
     def strip_title(self, title, max_length):
         result = title
         if len(title) > max_length:
             result = title[:max_length - 1] + '…'
         return result
 

boards/models/tag.py

@@ -1,212 +1,212 b''
 import hashlib
-from django.core.urlresolvers import reverse
+from django.urls import reverse
 from django.db import models
 from django.db.models import Count, Q
 from django.utils.translation import get_language
 
 import boards
 from boards.models import Attachment
 from boards.models.attachment import FILE_TYPES_IMAGE
 from boards.models.base import Viewable
 from boards.models.thread import STATUS_ACTIVE, STATUS_BUMPLIMIT, STATUS_ARCHIVE
 from boards.utils import cached_result
 
 __author__ = 'neko259'
 
 
 RELATED_TAGS_COUNT = 5
 DEFAULT_LOCALE = 'default'
 
 
 class TagAliasManager(models.Manager):
     def filter_localized(self, *args, **kwargs):
         locale = get_language()
         tag_aliases = (self.filter(locale=locale)
                 | self.filter(Q(locale=DEFAULT_LOCALE)
                     & ~Q(parent__aliases__locale=locale)))
         return tag_aliases.filter(**kwargs)
 
 
 class TagAlias(models.Model, Viewable):
     class Meta:
         app_label = 'boards'
         ordering = ('name',)
 
     objects = TagAliasManager()
 
     name = models.CharField(max_length=100, db_index=True)
     locale = models.CharField(max_length=10, db_index=True)
 
-    parent = models.ForeignKey('Tag', null=True, blank=True,
-            related_name='aliases')
+    parent = models.ForeignKey('Tag', on_delete=models.CASCADE, null=True,
+                               blank=True, related_name='aliases')
 
 
 class TagManager(models.Manager):
     def get_not_empty_tags(self):
         """
         Gets tags that have non-archived threads.
         """
 
         return self.annotate(num_threads=Count('thread_tags'))\
                 .filter(num_threads__gt=0)\
                 .filter(aliases__in=TagAlias.objects.filter_localized())\
                 .order_by('aliases__name')
 
     def get_tag_url_list(self, tags: list) -> str:
         """
         Gets a comma-separated list of tag links.
         """
 
         return ', '.join([tag.get_view() for tag in tags])
 
     def get_by_alias(self, alias):
         tag = None
         aliases = TagAlias.objects.filter(name=alias).all()
         if aliases:
             tag = aliases[0].parent
 
         return tag
 
     def get_or_create_with_alias(self, name, required=False):
         tag = self.get_by_alias(name)
         created = False
         if not tag:
             tag = self.create(required=required)
             TagAlias.objects.create(name=name, locale=DEFAULT_LOCALE, parent=tag)
             created = True
         return tag, created
 
 
 class Tag(models.Model, Viewable):
     """
     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'
 
     required = models.BooleanField(default=False, db_index=True)
     description = models.TextField(blank=True)
 
-    parent = models.ForeignKey('Tag', null=True, blank=True,
-            related_name='children')
+    parent = models.ForeignKey('Tag', on_delete=models.CASCADE, null=True,
+                               blank=True, related_name='children')
 
     def get_name(self):
         return self.aliases.get(locale=DEFAULT_LOCALE).name
 
     def __str__(self):
         return self.get_name()
 
     def is_empty(self) -> bool:
         """
         Checks if the tag has some threads.
         """
 
         return self.get_thread_count() == 0
 
     def get_thread_count(self, status=None) -> int:
         threads = self.get_threads()
         if status is not None:
             threads = threads.filter(status=status)
         return threads.count()
 
     def get_active_thread_count(self) -> int:
         return self.get_thread_count(status=STATUS_ACTIVE)
 
     def get_bumplimit_thread_count(self) -> int:
         return self.get_thread_count(status=STATUS_BUMPLIMIT)
 
     def get_archived_thread_count(self) -> int:
         return self.get_thread_count(status=STATUS_ARCHIVE)
 
     @cached_result()
     def get_absolute_url(self):
         return reverse('tag', kwargs={'tag_name': self.get_name()})
 
     def get_threads(self):
         return self.thread_tags.order_by('-bump_time')
 
     def is_required(self):
         return self.required
 
     def _get_locale_cache_key(self):
         return '{}_{}'.format(self.id, get_language())
 
     @cached_result(key_method=_get_locale_cache_key)
     def get_localized_name(self):
         locale = get_language()
 
         aliases = self.aliases.filter(Q(locale=locale) | Q(locale=DEFAULT_LOCALE))
 
         localized_tag_name = None
         default_tag_name = None
 
         for alias in aliases:
             if alias.locale == locale:
                 localized_tag_name = alias.name
             elif alias.locale == DEFAULT_LOCALE:
                 default_tag_name = alias.name
 
         return localized_tag_name if localized_tag_name else default_tag_name
 
     def get_view(self):
         name = self.get_localized_name()
         link = '<a class="tag" href="{}">{}</a>'.format(
             self.get_absolute_url(), name)
         if self.is_required():
             link = '<b>{}</b>'.format(link)
         return link
 
     @cached_result()
     def get_post_count(self):
         return self.get_threads().aggregate(num_posts=Count('replies'))['num_posts']
 
     def get_description(self):
         return self.description
 
     def get_random_image_post(self, status=[STATUS_ACTIVE, STATUS_BUMPLIMIT]):
         posts = boards.models.Post.objects.filter(attachments__mimetype__in=FILE_TYPES_IMAGE)\
             .annotate(images_count=Count(
             'attachments')).filter(images_count__gt=0, thread__tags__in=[self])
         if status is not None:
             posts = posts.filter(thread__status__in=status)
         return posts.order_by('?').first()
 
     def get_first_letter(self):
         name = self.get_localized_name()
         return name and name[0] or ''
 
     def get_related_tags(self):
         return set(Tag.objects.filter(thread_tags__in=self.get_threads()).exclude(
             id=self.id).order_by('?')[:RELATED_TAGS_COUNT])
 
     @cached_result()
     def get_color(self):
         """
         Gets color hashed from the tag name.
         """
         return hashlib.md5(self.get_name().encode()).hexdigest()[:6]
 
     def get_parent(self):
         return self.parent
 
     def get_all_parents(self):
         parents = list()
         parent = self.get_parent()
         if parent and parent not in parents:
             parents.insert(0, parent)
             parents = parent.get_all_parents() + parents
 
         return parents
 
     def get_children(self):
         return self.children
 
     def get_images(self):
         return Attachment.objects.filter(
             attachment_posts__thread__tags__in=[self]).filter(
             mimetype__in=FILE_TYPES_IMAGE).order_by('-attachment_posts__pub_time')
 

boards/models/user.py

@@ -1,45 +1,45 b''
 from django.db import models
 import boards
 
 __author__ = 'neko259'
 
 BAN_REASON_AUTO = 'Auto'
 BAN_REASON_MAX_LENGTH = 200
 
 
 class Ban(models.Model):
 
     class Meta:
         app_label = 'boards'
 
     ip = models.GenericIPAddressField()
     reason = models.CharField(default=BAN_REASON_AUTO,
                               max_length=BAN_REASON_MAX_LENGTH)
     can_read = models.BooleanField(default=True)
 
     def __str__(self):
         return self.ip
 
 
 class NotificationManager(models.Manager):
     def get_notification_posts(self, usernames: list, last: int = None):
         lower_names = [username.lower() for username in usernames]
         posts = boards.models.post.Post.objects.filter(
                 notification__name__in=lower_names).distinct()
         if last is not None:
             posts = posts.filter(id__gt=last)
         posts = posts.order_by('-id')
 
         return posts
 
 
 class Notification(models.Model):
 
     class Meta:
         app_label = 'boards'
 
     objects = NotificationManager()
 
-    post = models.ForeignKey('Post')
+    post = models.ForeignKey('Post', on_delete=models.CASCADE)
     name = models.TextField()
 

boards/templatetags/board.py

@@ -1,100 +1,96 b''
 import re
-
+from django import template
 from django.shortcuts import get_object_or_404
-from django import template
 from django.utils.text import re_tag
-from django.core.urlresolvers import reverse
 
 from boards.mdx_neboard import LINE_BREAK_HTML
-from boards import settings
-
 
 IMG_ACTION_URL = '[<a href="{}">{}</a>]'
 REGEX_NEWLINE = re.compile(LINE_BREAK_HTML)
 TRUNCATOR = '...'
 HTML4_SINGLETS =(
     'br', 'col', 'link', 'base', 'img', 'param', 'area', 'hr', 'input'
 )
 
 
 register = template.Library()
 
 
 @register.simple_tag(name='post_url')
 def post_url(*args, **kwargs):
     post_id = args[0]
 
     post = get_object_or_404('Post', id=post_id)
 
     return post.get_absolute_url()
 
 
 @register.inclusion_tag('boards/post.html', name='post_view', takes_context=True)
 def post_view(context, post, *args, **kwargs):
     kwargs['perms'] = context['perms']
     return post.get_view_params(*args, **kwargs)
 
 
 @register.simple_tag(name='page_url')
 def page_url(paginator, page_number, *args, **kwargs):
     if paginator.supports_urls():
         return paginator.get_page_url(page_number)
 
 
 @register.filter(name='truncatenewlines_html')
 def truncatenewlines_html(value, arg):
     end_pos = 0
     start_pos = 0
     match_count = 0
 
     # Collect places for truncation
     while match_count <= arg:
         m = REGEX_NEWLINE.search(value, end_pos)
         if m is None:
             break
         else:
             match_count += 1
             end_pos = m.end()
             start_pos = m.start()
 
     # Find and close open tags
     if match_count > arg:
         truncate_pos = start_pos
 
         open_tags = []
         text = value[:truncate_pos]
         current_pos = 0
         while True:
             tag = re_tag.search(text, current_pos)
             if tag is None:
                 break
             else:
                 closing_tag, tagname, self_closing = tag.groups()
                 tagname = tagname.lower()
                 if self_closing or tagname in HTML4_SINGLETS:
                     pass
                 elif closing_tag:
                     # Check for match in open tags list
                     try:
                         i = open_tags.index(tagname)
                     except ValueError:
                         pass
                     else:
                         # SGML: An end tag closes, back to the matching start tag,
                         # all unclosed intervening start tags with omitted end tags
                         open_tags = open_tags[i + 1:]
                 else:
                     # Add it to the start of the open tags list
                     open_tags.insert(0, tagname)
 
                 current_pos = tag.end()
 
         if not text.endswith(TRUNCATOR):
             text += TRUNCATOR
         for tag in open_tags:
             text += '</{}>'.format(tag)
     else:
         text = value
 
     return text
 

boards/urls.py

@@ -1,96 +1,93 b''
 from django.conf.urls import url
+from django.urls import path
+from django.views.i18n import JavaScriptCatalog
 
 from boards import views
 from boards.rss import AllThreadsFeed, TagThreadsFeed, ThreadPostsFeed
 from boards.views import api, tag_threads, all_threads, settings, feed, stickers
 from boards.views.authors import AuthorsView
 from boards.views.landing import LandingView
 from boards.views.notifications import NotificationView
 from boards.views.preview import PostPreviewView
 from boards.views.random import RandomImageView
 from boards.views.search import BoardSearchView
 from boards.views.static import StaticPageView
 from boards.views.sync import get_post_sync_data, response_get, response_list
 from boards.views.tag_gallery import TagGalleryView
-from boards.views.translation import cached_javascript_catalog
 from boards.views.utils import UtilsView
 
-js_info_dict = {
-    'packages': ('boards',),
-}
 
 urlpatterns = [
     # /boards/
     url(r'^all/$', all_threads.AllThreadsView.as_view(), name='index'),
 
     # /boards/tag/tag_name/
     url(r'^tag/(?P<tag_name>[\w\d\']+)/$', tag_threads.TagView.as_view(),
         name='tag'),
     url(r'^tag/(?P<tag_name>[\w\d\']+)/gallery/$', TagGalleryView.as_view(), name='tag_gallery'),
 
     # /boards/thread/
     url(r'^thread/(?P<post_id>\d+)/$', views.thread.NormalThreadView.as_view(),
         name='thread'),
     url(r'^thread/(?P<post_id>\d+)/mode/gallery/$', views.thread.GalleryThreadView.as_view(),
         name='thread_gallery'),
     url(r'^thread/(?P<post_id>\d+)/mode/tree/$', views.thread.TreeThreadView.as_view(),
         name='thread_tree'),
     # /feed/
     url(r'^feed/$', views.feed.FeedView.as_view(), name='feed'),
 
     url(r'^settings/$', settings.SettingsView.as_view(), name='settings'),
     url(r'^stickers/$', stickers.AliasesView.as_view(), name='stickers'),
     url(r'^stickers/(?P<category>\w+)/$', stickers.AliasesView.as_view(), name='stickers'),
     url(r'^authors/$', AuthorsView.as_view(), name='authors'),
 
     url(r'^banned/$', views.banned.BannedView.as_view(), name='banned'),
     url(r'^staticpage/(?P<name>\w+)/$', StaticPageView.as_view(),
         name='staticpage'),
 
     url(r'^random/$', RandomImageView.as_view(), name='random'),
     url(r'^search/$', BoardSearchView.as_view(), name='search'),
     url(r'^$', LandingView.as_view(), name='landing'),
     url(r'^utils$', UtilsView.as_view(), name='utils'),
 
     # RSS feeds
     url(r'^rss/$', AllThreadsFeed()),
     url(r'^all/rss/$', AllThreadsFeed()),
     url(r'^page/(?P<page>\d+)/rss/$', AllThreadsFeed()),
     url(r'^tag/(?P<tag_name>\w+)/rss/$', TagThreadsFeed()),
     url(r'^tag/(?P<tag_name>\w+)/page/(?P<page>\w+)/rss/$', TagThreadsFeed()),
     url(r'^thread/(?P<post_id>\d+)/rss/$', ThreadPostsFeed()),
 
     # i18n
-    url(r'^jsi18n/$', cached_javascript_catalog, js_info_dict,
-        name='js_info_dict'),
+    path('jsi18n/', JavaScriptCatalog.as_view(packages=['boards']), name='js_info_dict'),
 
     # API
     url(r'^api/post/(?P<post_id>\d+)/$', api.get_post, name="get_post"),
     url(r'^api/diff_thread/$', api.api_get_threaddiff, name="get_thread_diff"),
     url(r'^api/threads/(?P<count>\w+)/$', api.api_get_threads,
             name='get_threads'),
     url(r'^api/tags/$', api.api_get_tags, name='get_tags'),
     url(r'^api/thread/(?P<opening_post_id>\w+)/$', api.api_get_thread_posts,
             name='get_thread'),
     url(r'^api/add_post/(?P<opening_post_id>\w+)/$', api.api_add_post,
             name='add_post'),
     url(r'^api/notifications/(?P<username>\w+)/$', api.api_get_notifications,
             name='api_notifications'),
     url(r'^api/preview/$', api.api_get_preview, name='preview'),
     url(r'^api/new_posts/$', api.api_get_new_posts, name='new_posts'),
     url(r'^api/stickers/$', api.api_get_stickers, name='get_stickers'),
 
     # Sync protocol API
     url(r'^api/sync/list/$', response_list, name='api_sync_list'),
     url(r'^api/sync/get/$', response_get, name='api_sync_get'),
 
     # Notifications
     url(r'^notifications/(?P<username>\w+)/$', NotificationView.as_view(), name='notifications'),
     url(r'^notifications/$', NotificationView.as_view(), name='notifications'),
 
     # Post preview
     url(r'^preview/$', PostPreviewView.as_view(), name='preview'),
     url(r'^post_xml/(?P<post_id>\d+)$', get_post_sync_data,
         name='post_sync_data'),
 ]
 

boards/views/__init__.py

@@ -1,9 +0,0 b''
-__author__ = 'neko259'
-
-from django.views.decorators.cache import cache_page
-from django.views.i18n import javascript_catalog
-
-
-@cache_page(86400)
-def cached_js_catalog(request, domain='djangojs', packages=None):
-    return javascript_catalog(request, domain, packages)

boards/views/all_threads.py

@@ -1,180 +1,178 b''
-from django.core.urlresolvers import reverse
-from django.core.files import File
-from django.core.files.temp import NamedTemporaryFile
 from django.core.paginator import EmptyPage
 from django.db import transaction
 from django.http import Http404
 from django.shortcuts import render, redirect
+from django.urls import reverse
 from django.utils.decorators import method_decorator
 from django.views.decorators.csrf import csrf_protect
 
 from boards import utils, settings
 from boards.abstracts.paginator import get_paginator
-from boards.abstracts.settingsmanager import get_settings_manager,\
-        SETTING_ONLY_FAVORITES
+from boards.abstracts.settingsmanager import get_settings_manager, \
+    SETTING_ONLY_FAVORITES
 from boards.forms import ThreadForm, PlainErrorList
 from boards.models import Post, Thread, Ban
 from boards.views.banned import BannedView
 from boards.views.base import BaseBoardView, CONTEXT_FORM
+from boards.views.mixins import FileUploadMixin, PaginatedMixin, \
+    DispatcherMixin, PARAMETER_METHOD
 from boards.views.posting_mixin import PostMixin
-from boards.views.mixins import FileUploadMixin, PaginatedMixin,\
-        DispatcherMixin, PARAMETER_METHOD
 
 FORM_TAGS = 'tags'
 FORM_TEXT = 'text'
 FORM_TITLE = 'title'
 FORM_IMAGE = 'image'
 FORM_THREADS = 'threads'
 
 TAG_DELIMITER = ' '
 
 PARAMETER_CURRENT_PAGE = 'current_page'
 PARAMETER_PAGINATOR = 'paginator'
 PARAMETER_THREADS = 'threads'
 PARAMETER_ADDITIONAL = 'additional_params'
 PARAMETER_MAX_FILE_SIZE = 'max_file_size'
 PARAMETER_RSS_URL = 'rss_url'
 PARAMETER_MAX_FILES = 'max_files'
 
 TEMPLATE = 'boards/all_threads.html'
 DEFAULT_PAGE = 1
 
 FORM_TAGS = 'tags'
 
 
 class AllThreadsView(PostMixin, FileUploadMixin, BaseBoardView, PaginatedMixin, DispatcherMixin):
 
     tag_name = ''
 
     def __init__(self):
         self.settings_manager = None
         super(AllThreadsView, self).__init__()
 
     @method_decorator(csrf_protect)
     def get(self, request, form: ThreadForm=None):
         page = request.GET.get('page', DEFAULT_PAGE)
 
         params = self.get_context_data(request=request)
 
         if not form:
             form = ThreadForm(error_class=PlainErrorList,
                     initial={FORM_TAGS: self.tag_name})
 
         self.settings_manager = get_settings_manager(request)
 
         threads = self.get_threads()
 
         order = request.GET.get('order', 'bump')
         if order == 'bump':
             threads = threads.order_by('-bump_time')
         else:
             threads = threads.filter(replies__opening=True)\
                 .order_by('-replies__pub_time')
         filter = request.GET.get('filter')
         threads = threads.distinct()
 
         paginator = get_paginator(threads,
                                   settings.get_int('View', 'ThreadsPerPage'))
         paginator.current_page = int(page)
 
         try:
             threads = paginator.page(page).object_list
         except EmptyPage:
             raise Http404()
 
         params[PARAMETER_THREADS] = threads
         params[CONTEXT_FORM] = form
         params[PARAMETER_MAX_FILE_SIZE] = self.get_max_upload_size()
         params[PARAMETER_RSS_URL] = self.get_rss_url()
         params[PARAMETER_MAX_FILES] = settings.get_int('Forms', 'MaxFileCount')
 
         paginator.set_url(self.get_reverse_url(), request.GET.dict())
         params.update(self.get_page_context(paginator, page))
 
         return render(request, TEMPLATE, params)
 
     @method_decorator(csrf_protect)
     def post(self, request):
         if PARAMETER_METHOD in request.POST:
             self.dispatch_method(request)
 
             return redirect('index')  # FIXME Different for different modes
 
         form = ThreadForm(request.POST, request.FILES,
                           error_class=PlainErrorList)
         form.session = request.session
 
         if form.is_valid():
             return self.create_thread(request, form)
         if form.need_to_ban:
             # Ban user because he is suspected to be a bot
             self._ban_current_user(request)
 
         return self.get(request, form)
 
     def get_reverse_url(self):
         return reverse('index')
 
     @transaction.atomic
     def create_thread(self, request, form: ThreadForm, html_response=True):
         """
         Creates a new thread with an opening post.
         """
 
         ip = utils.get_client_ip(request)
         is_banned = Ban.objects.filter(ip=ip).exists()
 
         if is_banned:
             if html_response:
                 return redirect(BannedView().as_view())
             else:
                 return
 
         data = form.cleaned_data
 
         title = form.get_title()
         text = data[FORM_TEXT]
         files = form.get_files()
         file_urls = form.get_file_urls()
         images = form.get_images()
 
         text = self._remove_invalid_links(text)
 
         tags = data[FORM_TAGS]
         monochrome = form.is_monochrome()
         stickerpack = form.is_stickerpack()
 
         post = Post.objects.create_post(title=title, text=text, files=files,
                                         ip=ip, tags=tags,
                                         tripcode=form.get_tripcode(),
                                         monochrome=monochrome, images=images,
                                         file_urls=file_urls, stickerpack=stickerpack)
 
         if form.is_subscribe():
             settings_manager = get_settings_manager(request)
             settings_manager.add_or_read_fav_thread(post)
 
         if html_response:
             return redirect(post.get_absolute_url())
 
     def get_threads(self):
         """
         Gets list of threads that will be shown on a page.
         """
 
         threads = Thread.objects\
             .exclude(tags__in=self.settings_manager.get_hidden_tags())
         if self.settings_manager.get_setting(SETTING_ONLY_FAVORITES):
             fav_tags = self.settings_manager.get_fav_tags()
             if len(fav_tags) > 0:
                 threads = threads.filter(tags__in=fav_tags)
 
         return threads
 
     def get_rss_url(self):
         return self.get_reverse_url() + 'rss/'
 
     def toggle_fav(self, request):
         settings_manager = get_settings_manager(request)
         settings_manager.set_setting(SETTING_ONLY_FAVORITES,
                 not settings_manager.get_setting(SETTING_ONLY_FAVORITES, False))

boards/views/feed.py

@@ -1,131 +1,131 b''
-from django.core.urlresolvers import reverse
+from django.urls import reverse
 from django.shortcuts import render
 
 from boards import settings
 from boards.abstracts.paginator import get_paginator
 from boards.abstracts.settingsmanager import get_settings_manager
 from boards.models import Post
 from boards.views.base import BaseBoardView
 from boards.views.posting_mixin import PostMixin
 from boards.views.mixins import PaginatedMixin
 
 POSTS_PER_PAGE = settings.get_int('View', 'PostsPerPage')
 
 PARAMETER_POSTS = 'posts'
 PARAMETER_QUERIES = 'queries'
 
 TEMPLATE = 'boards/feed.html'
 DEFAULT_PAGE = 1
 
 
 class FeedFilter:
     @staticmethod
     def get_filtered_posts(request, posts):
         return posts
 
     @staticmethod
     def get_query(request):
         return None
 
 
 class TripcodeFilter(FeedFilter):
     @staticmethod
     def get_filtered_posts(request, posts):
         filtered_posts = posts
         tripcode = request.GET.get('tripcode', None)
         if tripcode:
             filtered_posts = filtered_posts.filter(tripcode=tripcode)
         return filtered_posts
 
     @staticmethod
     def get_query(request):
         tripcode = request.GET.get('tripcode', None)
         if tripcode:
             return 'Tripcode: {}'.format(tripcode)
 
 
 class FavoritesFilter(FeedFilter):
     @staticmethod
     def get_filtered_posts(request, posts):
         filtered_posts = posts
 
         favorites = 'favorites' in request.GET
         if favorites:
             settings_manager = get_settings_manager(request)
             fav_thread_ops = Post.objects.filter(id__in=settings_manager.get_fav_threads().keys())
             fav_threads = [op.get_thread() for op in fav_thread_ops]
             filtered_posts = filtered_posts.filter(thread__in=fav_threads)
         return filtered_posts
 
 
 class IpFilter(FeedFilter):
     @staticmethod
     def get_filtered_posts(request, posts):
         filtered_posts = posts
 
         ip = request.GET.get('ip', None)
         if ip and request.user.has_perm('post_delete'):
             filtered_posts = filtered_posts.filter(poster_ip=ip)
         return filtered_posts
 
     @staticmethod
     def get_query(request):
         ip = request.GET.get('ip', None)
         if ip:
             return 'IP: {}'.format(ip)
 
 
 class ImageFilter(FeedFilter):
     @staticmethod
     def get_filtered_posts(request, posts):
         filtered_posts = posts
 
         image = request.GET.get('image', None)
         if image:
             filtered_posts = filtered_posts.filter(attachments__file=image)
         return filtered_posts
 
     @staticmethod
     def get_query(request):
         image = request.GET.get('image', None)
         if image:
             return 'File: {}'.format(image)
 
 
 class FeedView(PostMixin, PaginatedMixin, BaseBoardView):
     filters = (
             TripcodeFilter,
             FavoritesFilter,
             IpFilter,
             ImageFilter,
     )
 
     def get(self, request):
         page = request.GET.get('page', DEFAULT_PAGE)
 
         params = self.get_context_data(request=request)
 
         settings_manager = get_settings_manager(request)
 
         posts = Post.objects.exclude(
             thread__tags__in=settings_manager.get_hidden_tags()).order_by(
             '-pub_time').prefetch_related('attachments', 'thread')
         queries = []
         for filter in self.filters:
             posts = filter.get_filtered_posts(request, posts)
             query = filter.get_query(request)
             if query:
                 queries.append(query)
         params[PARAMETER_QUERIES] = queries
 
         paginator = get_paginator(posts, POSTS_PER_PAGE)
         paginator.current_page = int(page)
 
         params[PARAMETER_POSTS] = paginator.page(page).object_list
 
         paginator.set_url(reverse('feed'), request.GET.dict())
 
         params.update(self.get_page_context(paginator, page))
 
         return render(request, TEMPLATE, params)
 

boards/views/search.py

@@ -1,54 +1,54 b''
 from django.shortcuts import render
 from django.views.generic import View
 from django.db.models import Q
-from django.core.urlresolvers import reverse
+from django.urls import reverse
 
 from boards.abstracts.paginator import get_paginator
 from boards.forms import SearchForm, PlainErrorList
 from boards.models import Post, Tag
 from boards.views.mixins import PaginatedMixin
 
 
 MIN_QUERY_LENGTH = 3
 RESULTS_PER_PAGE = 10
 
 FORM_QUERY = 'query'
 
 CONTEXT_QUERY = 'query'
 CONTEXT_FORM = 'form'
 CONTEXT_PAGE = 'page'
 CONTEXT_TAGS = 'tags'
 
 REQUEST_PAGE = 'page'
 
 __author__ = 'neko259'
 
 TEMPLATE = 'search/search.html'
 
 
 class BoardSearchView(View, PaginatedMixin):
     def get(self, request):
         params = dict()
 
         form = SearchForm(request.GET, error_class=PlainErrorList)
         params[CONTEXT_FORM] = form
 
         if form.is_valid():
             query = form.cleaned_data[FORM_QUERY]
             if len(query) >= MIN_QUERY_LENGTH:
                 results = Post.objects.filter(Q(text__icontains=query)
                         | Q(title__icontains=query) | Q(opening=True,
                             thread__tags__aliases__name__icontains=query)
                         | Q(attachments__url__icontains=query)).order_by('-id').distinct()
                 paginator = get_paginator(results, RESULTS_PER_PAGE)
                 paginator.set_url(reverse('search'), request.GET.dict())
 
                 page = int(request.GET.get(REQUEST_PAGE, '1'))
 
                 params[CONTEXT_QUERY] = query
                 params.update(self.get_page_context(paginator, page))
 
                 tags = Tag.objects.get_tag_url_list(Tag.objects.filter(aliases__name__icontains=query))
                 params[CONTEXT_TAGS] = tags
 
         return render(request, TEMPLATE, params)

boards/views/tag_gallery.py

@@ -1,32 +1,32 b''
-from django.core.urlresolvers import reverse
 from django.shortcuts import get_object_or_404, render
+from django.urls import reverse
 
 from boards import settings
 from boards.abstracts.paginator import get_paginator
-from boards.models import Tag, TagAlias
+from boards.models import TagAlias
 from boards.views.base import BaseBoardView
 from boards.views.mixins import PaginatedMixin
 
 IMAGES_PER_PAGE = settings.get_int('View', 'ImagesPerPageGallery')
 
 TEMPLATE = 'boards/tag_gallery.html'
 
 
 class TagGalleryView(BaseBoardView, PaginatedMixin):
 
     def get(self, request, tag_name):
         page = int(request.GET.get('page', 1))
 
         params = dict()
         tag_alias = get_object_or_404(TagAlias, name=tag_name)
         tag = tag_alias.parent
         params['tag'] = tag
         paginator = get_paginator(tag.get_images(), IMAGES_PER_PAGE,
                                   current_page=page)
         params['paginator'] = paginator
         params['images'] = paginator.page(page).object_list
         paginator.set_url(reverse('tag_gallery', kwargs={'tag_name': tag_name}),
                           request.GET.dict())
         params.update(self.get_page_context(paginator, page))
 
         return render(request, TEMPLATE, params)

boards/views/tag_threads.py

@@ -1,124 +1,124 b''
 from django.shortcuts import get_object_or_404, redirect
-from django.core.urlresolvers import reverse
+from django.urls import reverse
 
 from boards.abstracts.settingsmanager import get_settings_manager, \
         SETTING_FAVORITE_TAGS, SETTING_HIDDEN_TAGS
 from boards.models import Tag, TagAlias
 from boards.views.all_threads import AllThreadsView
 from boards.views.mixins import DispatcherMixin, PARAMETER_METHOD
 from boards.forms import ThreadForm, PlainErrorList
 
 PARAM_HIDDEN_TAGS = 'hidden_tags'
 PARAM_TAG = 'tag'
 PARAM_IS_FAVORITE = 'is_favorite'
 PARAM_IS_HIDDEN = 'is_hidden'
 PARAM_RANDOM_IMAGE_POST = 'random_image_post'
 PARAM_RELATED_TAGS = 'related_tags'
 
 
 __author__ = 'neko259'
 
 
 class TagView(AllThreadsView, DispatcherMixin):
 
     tag_name = None
 
     def get_threads(self):
         tag_alias = get_object_or_404(TagAlias, name=self.tag_name)
         tag = tag_alias.parent
 
         hidden_tags = self.settings_manager.get_hidden_tags()
 
         try:
             hidden_tags.remove(tag)
         except ValueError:
             pass
 
         return tag.get_threads().exclude(
             tags__in=hidden_tags)
 
     def get_context_data(self, **kwargs):
         params = super(TagView, self).get_context_data(**kwargs)
 
         settings_manager = get_settings_manager(kwargs['request'])
 
         tag_alias = get_object_or_404(TagAlias, name=self.tag_name)
         tag = tag_alias.parent
         params[PARAM_TAG] = tag
 
         fav_tag_names = settings_manager.get_setting(SETTING_FAVORITE_TAGS)
         hidden_tag_names = settings_manager.get_setting(SETTING_HIDDEN_TAGS)
 
         params[PARAM_IS_FAVORITE] = fav_tag_names is not None and tag.get_name() in fav_tag_names
         params[PARAM_IS_HIDDEN] = hidden_tag_names is not None and tag.get_name() in hidden_tag_names
 
         params[PARAM_RANDOM_IMAGE_POST] = tag.get_random_image_post()
         params[PARAM_RELATED_TAGS] = tag.get_related_tags()
 
         return params
 
     def get_reverse_url(self):
         return reverse('tag', kwargs={'tag_name': self.tag_name})
 
     def get(self, request, tag_name, form=None):
         self.tag_name = tag_name
 
         return super(TagView, self).get(request, form)
 
 
     def post(self, request, tag_name):
         self.tag_name = tag_name
 
         if PARAMETER_METHOD in request.POST:
             self.dispatch_method(request)
 
             return redirect('tag', tag_name)
         else:
             form = ThreadForm(request.POST, request.FILES,
                               error_class=PlainErrorList)
             form.session = request.session
 
             if form.is_valid():
                 return self.create_thread(request, form)
             if form.need_to_ban:
                 # Ban user because he is suspected to be a bot
                 self._ban_current_user(request)
 
             return self.get(request, tag_name, form)
 
     def subscribe(self, request):
         alias = get_object_or_404(TagAlias, name=self.tag_name)
         tag = alias.parent
 
         settings_manager = get_settings_manager(request)
         settings_manager.add_fav_tag(tag)
 
     def unsubscribe(self, request):
         alias = get_object_or_404(TagAlias, name=self.tag_name)
         tag = alias.parent
 
         settings_manager = get_settings_manager(request)
         settings_manager.del_fav_tag(tag)
 
     def hide(self, request):
         """
         Adds tag to user's hidden tags. Threads with this tag will not be
         shown.
         """
 
         alias = get_object_or_404(TagAlias, name=self.tag_name)
         tag = alias.parent
 
         settings_manager = get_settings_manager(request)
         settings_manager.add_hidden_tag(tag)
 
     def unhide(self, request):
         """
         Removed tag from user's hidden tags.
         """
 
         alias = get_object_or_404(TagAlias, name=self.tag_name)
         tag = alias.parent
 
         settings_manager = get_settings_manager(request)
         settings_manager.del_hidden_tag(tag)

boards/views/thread/thread.py

@@ -1,165 +1,159 b''
-from django.contrib.auth.decorators import permission_required
-
 from django.core.exceptions import ObjectDoesNotExist
-from django.core.urlresolvers import reverse
 from django.http import Http404
 from django.shortcuts import get_object_or_404, render, redirect
-from django.template.context_processors import csrf
+from django.urls import reverse
 from django.utils.decorators import method_decorator
 from django.views.decorators.csrf import csrf_protect
 from django.views.generic.edit import FormMixin
-from django.utils import timezone
-from django.utils.dateformat import format
 
-from boards import utils, settings
+from boards import utils
 from boards.abstracts.settingsmanager import get_settings_manager
 from boards.forms import PostForm, PlainErrorList
 from boards.models import Post
 from boards.views.base import BaseBoardView, CONTEXT_FORM
 from boards.views.mixins import DispatcherMixin, PARAMETER_METHOD
 from boards.views.posting_mixin import PostMixin
-import neboard
 
 REQ_POST_ID = 'post_id'
 
 CONTEXT_LASTUPDATE = "last_update"
 CONTEXT_THREAD = 'thread'
 CONTEXT_MODE = 'mode'
 CONTEXT_OP = 'opening_post'
 CONTEXT_FAVORITE = 'is_favorite'
 CONTEXT_RSS_URL = 'rss_url'
 
 FORM_TITLE = 'title'
 FORM_TEXT = 'text'
 FORM_IMAGE = 'image'
 FORM_THREADS = 'threads'
 
 
 class ThreadView(BaseBoardView, PostMixin, FormMixin, DispatcherMixin):
 
     @method_decorator(csrf_protect)
     def get(self, request, post_id, form: PostForm=None):
         try:
             opening_post = Post.objects.get(id=post_id)
         except ObjectDoesNotExist:
             raise Http404
 
         # If the tag is favorite, update the counter
         settings_manager = get_settings_manager(request)
         favorite = settings_manager.thread_is_fav(opening_post)
         if favorite:
             settings_manager.add_or_read_fav_thread(opening_post)
 
         # If this is not OP, don't show it as it is
         if not opening_post.is_opening():
             return redirect('{}#{}'.format(opening_post.get_thread().get_opening_post()
                             .get_absolute_url(), opening_post.id))
 
         if not form:
             form = PostForm(error_class=PlainErrorList)
 
         thread_to_show = opening_post.get_thread()
 
         params = dict()
 
         params[CONTEXT_FORM] = form
         params[CONTEXT_LASTUPDATE] = str(thread_to_show.last_edit_time)
         params[CONTEXT_THREAD] = thread_to_show
         params[CONTEXT_MODE] = self.get_mode()
         params[CONTEXT_OP] = opening_post
         params[CONTEXT_FAVORITE] = favorite
         params[CONTEXT_RSS_URL] = self.get_rss_url(post_id)
 
         params.update(self.get_data(thread_to_show))
 
         return render(request, self.get_template(), params)
 
     @method_decorator(csrf_protect)
     def post(self, request, post_id):
         opening_post = get_object_or_404(Post, id=post_id)
 
         # If this is not OP, don't show it as it is
         if not opening_post.is_opening():
             raise Http404
 
         if PARAMETER_METHOD in request.POST:
             self.dispatch_method(request, opening_post)
 
             return redirect('thread', post_id)  # FIXME Different for different modes
 
         if not opening_post.get_thread().is_archived():
             form = PostForm(request.POST, request.FILES,
                             error_class=PlainErrorList)
             form.session = request.session
 
             if form.is_valid():
                 return self.new_post(request, form, opening_post)
             if form.need_to_ban:
                 # Ban user because he is suspected to be a bot
                 self._ban_current_user(request)
 
             return self.get(request, post_id, form)
 
     def new_post(self, request, form: PostForm, opening_post: Post=None,
                  html_response=True):
         """
         Adds a new post (in thread or as a reply).
         """
 
         ip = utils.get_client_ip(request)
 
         data = form.cleaned_data
 
         title = form.get_title()
         text = data[FORM_TEXT]
         files = form.get_files()
         file_urls = form.get_file_urls()
         images = form.get_images()
 
         text = self._remove_invalid_links(text)
 
         post_thread = opening_post.get_thread()
 
         post = Post.objects.create_post(title=title, text=text, files=files,
                                         thread=post_thread, ip=ip,
                                         tripcode=form.get_tripcode(),
                                         images=images, file_urls=file_urls)
 
         if form.is_subscribe():
             settings_manager = get_settings_manager(request)
             settings_manager.add_or_read_fav_thread(
                     post_thread.get_opening_post())
 
         if html_response:
             if opening_post:
                 return redirect(post.get_absolute_url())
         else:
             return post
 
     def get_data(self, thread) -> dict:
         """
         Returns context params for the view.
         """
 
         return dict()
 
     def get_template(self) -> str:
         """
         Gets template to show the thread mode on.
         """
 
         pass
 
     def get_mode(self) -> str:
         pass
 
     def subscribe(self, request, opening_post):
         settings_manager = get_settings_manager(request)
         settings_manager.add_or_read_fav_thread(opening_post)
 
     def unsubscribe(self, request, opening_post):
         settings_manager = get_settings_manager(request)
         settings_manager.del_fav_thread(opening_post)
 
     def get_rss_url(self, opening_id):
         return reverse('thread', kwargs={'post_id': opening_id}) + 'rss/'

neboard/settings.py

@@ -1,198 +1,198 b''
 # Django settings for neboard project.
 import os
 
 DEBUG = True
 
 ADMINS = (
     # ('Your Name', '[e-mail]'),
     ('admin', '[e-mail]')
 )
 
 MANAGERS = ADMINS
 
 DATABASES = {
     'default': {
         'ENGINE': 'django.db.backends.sqlite3', # Add 'postgresql_psycopg2', 'mysql', 'sqlite3' or 'oracle'.
         'NAME': 'database.db',                      # Or path to database file if using sqlite3.
         'USER': '',                      # Not used with sqlite3.
         'PASSWORD': '',                  # Not used with sqlite3.
         'HOST': '',                      # Set to empty string for localhost. Not used with sqlite3.
         'PORT': '',                      # Set to empty string for default. Not used with sqlite3.
 	'CONN_MAX_AGE': None,
     }
 }
 
 # Local time zone for this installation. Choices can be found here:
 # http://en.wikipedia.org/wiki/List_of_tz_zones_by_name
 # although not all choices may be available on all operating systems.
 # In a Windows environment this must be set to your system time zone.
 TIME_ZONE = 'Europe/Kiev'
 
 # Language code for this installation. All choices can be found here:
 # http://www.i18nguy.com/unicode/language-identifiers.html
 LANGUAGE_CODE = 'en'
 
 SITE_ID = 1
 
 # If you set this to False, Django will make some optimizations so as not
 # to load the internationalization machinery.
 USE_I18N = True
 
 # If you set this to False, Django will not format dates, numbers and
 # calendars according to the current locale.
 USE_L10N = True
 
 # If you set this to False, Django will not use timezone-aware datetimes.
 USE_TZ = True
 
 USE_ETAGS = True
 
 # Absolute filesystem path to the directory that will hold user-uploaded files.
 # Example: "/home/media/media.lawrence.com/media/"
 MEDIA_ROOT = './media/' 
 
 # URL that handles the media served from MEDIA_ROOT. Make sure to use a
 # trailing slash.
 # Examples: "http://media.lawrence.com/media/", "http://example.com/media/"
 MEDIA_URL = '/media/'
 
 # Absolute path to the directory static files should be collected to.
 # Don't put anything in this directory yourself; store your static files
 # in apps' "static/" subdirectories and in STATICFILES_DIRS.
 # Example: "/home/media/media.lawrence.com/static/"
 STATIC_ROOT = ''
 
 # URL prefix for static files.
 # Example: "http://media.lawrence.com/static/"
 STATIC_URL = '/static/'
 
 STATICFILES_DIRS = []
 
 # List of finder classes that know how to find static files in
 # various locations.
 STATICFILES_FINDERS = (
     'django.contrib.staticfiles.finders.FileSystemFinder',
     'django.contrib.staticfiles.finders.AppDirectoriesFinder',
 )
 
 if DEBUG:
     STATICFILES_STORAGE = \
         'django.contrib.staticfiles.storage.StaticFilesStorage'
 else:
     STATICFILES_STORAGE = \
         'django.contrib.staticfiles.storage.CachedStaticFilesStorage'
 
 # Make this unique, and don't share it with anybody.
 SECRET_KEY = '@1rc$o(7=tt#kd+4s$u6wchm**z^)4x90)7f6z(i&55@o11*8o'
 
 TEMPLATES = [{
     'BACKEND': 'django.template.backends.django.DjangoTemplates',
     'DIRS': ['templates'],
     'OPTIONS': {
         'loaders': [
             ('django.template.loaders.cached.Loader', [
                 'django.template.loaders.filesystem.Loader',
                 'django.template.loaders.app_directories.Loader',
             ]),
         ],
         'context_processors': [
             'django.template.context_processors.csrf',
             'django.contrib.auth.context_processors.auth',
             'boards.context_processors.user_and_ui_processor',
         ],
     },
 }]
 
 
-MIDDLEWARE_CLASSES = [
+MIDDLEWARE = [
     'django.middleware.http.ConditionalGetMiddleware',
     'django.contrib.sessions.middleware.SessionMiddleware',
     'django.middleware.locale.LocaleMiddleware',
     'django.middleware.common.CommonMiddleware',
     'django.contrib.auth.middleware.AuthenticationMiddleware',
     'django.contrib.messages.middleware.MessageMiddleware',
     'boards.middlewares.BanMiddleware',
     'boards.middlewares.TimezoneMiddleware',
 ]
 
 ROOT_URLCONF = 'neboard.urls'
 
 # Python dotted path to the WSGI application used by Django's runserver.
 WSGI_APPLICATION = 'neboard.wsgi.application'
 
 INSTALLED_APPS = (
     'django.contrib.auth',
     'django.contrib.contenttypes',
     'django.contrib.sessions',
     'django.contrib.staticfiles',
     # Uncomment the next line to enable the admin:
     'django.contrib.admin',
     # Uncomment the next line to enable admin documentation:
     # 'django.contrib.admindocs',
     'django.contrib.messages',
 
     'debug_toolbar',
 
     'boards',
 )
 
 # A sample logging configuration. The only tangible logging
 # performed by this configuration is to send an email to
 # the site admins on every HTTP 500 error when DEBUG=False.
 # See http://docs.djangoproject.com/en/dev/topics/logging for
 # more details on how to customize your logging configuration.
 LOGGING = {
     'version': 1,
     'disable_existing_loggers': False,
     'formatters': {
         'verbose': {
             'format': '%(levelname)s %(asctime)s %(name)s %(process)d %(thread)d %(message)s'
         },
         'simple': {
             'format': '%(levelname)s %(asctime)s [%(name)s] %(message)s'
         },
     },
     'filters': {
         'require_debug_false': {
             '()': 'django.utils.log.RequireDebugFalse'
         }
     },
     'handlers': {
         'console': {
             'level': 'DEBUG',
             'class': 'logging.StreamHandler',
             'formatter': 'simple'
         },
     },
     'loggers': {
         'boards': {
             'handlers': ['console'],
             'level': 'DEBUG',
         }
     },
 }
 
 ALLOWED_HOSTS = ['*']
 
 POSTING_DELAY = 20  # seconds
 
 SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db'
 
 # Debug middlewares
-MIDDLEWARE_CLASSES += [
+MIDDLEWARE += [
     'debug_toolbar.middleware.DebugToolbarMiddleware',
 ]
 
 
 def custom_show_toolbar(request):
     return request.user.has_perm('admin.debug')
 
 DEBUG_TOOLBAR_CONFIG = {
     'ENABLE_STACKTRACES': True,
     'SHOW_TOOLBAR_CALLBACK': 'neboard.settings.custom_show_toolbar',
 }
 
 # FIXME Uncommenting this fails somehow. Need to investigate this
 #DEBUG_TOOLBAR_PANELS += (
 #    'debug_toolbar.panels.profiling.ProfilingDebugPanel',
 #)

neboard/urls.py

@@ -1,24 +1,24 b''
 from django.conf.urls import include, url
 
 # Uncomment the next two lines to enable the admin:
 from django.conf.urls.static import static
 from django.contrib import admin
 from neboard import settings
 
 from boards.views.not_found import NotFoundView
 
 admin.autodiscover()
 
 urlpatterns = [
     # Uncomment the admin/doc line below to enable admin documentation:
     # url(r'^admin/doc/', include('django.contrib.admindocs.urls')),
 
-    url(r'^admin/', include(admin.site.urls), name='admin'),
+    url(r'^admin/', admin.site.urls, name='admin'),
     url(r'^', include('boards.urls')),
 ] + static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
 
 if settings.DEBUG:
     import debug_toolbar
     urlpatterns.append(url(r'^__debug__/', include(debug_toolbar.urls)))
 
 handler404 = NotFoundView.as_view()