Merged with default

boards/abstracts/tripcode.py

@@ -0,0 +1,26 b''
+class Tripcode:
+    def __init__(self, code_str):
+        self.tripcode = code_str
+
+    def get_color(self):
+        return self.tripcode[:6]
+
+    def get_background(self):
+        code = self.get_color()
+        result = ''
+
+        for i in range(0, len(code), 2):
+            p = code[i:i+2]
+            background = hex(255 - int(p, 16))[2:]
+            if len(background) < 2:
+                background = '0' + background
+            result += background
+
+        return result
+
+    def get_short_text(self):
+        return self.tripcode[:8]
+
+    def get_full_text(self):
+        return self.tripcode
+

boards/migrations/0020_auto_20150731_1738.py

@@ -0,0 +1,19 b''
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import models, migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boards', '0019_auto_20150519_1323'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='post',
+            name='images',
+            field=models.ManyToManyField(to='boards.PostImage', blank=True, null=True, db_index=True, related_name='post_images'),
+        ),
+    ]

boards/migrations/0021_tag_description.py

@@ -0,0 +1,19 b''
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import models, migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boards', '0020_auto_20150731_1738'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='tag',
+            name='description',
+            field=models.TextField(blank=True),
+        ),
+    ]

boards/migrations/0022_auto_20150812_1819.py

@@ -0,0 +1,19 b''
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import models, migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boards', '0021_tag_description'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='thread',
+            name='tags',
+            field=models.ManyToManyField(related_name='thread_tags', to='boards.Tag'),
+        ),
+    ]

boards/migrations/0023_auto_20150818_1026.py

@@ -0,0 +1,29 b''
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import models, migrations
+import boards.models.attachment
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boards', '0022_auto_20150812_1819'),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Attachment',
+            fields=[
+                ('id', models.AutoField(verbose_name='ID', primary_key=True, serialize=False, auto_created=True)),
+                ('file', models.FileField(upload_to=boards.models.attachment.Attachment._update_filename)),
+                ('mimetype', models.CharField(max_length=50)),
+                ('hash', models.CharField(max_length=36)),
+            ],
+        ),
+        migrations.AddField(
+            model_name='post',
+            name='attachments',
+            field=models.ManyToManyField(blank=True, null=True, related_name='attachment_posts', to='boards.Attachment'),
+        ),
+    ]

boards/migrations/0024_post_tripcode.py

@@ -0,0 +1,19 b''
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import models, migrations
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boards', '0023_auto_20150818_1026'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='post',
+            name='tripcode',
+            field=models.CharField(max_length=50, null=True),
+        ),
+    ]

boards/migrations/0025_auto_20150825_2049.py

@@ -0,0 +1,21 b''
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import migrations
+
+
+class Migration(migrations.Migration):
+
+    def refuild_refmap(apps, schema_editor):
+        Post = apps.get_model('boards', 'Post')
+        for post in Post.objects.all():
+            post.build_refmap()
+            post.save(update_fields=['refmap'])
+
+    dependencies = [
+        ('boards', '0024_post_tripcode'),
+    ]
+
+    operations = [
+        migrations.RunPython(refuild_refmap),
+    ]

boards/migrations/0026_auto_20150830_2006.py

@@ -0,0 +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')),
+            ],
+        ),
+        migrations.AddField(
+            model_name='post',
+            name='global_id',
+            field=models.OneToOneField(to='boards.GlobalId', null=True, blank=True),
+        ),
+    ]

boards/models/attachment/__init__.py

@@ -0,0 +1,60 b''
+import os
+import time
+from random import random
+
+from django.db import models
+
+from boards import utils
+from boards.models.attachment.viewers import get_viewers, AbstractViewer
+
+FILES_DIRECTORY = 'files/'
+FILE_EXTENSION_DELIMITER = '.'
+
+
+class AttachmentManager(models.Manager):
+    def create_with_hash(self, file):
+        file_hash = utils.get_file_hash(file)
+        existing = self.filter(hash=file_hash)
+        if len(existing) > 0:
+            attachment = existing[0]
+        else:
+            file_type = file.name.split(FILE_EXTENSION_DELIMITER)[-1].lower()
+            attachment = Attachment.objects.create(
+                file=file, mimetype=file_type, hash=file_hash)
+
+        return attachment
+
+
+class Attachment(models.Model):
+    objects = AttachmentManager()
+
+    # TODO Dedup the method
+    def _update_filename(self, filename):
+        """
+        Gets unique filename
+        """
+
+        # TODO Use something other than random number in file name
+        new_name = '{}{}.{}'.format(
+            str(int(time.mktime(time.gmtime()))),
+            str(int(random() * 1000)),
+            filename.split(FILE_EXTENSION_DELIMITER)[-1:][0])
+
+        return os.path.join(FILES_DIRECTORY, new_name)
+
+    file = models.FileField(upload_to=_update_filename)
+    mimetype = models.CharField(max_length=50)
+    hash = models.CharField(max_length=36)
+
+    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).get_view()
+
+

boards/models/attachment/viewers.py

@@ -0,0 +1,70 b''
+from django.template.defaultfilters import filesizeformat
+from django.contrib.staticfiles.templatetags.staticfiles import static
+
+FILE_STUB_IMAGE = 'images/file.png'
+
+FILE_TYPES_VIDEO = (
+    'webm',
+    'mp4',
+)
+FILE_TYPE_SVG = 'svg'
+FILE_TYPES_AUDIO = (
+    'ogg',
+    'mp3',
+)
+
+
+def get_viewers():
+    return AbstractViewer.__subclasses__()
+
+
+class AbstractViewer:
+    def __init__(self, file, file_type):
+        self.file = file
+        self.file_type = file_type
+
+    @staticmethod
+    def supports(file_type):
+        return True
+
+    def get_view(self):
+        return '<div class="image">'\
+               '{}'\
+               '<div class="image-metadata"><a href="{}" download >{}, {}</a></div>'\
+               '</div>'.format(self.get_format_view(), self.file.url,
+                               self.file_type, filesizeformat(self.file.size))
+
+    def get_format_view(self):
+        return '<a href="{}">'\
+               '<img src="{}" width="200" height="150"/>'\
+               '</a>'.format(self.file.url, static(FILE_STUB_IMAGE))
+
+
+class VideoViewer(AbstractViewer):
+    @staticmethod
+    def supports(file_type):
+        return file_type in FILE_TYPES_VIDEO
+
+    def get_format_view(self):
+        return '<video width="200" height="150" controls src="{}"></video>'\
+               .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 controls src="{}"></audio>'.format(self.file.url)
+
+
+class SvgViewer(AbstractViewer):
+    @staticmethod
+    def supports(file_type):
+        return file_type == FILE_TYPE_SVG
+
+    def get_format_view(self):
+        return '<a class="thumb" href="{}">'\
+               '<img class="post-image-preview" width="200" height="150" src="{}" />'\
+               '</a>'.format(self.file.url, self.file.url)

boards/templates/boards/random.html

@@ -0,0 +1,37 b''
+{% extends "boards/base.html" %}
+
+{% load i18n %}
+
+{% block head %}
+    <title>{% trans 'Random images' %} - {{ site_name }}</title>
+{% endblock %}
+
+{% block content %}
+
+    {% if images %}
+        <div class="random-images-table">
+            <div>
+            {% for image in images %}
+                <div class="gallery_image">
+                    {% autoescape off %}
+                        {{ image.get_view }}
+                    {% endautoescape %}
+                    {% with image.get_random_associated_post as post %}
+                        {{ post.get_link_view|safe }}
+                        <div>
+                        {% for tag in post.get_thread.get_required_tags.all %}
+                            {{ tag.get_view|safe }}{% if not forloop.last %},{% endif %}
+                        {% endfor %}
+                        </div>
+                    {% endwith %}
+                </div>
+                {% if forloop.counter|divisibleby:"3" %}
+                </div>
+                <div>
+                {% endif %}
+            {% endfor %}
+            </div>
+        </div>
+    {% endif %}
+
+{% endblock %}

boards/views/random.py

@@ -0,0 +1,22 b''
+from django.shortcuts import render
+from django.views.generic import View
+
+from boards.models import PostImage
+
+__author__ = 'neko259'
+
+TEMPLATE = 'boards/random.html'
+
+CONTEXT_IMAGES = 'images'
+
+RANDOM_POST_COUNT = 9
+
+
+class RandomImageView(View):
+    def get(self, request):
+        params = dict()
+
+        params[CONTEXT_IMAGES] = PostImage.objects.get_random_images(
+            RANDOM_POST_COUNT)
+
+        return render(request, TEMPLATE, params)

.hgtags

@@ -1,35 +1,36 b''
 bc8fce57a613175450b8b6d933cdd85f22c04658 1.1
 784258eb652c563c288ca7652c33f52cd4733d83 1.1-stable
 1b53a22467a8fccc798935d7a26efe78e4bc7b25 1.2-stable
 1713fb7543386089e364c39703b79e57d3d851f0 1.3
 80f183ebbe132ea8433eacae9431360f31fe7083 1.4
 4330ff5a2bf6c543d8aaae8a43de1dc062f3bd13 1.4.1
 8531d7b001392289a6b761f38c73a257606552ad 1.5
 78e843c8b04b5a81cee5aa24601e305fae75da24 1.5.1
 4f92838730ed9aa1d17651bbcdca19a097fd0c37 1.6
 4bac2f37ea463337ddd27f98e7985407a74de504 1.7
 1c4febea92c6503ae557fba73b2768659ae90d24 1.7.1
 56a4a4578fc454ee455e33dd74a2cc82234bcb59 1.7.2
 34d6f3d5deb22be56b6c1512ec654bd7f6e03bcc 1.7.3
 f5cca33d29c673b67d43f310bebc4e3a21c6d04c 1.7.4
 7f7c33ba6e3f3797ca866c5ed5d358a2393f1371 1.8
 a6b9dd9547bdc17b681502efcceb17aa5c09adf4 1.8.1
 8318fa1615d1946e4519f5735ae880909521990d 2.0
 e23590ee7e2067a3f0fc3cbcfd66404b47127feb 2.1
 4d998aba79e4abf0a2e78e93baaa2c2800b1c49c 2.2
 07fdef4ac33a859250d03f17c594089792bca615 2.2.1
 bcc74d45f060ecd3ff06ff448165aea0d026cb3e 2.2.2
 b0e629ff24eb47a449ecfb455dc6cc600d18c9e2 2.2.3
 1b52ba60f17fd7c90912c14d9d17e880b7952d01 2.2.4
 957e2fec91468f739b0fc2b9936d564505048c68 2.3.0
 bb91141c6ea5c822ccbe2d46c3c48bdab683b77d 2.4.0
 97eb184637e5691b288eaf6b03e8971f3364c239 2.5.0
 119fafc5381b933bf30d97be0b278349f6135075 2.5.1
 d528d76d3242cced614fa11bb63f3d342e4e1d09 2.5.2
 1b631781ced34fbdeec032e7674bc4e131724699 2.6.0
 0f2ef17dc0de678ada279bf7eedf6c5585f1fd7a 2.6.1
 d53fc814a424d7fd90f23025c87b87baa164450e 2.7.0
 836d8bb9fcd930b952b9a02029442c71c2441983 2.8.0
 dfb6c481b1a2c33705de9a9b5304bc924c46b202 2.8.1
 4a5bec08ccfb47a27f9e98698f12dd5b7246623b 2.8.2
 604935b98f5b5e4a5e903594f048046e1fbb3519 2.8.3
+c48ffdc671566069ed0f33644da1229277f3cd18 2.9.0

boards/abstracts/settingsmanager.py

@@ -1,145 +1,148 b''
-from django.shortcuts import get_object_or_404
 from boards.models import Tag
 
+MAX_TRIPCODE_COLLISIONS = 50
+
 __author__ = 'neko259'
 
 SESSION_SETTING = 'setting'
 
 # Remove this, it is not used any more cause there is a user's permission
 PERMISSION_MODERATE = 'moderator'
 
 SETTING_THEME = 'theme'
 SETTING_FAVORITE_TAGS = 'favorite_tags'
 SETTING_HIDDEN_TAGS = 'hidden_tags'
 SETTING_PERMISSIONS = 'permissions'
 SETTING_USERNAME = 'username'
 SETTING_LAST_NOTIFICATION_ID = 'last_notification'
 SETTING_IMAGE_VIEWER = 'image_viewer'
+SETTING_TRIPCODE = 'tripcode'
 
 DEFAULT_THEME = 'md'
 
 
 class SettingsManager:
     """
     Base settings manager class. get_setting and set_setting methods should
     be overriden.
     """
     def __init__(self):
         pass
 
     def get_theme(self) -> str:
         theme = self.get_setting(SETTING_THEME)
         if not theme:
             theme = DEFAULT_THEME
             self.set_setting(SETTING_THEME, theme)
 
         return theme
 
     def set_theme(self, theme):
         self.set_setting(SETTING_THEME, theme)
 
     def has_permission(self, permission):
         permissions = self.get_setting(SETTING_PERMISSIONS)
         if permissions:
             return permission in permissions
         else:
             return False
 
     def get_setting(self, setting, default=None):
         pass
 
     def set_setting(self, setting, value):
         pass
 
     def add_permission(self, permission):
         permissions = self.get_setting(SETTING_PERMISSIONS)
         if not permissions:
             permissions = [permission]
         else:
             permissions.append(permission)
         self.set_setting(SETTING_PERMISSIONS, permissions)
 
     def del_permission(self, permission):
         permissions = self.get_setting(SETTING_PERMISSIONS)
         if not permissions:
             permissions = []
         else:
             permissions.remove(permission)
         self.set_setting(SETTING_PERMISSIONS, permissions)
 
     def get_fav_tags(self) -> list:
         tag_names = self.get_setting(SETTING_FAVORITE_TAGS)
         tags = []
         if tag_names:
             tags = list(Tag.objects.filter(name__in=tag_names))
         return tags
 
     def add_fav_tag(self, tag):
         tags = self.get_setting(SETTING_FAVORITE_TAGS)
         if not tags:
             tags = [tag.name]
         else:
             if not tag.name in tags:
                 tags.append(tag.name)
 
         tags.sort()
         self.set_setting(SETTING_FAVORITE_TAGS, tags)
 
     def del_fav_tag(self, tag):
         tags = self.get_setting(SETTING_FAVORITE_TAGS)
         if tag.name in tags:
             tags.remove(tag.name)
             self.set_setting(SETTING_FAVORITE_TAGS, tags)
 
     def get_hidden_tags(self) -> list:
         tag_names = self.get_setting(SETTING_HIDDEN_TAGS)
         tags = []
         if tag_names:
             tags = list(Tag.objects.filter(name__in=tag_names))
 
         return tags
 
     def add_hidden_tag(self, tag):
         tags = self.get_setting(SETTING_HIDDEN_TAGS)
         if not tags:
             tags = [tag.name]
         else:
             if not tag.name in tags:
                 tags.append(tag.name)
 
         tags.sort()
         self.set_setting(SETTING_HIDDEN_TAGS, tags)
 
     def del_hidden_tag(self, tag):
         tags = self.get_setting(SETTING_HIDDEN_TAGS)
         if tag.name in tags:
             tags.remove(tag.name)
             self.set_setting(SETTING_HIDDEN_TAGS, tags)
 
 
 class SessionSettingsManager(SettingsManager):
     """
     Session-based settings manager. All settings are saved to the user's
     session.
     """
     def __init__(self, session):
         SettingsManager.__init__(self)
         self.session = session
 
     def get_setting(self, setting, default=None):
         if setting in self.session:
             return self.session[setting]
         else:
+            self.set_setting(setting, default)
             return default
 
     def set_setting(self, setting, value):
         self.session[setting] = value
 
 
 def get_settings_manager(request) -> SettingsManager:
     """
     Get settings manager based on the request object. Currently only
     session-based manager is supported. In the future, cookie-based or
     database-based managers could be implemented.
     """
     return SessionSettingsManager(request.session)

boards/config/default_settings.ini

@@ -1,33 +1,33 b''
 [Version]
-Version = 2.8.3 Charlie
+Version = 2.9.0 Claire
 SiteName = Neboard DEV
 
 [Cache]
 # Timeout for caching, if cache is used
 CacheTimeout = 600
 
 [Forms]
 # Max post length in characters
 MaxTextLength = 30000
-MaxImageSize = 8000000
+MaxFileSize = 8000000
 LimitPostingSpeed = false
 
 [Messages]
 # Thread bumplimit
 MaxPostsPerThread = 10
 # Old posts will be archived or deleted if this value is reached
 MaxThreadCount = 5
 
 [View]
 DefaultTheme = md
 DefaultImageViewer = simple
 LastRepliesCount = 3
 ThreadsPerPage = 3
 
 [Storage]
 # Enable archiving threads instead of deletion when the thread limit is reached
 ArchiveThreads = true
 
 [External]
 # Thread update
 WebsocketsEnabled = false

boards/forms.py

@@ -1,387 +1,395 b''
+import hashlib
 import re
 import time
+
 import pytz
-
 from django import forms
 from django.core.files.uploadedfile import SimpleUploadedFile
 from django.core.exceptions import ObjectDoesNotExist
 from django.forms.util import ErrorList
 from django.utils.translation import ugettext_lazy as _
 import requests
 
 from boards.mdx_neboard import formatters
 from boards.models.post import TITLE_MAX_LENGTH
 from boards.models import Tag, Post
 from neboard import settings
 import boards.settings as board_settings
+import neboard
 
 HEADER_CONTENT_LENGTH = 'content-length'
 HEADER_CONTENT_TYPE = 'content-type'
 
-CONTENT_TYPE_IMAGE = (
-    'image/jpeg',
-    'image/jpg',
-    'image/png',
-    'image/gif',
-    'image/bmp',
-)
-
 REGEX_TAGS = re.compile(r'^[\w\s\d]+$', re.UNICODE)
 
 VETERAN_POSTING_DELAY = 5
 
 ATTRIBUTE_PLACEHOLDER = 'placeholder'
 ATTRIBUTE_ROWS = 'rows'
 
 LAST_POST_TIME = 'last_post_time'
 LAST_LOGIN_TIME = 'last_login_time'
 TEXT_PLACEHOLDER = _('Type message here. Use formatting panel for more advanced usage.')
 TAGS_PLACEHOLDER = _('music images i_dont_like_tags')
 
 LABEL_TITLE = _('Title')
 LABEL_TEXT = _('Text')
 LABEL_TAG = _('Tag')
 LABEL_SEARCH = _('Search')
 
 ERROR_SPEED = _('Please wait %s seconds before sending message')
 
 TAG_MAX_LENGTH = 20
 
-IMAGE_DOWNLOAD_CHUNK_BYTES = 100000
+FILE_DOWNLOAD_CHUNK_BYTES = 100000
 
 HTTP_RESULT_OK = 200
 
 TEXTAREA_ROWS = 4
 
 
 def get_timezones():
     timezones = []
     for tz in pytz.common_timezones:
         timezones.append((tz, tz),)
     return timezones
 
 
 class FormatPanel(forms.Textarea):
     """
     Panel for text formatting. Consists of buttons to add different tags to the
     form text area.
     """
 
     def render(self, name, value, attrs=None):
         output = '<div id="mark-panel">'
         for formatter in formatters:
             output += '<span class="mark_btn"' + \
                       ' onClick="addMarkToMsg(\'' + formatter.format_left + \
                       '\', \'' + formatter.format_right + '\')">' + \
                       formatter.preview_left + formatter.name + \
                       formatter.preview_right + '</span>'
 
         output += '</div>'
         output += super(FormatPanel, self).render(name, value, attrs=None)
 
         return output
 
 
 class PlainErrorList(ErrorList):
     def __unicode__(self):
         return self.as_text()
 
     def as_text(self):
         return ''.join(['(!) %s ' % e for e in self])
 
 
 class NeboardForm(forms.Form):
     """
     Form with neboard-specific formatting.
     """
 
     def as_div(self):
         """
         Returns this form rendered as HTML <as_div>s.
         """
 
         return self._html_output(
             # TODO Do not show hidden rows in the list here
             normal_row='<div class="form-row">'
                        '<div class="form-label">'
                        '%(label)s'
                        '</div>'
                        '<div class="form-input">'
                        '%(field)s'
                        '</div>'
                        '</div>'
                        '<div class="form-row">'
                        '%(help_text)s'
                        '</div>',
             error_row='<div class="form-row">'
                       '<div class="form-label"></div>'
                       '<div class="form-errors">%s</div>'
                       '</div>',
             row_ender='</div>',
             help_text_html='%s',
             errors_on_separate_row=True)
 
     def as_json_errors(self):
         errors = []
 
         for name, field in list(self.fields.items()):
             if self[name].errors:
                 errors.append({
                     'field': name,
                     'errors': self[name].errors.as_text(),
                 })
 
         return errors
 
 
 class PostForm(NeboardForm):
 
     title = forms.CharField(max_length=TITLE_MAX_LENGTH, required=False,
-                            label=LABEL_TITLE)
+                            label=LABEL_TITLE,
+                            widget=forms.TextInput(
+                                attrs={ATTRIBUTE_PLACEHOLDER:
+                                           'test#tripcode'}))
     text = forms.CharField(
         widget=FormatPanel(attrs={
             ATTRIBUTE_PLACEHOLDER: TEXT_PLACEHOLDER,
             ATTRIBUTE_ROWS: TEXTAREA_ROWS,
         }),
         required=False, label=LABEL_TEXT)
-    image = forms.ImageField(required=False, label=_('Image'),
+    file = forms.FileField(required=False, label=_('File'),
                              widget=forms.ClearableFileInput(
-                                 attrs={'accept': 'image/*'}))
-    image_url = forms.CharField(required=False, label=_('Image URL'),
+                                 attrs={'accept': 'file/*'}))
+    file_url = forms.CharField(required=False, label=_('File URL'),
                                 widget=forms.TextInput(
                                     attrs={ATTRIBUTE_PLACEHOLDER:
                                                'http://example.com/image.png'}))
 
     # This field is for spam prevention only
     email = forms.CharField(max_length=100, required=False, label=_('e-mail'),
                             widget=forms.TextInput(attrs={
                                 'class': 'form-email'}))
     threads = forms.CharField(required=False, label=_('Additional threads'),
             widget=forms.TextInput(attrs={ATTRIBUTE_PLACEHOLDER:
                 '123 456 789'}))
 
     session = None
     need_to_ban = False
 
     def clean_title(self):
         title = self.cleaned_data['title']
         if title:
             if len(title) > TITLE_MAX_LENGTH:
                 raise forms.ValidationError(_('Title must have less than %s '
                                               'characters') %
                                             str(TITLE_MAX_LENGTH))
         return title
 
     def clean_text(self):
         text = self.cleaned_data['text'].strip()
         if text:
             max_length = board_settings.get_int('Forms', 'MaxTextLength')
             if len(text) > max_length:
                 raise forms.ValidationError(_('Text must have less than %s '
                                               'characters') % str(max_length))
         return text
 
-    def clean_image(self):
-        image = self.cleaned_data['image']
+    def clean_file(self):
+        file = self.cleaned_data['file']
 
-        if image:
-            self.validate_image_size(image.size)
+        if file:
+            self.validate_file_size(file.size)
 
-        return image
+        return file
 
-    def clean_image_url(self):
-        url = self.cleaned_data['image_url']
+    def clean_file_url(self):
+        url = self.cleaned_data['file_url']
 
-        image = None
+        file = None
         if url:
-            image = self._get_image_from_url(url)
+            file = self._get_file_from_url(url)
 
-            if not image:
+            if not file:
                 raise forms.ValidationError(_('Invalid URL'))
             else:
-                self.validate_image_size(image.size)
+                self.validate_file_size(file.size)
 
-        return image
+        return file
 
     def clean_threads(self):
         threads_str = self.cleaned_data['threads']
 
         if len(threads_str) > 0:
             threads_id_list = threads_str.split(' ')
 
             threads = list()
 
             for thread_id in threads_id_list:
                 try:
                     thread = Post.objects.get(id=int(thread_id))
                     if not thread.is_opening() or thread.get_thread().archived:
                         raise ObjectDoesNotExist()
                     threads.append(thread)
                 except (ObjectDoesNotExist, ValueError):
                     raise forms.ValidationError(_('Invalid additional thread list'))
 
             return threads
 
     def clean(self):
         cleaned_data = super(PostForm, self).clean()
 
         if cleaned_data['email']:
             self.need_to_ban = True
             raise forms.ValidationError('A human cannot enter a hidden field')
 
         if not self.errors:
-            self._clean_text_image()
+            self._clean_text_file()
 
         if not self.errors and self.session:
             self._validate_posting_speed()
 
         return cleaned_data
 
-    def get_image(self):
+    def get_file(self):
         """
-        Gets image from file or URL.
+        Gets file from form or URL.
         """
 
-        image = self.cleaned_data['image']
-        return image if image else self.cleaned_data['image_url']
+        file = self.cleaned_data['file']
+        return file or self.cleaned_data['file_url']
+
+    def get_tripcode(self):
+        title = self.cleaned_data['title']
+        if title is not None and '#' in title:
+            code = title.split('#', maxsplit=1)[1] + neboard.settings.SECRET_KEY
+            return hashlib.md5(code.encode()).hexdigest()
 
-    def _clean_text_image(self):
+    def get_title(self):
+        title = self.cleaned_data['title']
+        if title is not None and '#' in title:
+            return title.split('#', maxsplit=1)[0]
+        else:
+            return title
+
+    def _clean_text_file(self):
         text = self.cleaned_data.get('text')
-        image = self.get_image()
+        file = self.get_file()
 
-        if (not text) and (not image):
-            error_message = _('Either text or image must be entered.')
+        if (not text) and (not file):
+            error_message = _('Either text or file must be entered.')
             self._errors['text'] = self.error_class([error_message])
 
     def _validate_posting_speed(self):
         can_post = True
 
         posting_delay = settings.POSTING_DELAY
 
         if board_settings.get_bool('Forms', 'LimitPostingSpeed'):
             now = time.time()
 
             current_delay = 0
             need_delay = False
 
             if not LAST_POST_TIME in self.session:
                 self.session[LAST_POST_TIME] = now
 
                 need_delay = True
             else:
                 last_post_time = self.session.get(LAST_POST_TIME)
                 current_delay = int(now - last_post_time)
 
                 need_delay = current_delay < posting_delay
 
             if need_delay:
                 error_message = ERROR_SPEED % str(posting_delay
                         - current_delay)
                 self._errors['text'] = self.error_class([error_message])
 
                 can_post = False
 
             if can_post:
                 self.session[LAST_POST_TIME] = now
 
-    def validate_image_size(self, size: int):
-        max_size = board_settings.get_int('Forms', 'MaxImageSize')
+    def validate_file_size(self, size: int):
+        max_size = board_settings.get_int('Forms', 'MaxFileSize')
         if size > max_size:
             raise forms.ValidationError(
-                _('Image must be less than %s bytes')
+                _('File must be less than %s bytes')
                 % str(max_size))
 
-    def _get_image_from_url(self, url: str) -> SimpleUploadedFile:
+    def _get_file_from_url(self, url: str) -> SimpleUploadedFile:
         """
-        Gets an image file from URL.
+        Gets an file file from URL.
         """
 
         img_temp = None
 
         try:
             # Verify content headers
             response_head = requests.head(url, verify=False)
             content_type = response_head.headers[HEADER_CONTENT_TYPE].split(';')[0]
-            if content_type in CONTENT_TYPE_IMAGE:
                 length_header = response_head.headers.get(HEADER_CONTENT_LENGTH)
                 if length_header:
                     length = int(length_header)
-                    self.validate_image_size(length)
+                self.validate_file_size(length)
                 # Get the actual content into memory
                 response = requests.get(url, verify=False, stream=True)
 
-                # Download image, stop if the size exceeds limit
+            # Download file, stop if the size exceeds limit
                 size = 0
                 content = b''
-                for chunk in response.iter_content(IMAGE_DOWNLOAD_CHUNK_BYTES):
+            for chunk in response.iter_content(FILE_DOWNLOAD_CHUNK_BYTES):
                     size += len(chunk)
-                    self.validate_image_size(size)
+                self.validate_file_size(size)
                     content += chunk
 
                 if response.status_code == HTTP_RESULT_OK and content:
                     # Set a dummy file name that will be replaced
                     # anyway, just keep the valid extension
-                    filename = 'image.' + content_type.split('/')[1]
+                filename = 'file.' + content_type.split('/')[1]
                     img_temp = SimpleUploadedFile(filename, content,
                                                   content_type)
-        except Exception:
-            # Just return no image
+        except Exception as e:
+            # Just return no file
             pass
 
         return img_temp
 
 
 class ThreadForm(PostForm):
 
     tags = forms.CharField(
         widget=forms.TextInput(attrs={ATTRIBUTE_PLACEHOLDER: TAGS_PLACEHOLDER}),
         max_length=100, label=_('Tags'), required=True)
 
     def clean_tags(self):
         tags = self.cleaned_data['tags'].strip()
 
         if not tags or not REGEX_TAGS.match(tags):
             raise forms.ValidationError(
                 _('Inappropriate characters in tags.'))
 
         required_tag_exists = False
         for tag in tags.split():
             try:
                 Tag.objects.get(name=tag.strip().lower(), required=True)
                 required_tag_exists = True
                 break
             except ObjectDoesNotExist:
                 pass
 
         if not required_tag_exists:
             all_tags = Tag.objects.filter(required=True)
             raise forms.ValidationError(
-                _('Need at least one of the tags: ')
-                + ', '.join([tag.name for tag in all_tags]))
+                _('Need at least one section.'))
 
         return tags
 
     def clean(self):
         cleaned_data = super(ThreadForm, self).clean()
 
         return cleaned_data
 
 
 class SettingsForm(NeboardForm):
 
     theme = forms.ChoiceField(choices=settings.THEMES, label=_('Theme'))
     image_viewer = forms.ChoiceField(choices=settings.IMAGE_VIEWERS, label=_('Image view mode'))
     username = forms.CharField(label=_('User name'), required=False)
     timezone = forms.ChoiceField(choices=get_timezones(), label=_('Time zone'))
 
     def clean_username(self):
         username = self.cleaned_data['username']
 
         if username and not REGEX_TAGS.match(username):
             raise forms.ValidationError(_('Inappropriate characters.'))
 
         return username
 
 
 class SearchForm(NeboardForm):
     query = forms.CharField(max_length=500, label=LABEL_SEARCH, required=False)

boards/locale/ru/LC_MESSAGES/django.po

@@ -1,431 +1,462 b''
 # SOME DESCRIPTIVE TITLE.
 # Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER
 # This file is distributed under the same license as the PACKAGE package.
 # FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
 #
 msgid ""
 msgstr ""
 "Project-Id-Version: PACKAGE VERSION\n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2015-05-19 17:51+0300\n"
+"POT-Creation-Date: 2015-08-22 15:07+0300\n"
 "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
 "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
 "Language-Team: LANGUAGE <[e-mail]>\n"
 "Language: ru\n"
 "MIME-Version: 1.0\n"
 "Content-Type: text/plain; charset=UTF-8\n"
 "Content-Transfer-Encoding: 8bit\n"
 "Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n"
 "%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
 
 #: admin.py:22
 msgid "{} posters were banned"
 msgstr ""
 
 #: authors.py:9
 msgid "author"
 msgstr "автор"
 
 #: authors.py:10
 msgid "developer"
 msgstr "разработчик"
 
 #: authors.py:11
 msgid "javascript developer"
 msgstr "разработчик javascript"
 
 #: authors.py:12
 msgid "designer"
 msgstr "дизайнер"
 
-#: forms.py:35
+#: forms.py:31
 msgid "Type message here. Use formatting panel for more advanced usage."
 msgstr ""
 "Вводите сообщение сюда. Используйте панель для более сложного форматирования."
 
-#: forms.py:36
+#: forms.py:32
 msgid "music images i_dont_like_tags"
 msgstr "музыка картинки теги_не_нужны"
 
-#: forms.py:38
+#: forms.py:34
 msgid "Title"
 msgstr "Заголовок"
 
-#: forms.py:39
+#: forms.py:35
 msgid "Text"
 msgstr "Текст"
 
-#: forms.py:40
+#: forms.py:36
 msgid "Tag"
 msgstr "Метка"
 
-#: forms.py:41 templates/boards/base.html:40 templates/search/search.html:7
+#: forms.py:37 templates/boards/base.html:40 templates/search/search.html:7
 msgid "Search"
 msgstr "Поиск"
 
-#: forms.py:43
+#: forms.py:39
 #, python-format
 msgid "Please wait %s seconds before sending message"
 msgstr "Пожалуйста подождите %s секунд перед отправкой сообщения"
 
-#: forms.py:144
-msgid "Image"
-msgstr "Изображение"
+#: forms.py:140
+msgid "File"
+msgstr "Файл"
 
-#: forms.py:147
-msgid "Image URL"
-msgstr "URL изображения"
+#: forms.py:143
+msgid "File URL"
+msgstr "URL файла"
 
-#: forms.py:153
+#: forms.py:149
 msgid "e-mail"
 msgstr ""
 
-#: forms.py:156
+#: forms.py:152
 msgid "Additional threads"
 msgstr "Дополнительные темы"
 
-#: forms.py:167
+#: forms.py:155
+msgid "Tripcode"
+msgstr "Трипкод"
+
+#: forms.py:164
 #, python-format
 msgid "Title must have less than %s characters"
 msgstr "Заголовок должен иметь меньше %s символов"
 
-#: forms.py:177
+#: forms.py:174
 #, python-format
 msgid "Text must have less than %s characters"
 msgstr "Текст должен быть короче %s символов"
 
-#: forms.py:197
+#: forms.py:194
 msgid "Invalid URL"
 msgstr "Неверный URL"
 
-#: forms.py:218
+#: forms.py:215
 msgid "Invalid additional thread list"
 msgstr "Неверный список дополнительных тем"
 
-#: forms.py:250
-msgid "Either text or image must be entered."
-msgstr "Текст или картинка должны быть введены."
+#: forms.py:251
+msgid "Either text or file must be entered."
+msgstr "Текст или файл должны быть введены."
 
-#: forms.py:288
+#: forms.py:289
 #, python-format
-msgid "Image must be less than %s bytes"
-msgstr "Изображение должно быть менее %s байт"
+msgid "File must be less than %s bytes"
+msgstr "Файл должен быть менее %s байт"
 
-#: forms.py:335 templates/boards/all_threads.html:129
+#: forms.py:335 templates/boards/all_threads.html:154
 #: templates/boards/rss/post.html:10 templates/boards/tags.html:6
 msgid "Tags"
 msgstr "Метки"
 
 #: forms.py:342
 msgid "Inappropriate characters in tags."
 msgstr "Недопустимые символы в метках."
 
 #: forms.py:356
-msgid "Need at least one of the tags: "
-msgstr "Нужна хотя бы одна из меток: "
+msgid "Need at least one section."
+msgstr "Нужен хотя бы один раздел."
 
-#: forms.py:369
+#: forms.py:368
 msgid "Theme"
 msgstr "Тема"
 
-#: forms.py:370
+#: forms.py:369
+#| msgid "Image view mode"
 msgid "Image view mode"
 msgstr "Режим просмотра изображений"
 
-#: forms.py:371
+#: forms.py:370
 msgid "User name"
 msgstr "Имя пользователя"
 
-#: forms.py:372
+#: forms.py:371
 msgid "Time zone"
 msgstr "Часовой пояс"
 
-#: forms.py:378
+#: forms.py:377
 msgid "Inappropriate characters."
 msgstr "Недопустимые символы."
 
 #: templates/boards/404.html:6
 msgid "Not found"
 msgstr "Не найдено"
 
 #: templates/boards/404.html:12
 msgid "This page does not exist"
 msgstr "Этой страницы не существует"
 
 #: templates/boards/all_threads.html:35
 msgid "Related message"
 msgstr "Связанное сообщение"
 
-#: templates/boards/all_threads.html:60
+#: templates/boards/all_threads.html:71
 msgid "Edit tag"
 msgstr "Изменить метку"
 
-#: templates/boards/all_threads.html:63
+#: templates/boards/all_threads.html:79
 #, python-format
-msgid "This tag has %(thread_count)s threads and %(post_count)s posts."
-msgstr "С этой меткой есть %(thread_count)s тем и %(post_count)s сообщений."
+msgid ""
+"This tag has %(thread_count)s threads (%(active_thread_count)s active) and "
+"%(post_count)s posts."
+msgstr ""
+"С этой меткой есть %(thread_count)s тем (%(active_thread_count)s активных) и "
+"%(post_count)s сообщений."
 
-#: templates/boards/all_threads.html:70 templates/boards/feed.html:30
+#: templates/boards/all_threads.html:81
+msgid "Related tags:"
+msgstr "Похожие метки:"
+
+#: templates/boards/all_threads.html:96 templates/boards/feed.html:30
 #: templates/boards/notifications.html:17 templates/search/search.html:26
 msgid "Previous page"
 msgstr "Предыдущая страница"
 
-#: templates/boards/all_threads.html:84
+#: templates/boards/all_threads.html:110
 #, python-format
 msgid "Skipped %(count)s replies. Open thread to see all replies."
 msgstr "Пропущено %(count)s ответов. Откройте тред, чтобы увидеть все ответы."
 
-#: templates/boards/all_threads.html:102 templates/boards/feed.html:40
+#: templates/boards/all_threads.html:128 templates/boards/feed.html:40
 #: templates/boards/notifications.html:27 templates/search/search.html:37
 msgid "Next page"
 msgstr "Следующая страница"
 
-#: templates/boards/all_threads.html:107
+#: templates/boards/all_threads.html:133
 msgid "No threads exist. Create the first one!"
 msgstr "Нет тем. Создайте первую!"
 
-#: templates/boards/all_threads.html:113
+#: templates/boards/all_threads.html:139
 msgid "Create new thread"
 msgstr "Создать новую тему"
 
-#: templates/boards/all_threads.html:118 templates/boards/preview.html:16
+#: templates/boards/all_threads.html:144 templates/boards/preview.html:16
 #: templates/boards/thread_normal.html:38
 msgid "Post"
 msgstr "Отправить"
 
-#: templates/boards/all_threads.html:123
+#: templates/boards/all_threads.html:149
 msgid "Tags must be delimited by spaces. Text or image is required."
 msgstr ""
 "Метки должны быть разделены пробелами. Текст или изображение обязательны."
 
-#: templates/boards/all_threads.html:126
-#: templates/boards/thread_normal.html:43
+#: templates/boards/all_threads.html:151 templates/boards/preview.html:6
+#: templates/boards/staticpages/help.html:21
+#: templates/boards/thread_normal.html:42
+msgid "Preview"
+msgstr "Предпросмотр"
+
+#: templates/boards/all_threads.html:153 templates/boards/thread_normal.html:45
 msgid "Text syntax"
 msgstr "Синтаксис текста"
 
-#: templates/boards/all_threads.html:143 templates/boards/feed.html:53
+#: templates/boards/all_threads.html:167 templates/boards/feed.html:53
 msgid "Pages:"
 msgstr "Страницы: "
 
 #: templates/boards/authors.html:6 templates/boards/authors.html.py:12
 msgid "Authors"
 msgstr "Авторы"
 
 #: templates/boards/authors.html:26
 msgid "Distributed under the"
 msgstr "Распространяется под"
 
 #: templates/boards/authors.html:28
 msgid "license"
 msgstr "лицензией"
 
 #: templates/boards/authors.html:30
 msgid "Repository"
 msgstr "Репозиторий"
 
 #: templates/boards/base.html:14 templates/boards/base.html.py:41
 msgid "Feed"
 msgstr "Лента"
 
 #: templates/boards/base.html:31
 msgid "All threads"
 msgstr "Все темы"
 
 #: templates/boards/base.html:37
 msgid "Add tags"
 msgstr "Добавить метки"
 
 #: templates/boards/base.html:39
 msgid "Tag management"
 msgstr "Управление метками"
 
 #: templates/boards/base.html:39
 msgid "tags"
 msgstr "метки"
 
 #: templates/boards/base.html:40
 msgid "search"
 msgstr "поиск"
 
 #: templates/boards/base.html:41 templates/boards/feed.html:11
 msgid "feed"
 msgstr "лента"
 
-#: templates/boards/base.html:44 templates/boards/base.html.py:45
+#: templates/boards/base.html:42 templates/boards/random.html:6
+msgid "Random images"
+msgstr "Случайные изображения"
+
+#: templates/boards/base.html:42
+msgid "random"
+msgstr "случайные"
+
+#: templates/boards/base.html:45 templates/boards/base.html.py:46
 #: templates/boards/notifications.html:8
 msgid "Notifications"
 msgstr "Уведомления"
 
-#: templates/boards/base.html:52 templates/boards/settings.html:8
+#: templates/boards/base.html:53 templates/boards/settings.html:8
 msgid "Settings"
 msgstr "Настройки"
 
-#: templates/boards/base.html:65
+#: templates/boards/base.html:66
 msgid "Admin"
 msgstr "Администрирование"
 
-#: templates/boards/base.html:67
+#: templates/boards/base.html:68
 #, python-format
 msgid "Speed: %(ppd)s posts per day"
 msgstr "Скорость: %(ppd)s сообщений в день"
 
-#: templates/boards/base.html:69
+#: templates/boards/base.html:70
 msgid "Up"
 msgstr "Вверх"
 
 #: templates/boards/feed.html:45
 msgid "No posts exist. Create the first one!"
 msgstr "Нет сообщений. Создайте первое!"
 
-#: templates/boards/post.html:25
+#: templates/boards/post.html:30
 msgid "Open"
 msgstr "Открыть"
 
-#: templates/boards/post.html:27 templates/boards/post.html.py:38
+#: templates/boards/post.html:32 templates/boards/post.html.py:43
 msgid "Reply"
 msgstr "Ответить"
 
-#: templates/boards/post.html:33
+#: templates/boards/post.html:38
 msgid " in "
 msgstr " в "
 
-#: templates/boards/post.html:43
+#: templates/boards/post.html:48
 msgid "Edit"
 msgstr "Изменить"
 
-#: templates/boards/post.html:45
+#: templates/boards/post.html:50
 msgid "Edit thread"
 msgstr "Изменить тему"
 
-#: templates/boards/post.html:84
+#: templates/boards/post.html:97
 msgid "Replies"
 msgstr "Ответы"
 
-#: templates/boards/post.html:97 templates/boards/thread.html:37
+#: templates/boards/post.html:109 templates/boards/thread.html:34
 msgid "messages"
 msgstr "сообщений"
 
-#: templates/boards/post.html:98 templates/boards/thread.html:38
+#: templates/boards/post.html:110 templates/boards/thread.html:35
 msgid "images"
 msgstr "изображений"
 
-#: templates/boards/preview.html:6 templates/boards/staticpages/help.html:20
-msgid "Preview"
-msgstr "Предпросмотр"
-
 #: templates/boards/rss/post.html:5
 msgid "Post image"
 msgstr "Изображение сообщения"
 
-#: templates/boards/settings.html:16
+#: templates/boards/settings.html:15
 msgid "You are moderator."
 msgstr "Вы модератор."
 
-#: templates/boards/settings.html:20
+#: templates/boards/settings.html:19
 msgid "Hidden tags:"
 msgstr "Скрытые метки:"
 
-#: templates/boards/settings.html:28
+#: templates/boards/settings.html:27
 msgid "No hidden tags."
 msgstr "Нет скрытых меток."
 
+#: templates/boards/settings.html:29
+msgid "Tripcode:"
+msgstr "Трипкод:"
+
+#: templates/boards/settings.html:29
+msgid "reset"
+msgstr "сбросить"
+
 #: templates/boards/settings.html:37
 msgid "Save"
 msgstr "Сохранить"
 
 #: templates/boards/staticpages/banned.html:6
 msgid "Banned"
 msgstr "Заблокирован"
 
 #: templates/boards/staticpages/banned.html:11
 msgid "Your IP address has been banned. Contact the administrator"
 msgstr "Ваш IP адрес был заблокирован. Свяжитесь с администратором"
 
 #: templates/boards/staticpages/help.html:6
 #: templates/boards/staticpages/help.html:10
 msgid "Syntax"
 msgstr "Синтаксис"
 
 #: templates/boards/staticpages/help.html:11
 msgid "Italic text"
 msgstr "Курсивный текст"
 
 #: templates/boards/staticpages/help.html:12
 msgid "Bold text"
 msgstr "Полужирный текст"
 
 #: templates/boards/staticpages/help.html:13
 msgid "Spoiler"
 msgstr "Спойлер"
 
 #: templates/boards/staticpages/help.html:14
 msgid "Link to a post"
 msgstr "Ссылка на сообщение"
 
 #: templates/boards/staticpages/help.html:15
 msgid "Strikethrough text"
 msgstr "Зачеркнутый текст"
 
 #: templates/boards/staticpages/help.html:16
 msgid "Comment"
 msgstr "Комментарий"
 
 #: templates/boards/staticpages/help.html:17
 #: templates/boards/staticpages/help.html:18
 msgid "Quote"
 msgstr "Цитата"
 
-#: templates/boards/staticpages/help.html:20
+#: templates/boards/staticpages/help.html:21
 msgid "You can try pasting the text and previewing the result here:"
 msgstr "Вы можете попробовать вставить текст и проверить результат здесь:"
 
-#: templates/boards/tags.html:21
-msgid "No tags found."
-msgstr "Метки не найдены."
+#: templates/boards/tags.html:17
+msgid "Sections:"
+msgstr "Разделы:"
 
-#: templates/boards/tags.html:24
-msgid "All tags"
-msgstr "Все метки"
+#: templates/boards/tags.html:30
+msgid "Other tags:"
+msgstr "Другие метки:"
+
+#: templates/boards/tags.html:43
+msgid "All tags..."
+msgstr "Все метки..."
 
 #: templates/boards/thread.html:15
-#| msgid "Normal mode"
 msgid "Normal"
 msgstr "Нормальный"
 
 #: templates/boards/thread.html:16
-#| msgid "Gallery mode"
 msgid "Gallery"
 msgstr "Галерея"
 
 #: templates/boards/thread.html:17
-#| msgid "Tree mode"
 msgid "Tree"
 msgstr "Дерево"
 
-#: templates/boards/thread.html:39
+#: templates/boards/thread.html:36
 msgid "Last update: "
 msgstr "Последнее обновление: "
 
 #: templates/boards/thread_gallery.html:36
 msgid "No images."
 msgstr "Нет изображений."
 
 #: templates/boards/thread_normal.html:17
 msgid "posts to bumplimit"
 msgstr "сообщений до бамплимита"
 
 #: templates/boards/thread_normal.html:31
 msgid "Reply to thread"
 msgstr "Ответить в тему"
 
-#: templates/boards/thread_normal.html:44
+#: templates/boards/thread_normal.html:31
+msgid "to message "
+msgstr "на сообщение"
+
+#: templates/boards/thread_normal.html:46
 msgid "Close form"
 msgstr "Закрыть форму"
 
-#: templates/boards/thread_normal.html:58
-msgid "Update"
-msgstr "Обновить"
-
 #: templates/search/search.html:17
 msgid "Ok"
 msgstr "Ок"

boards/management/commands/cleanfiles.py

@@ -1,30 +1,46 b''
 import os
 
 from django.core.management import BaseCommand
 from django.db import transaction
+from boards.models import Attachment
+from boards.models.attachment import FILES_DIRECTORY
 
 from boards.models.image import IMAGES_DIRECTORY, PostImage, IMAGE_THUMB_SIZE
 from neboard.settings import MEDIA_ROOT
 
 
 __author__ = 'neko259'
 
 
 class Command(BaseCommand):
-    help = 'Remove image files whose models were deleted'
+    help = 'Remove files whose models were deleted'
 
     @transaction.atomic
     def handle(self, *args, **options):
         count = 0
         thumb_prefix = '.{}x{}'.format(*IMAGE_THUMB_SIZE)
 
         model_files = os.listdir(MEDIA_ROOT + IMAGES_DIRECTORY)
         for file in model_files:
             image_name = file if thumb_prefix not in file else file.replace(thumb_prefix, '')
-            found = PostImage.objects.filter(image=IMAGES_DIRECTORY + image_name).exists()
+            found = PostImage.objects.filter(
+                image=IMAGES_DIRECTORY + image_name).exists()
 
             if not found:
                 print('Missing {}'.format(image_name))
                 os.remove(MEDIA_ROOT + IMAGES_DIRECTORY + file)
                 count += 1
-        print('Deleted {} image files.'.format(count))
  No newline at end of file
+        print('Deleted {} image files.'.format(count))
+
+        count = 0
+        model_files = os.listdir(MEDIA_ROOT + FILES_DIRECTORY)
+        for file in model_files:
+            found = Attachment.objects.filter(file=FILES_DIRECTORY + file)\
+                .exists()
+
+            if not found:
+                print('Missing {}'.format(file))
+                os.remove(MEDIA_ROOT + FILES_DIRECTORY + file)
+                count += 1
+
+        print('Deleted {} attachment files.'.format(count))

boards/mdx_neboard.py

@@ -1,230 +1,230 b''
 # coding=utf-8
 
 import re
 import bbcode
 
 from urllib.parse import unquote
 
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.urlresolvers import reverse
 
 import boards
 
 
 __author__ = 'neko259'
 
 
 REFLINK_PATTERN = re.compile(r'^\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>'
 
 
 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]'
 
     def handleMatch(self, m):
         quote_element = etree.Element('span')
         quote_element.set('class', 'spoiler')
         quote_element.text = m.group(2)
 
         return quote_element
 
 
 class CommentPattern(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]'
 
 
 def render_reflink(tag_name, value, options, parent, context):
     result = '>>%s' % value
 
     if REFLINK_PATTERN.match(value):
         post_id = int(value)
 
         try:
             post = boards.models.Post.objects.get(id=post_id)
 
-            result = '<a href="%s">&gt;&gt;%s</a>' % (post.get_absolute_url(), post_id)
+            result = post.get_link_view()
         except ObjectDoesNotExist:
             pass
 
     return result
 
 
 def render_quote(tag_name, value, options, parent, context):
     source = ''
     if 'source' in options:
         source = options['source']
 
     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_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
 
 
 formatters = [
     QuotePattern,
     SpoilerPattern,
     ItalicPattern,
     BoldPattern,
     CommentPattern,
     StrikeThroughPattern,
     CodePattern,
 ]
 
 
 PREPARSE_PATTERNS = {
     r'(?<!>)>>(\d+)': r'[post]\1[/post]',  # Reflink ">>123"
     r'^>([^>].+)': r'[quote]\1[/quote]',  # Quote ">text"
     r'^//(.+)': r'[comment]\1[/comment]',  # Comment "//text"
     r'\B@(\w+)': r'[user]\1[/user]',  # User notification "@user"
 }
 
 
 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('user', render_notification, strip=True)
         self.parser.add_formatter('tag', render_tag, strip=True)
         self.parser.add_simple_formatter(
             'comment', '<span class="comment">//%(value)s</span>')
         self.parser.add_simple_formatter(
             'spoiler', '<span class="spoiler">%(value)s</span>')
         self.parser.add_simple_formatter(
             's', '<span class="strikethrough">%(value)s</span>')
         # TODO Why not use built-in tag?
         self.parser.add_simple_formatter('code',
                                          '<pre><code>%(value)s</pre></code>',
                                          render_embedded=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)

boards/models/__init__.py

@@ -1,10 +1,11 b''
 __author__ = 'neko259'
 
 from boards.models.signature import GlobalId, Signature
 from boards.models.sync_key import KeyPair
 from boards.models.image import PostImage
+from boards.models.attachment import Attachment
 from boards.models.thread import Thread
 from boards.models.post import Post
 from boards.models.tag import Tag
 from boards.models.user import Ban
 from boards.models.banner import Banner

boards/models/image.py

@@ -1,105 +1,114 b''
 import hashlib
 import os
 from random import random
 import time
+
 from django.db import models
-from boards import thumbs
+from django.template.defaultfilters import filesizeformat
+
+from boards import thumbs, utils
+import boards
 from boards.models.base import Viewable
 
 __author__ = 'neko259'
 
 
 IMAGE_THUMB_SIZE = (200, 150)
 IMAGES_DIRECTORY = 'images/'
 FILE_EXTENSION_DELIMITER = '.'
 HASH_LENGTH = 36
 
 CSS_CLASS_IMAGE = 'image'
 CSS_CLASS_THUMB = 'thumb'
 
 
 class PostImageManager(models.Manager):
     def create_with_hash(self, image):
-        image_hash = self.get_hash(image)
+        image_hash = utils.get_file_hash(image)
         existing = self.filter(hash=image_hash)
         if len(existing) > 0:
             post_image = existing[0]
         else:
             post_image = PostImage.objects.create(image=image)
 
         return post_image
 
-    def get_hash(self, image):
-        """
-        Gets hash of an image.
-        """
-        md5 = hashlib.md5()
-        for chunk in image.chunks():
-            md5.update(chunk)
-        return md5.hexdigest()
+    def get_random_images(self, count, include_archived=False, tags=None):
+        images = self.filter(post_images__thread__archived=include_archived)
+        if tags is not None:
+            images = images.filter(post_images__threads__tags__in=tags)
+        return images.order_by('?')[:count]
 
 
 class PostImage(models.Model, Viewable):
     objects = PostImageManager()
 
     class Meta:
         app_label = 'boards'
         ordering = ('id',)
 
     def _update_image_filename(self, filename):
         """
         Gets unique image filename
         """
 
-        path = IMAGES_DIRECTORY
-
         # TODO Use something other than random number in file name
         new_name = '{}{}.{}'.format(
             str(int(time.mktime(time.gmtime()))),
             str(int(random() * 1000)),
             filename.split(FILE_EXTENSION_DELIMITER)[-1:][0])
 
-        return os.path.join(path, new_name)
+        return os.path.join(IMAGES_DIRECTORY, new_name)
 
     width = models.IntegerField(default=0)
     height = models.IntegerField(default=0)
 
     pre_width = models.IntegerField(default=0)
     pre_height = models.IntegerField(default=0)
 
     image = thumbs.ImageWithThumbsField(upload_to=_update_image_filename,
                                         blank=True, sizes=(IMAGE_THUMB_SIZE,),
                                         width_field='width',
                                         height_field='height',
                                         preview_width_field='pre_width',
                                         preview_height_field='pre_height')
     hash = models.CharField(max_length=HASH_LENGTH)
 
     def save(self, *args, **kwargs):
         """
         Saves the model and computes the image hash for deduplication purposes.
         """
 
         if not self.pk and self.image:
-            self.hash = PostImage.objects.get_hash(self.image)
+            self.hash = utils.get_file_hash(self.image)
         super(PostImage, self).save(*args, **kwargs)
 
     def __str__(self):
         return self.image.url
 
     def get_view(self):
+        metadata = '{}, {}'.format(self.image.name.split('.')[-1],
+                                   filesizeformat(self.image.size))
         return '<div class="{}">' \
                '<a class="{}" href="{full}">' \
                '<img class="post-image-preview"' \
                ' src="{}"' \
                ' alt="{}"' \
                ' width="{}"' \
                ' height="{}"' \
                ' data-width="{}"' \
                ' data-height="{}" />' \
                '</a>' \
+               '<div class="image-metadata">'\
+               '<a href="{full}" download>{image_meta}</a>'\
+               '</div>' \
                '</div>'\
             .format(CSS_CLASS_IMAGE, CSS_CLASS_THUMB,
                     self.image.url_200x150,
                     str(self.hash), str(self.pre_width),
-                    str(self.pre_height), str(self.width), str(self.height), full=self.image.url)
+                    str(self.pre_height), str(self.width), str(self.height),
+                    full=self.image.url, image_meta=metadata)
+
+    def get_random_associated_post(self):
+        posts = boards.models.Post.objects.filter(images__in=[self])
+        return posts.order_by('?').first()

boards/models/post/__init__.py

@@ -1,401 +1,425 b''
+from datetime import datetime, timedelta, date
+from datetime import time as dtime
 import logging
 import re
 import uuid
 
 from django.core.exceptions import ObjectDoesNotExist
 from django.core.urlresolvers import reverse
 from django.db import models
 from django.db.models import TextField, QuerySet
-
 from django.template.loader import render_to_string
-
 from django.utils import timezone
 
+from boards.abstracts.tripcode import Tripcode
 from boards.mdx_neboard import Parser
 from boards.models import KeyPair, GlobalId
 from boards import settings
-from boards.models import PostImage
+from boards.models import PostImage, Attachment
 from boards.models.base import Viewable
 from boards.models.post.export import get_exporter, DIFF_TYPE_JSON
 from boards.models.post.manager import PostManager
 from boards.models.user import Notification
 
 WS_NOTIFICATION_TYPE_NEW_POST = 'new_post'
 WS_NOTIFICATION_TYPE = 'notification_type'
 
 WS_CHANNEL_THREAD = "thread:"
 
 APP_LABEL_BOARDS = 'boards'
 
 BAN_REASON_AUTO = 'Auto'
 
 IMAGE_THUMB_SIZE = (200, 150)
 
 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_MODERATOR = 'moderator'
 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',
     'moderator',
     'need_open_link',
     'truncated',
     'mode_tree',
 )
 
-REFMAP_STR = '<a href="{}">&gt;&gt;{}</a>'
-
 
 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, null=True, blank=True)
     pub_time = models.DateTimeField()
     text = TextField(blank=True, null=True)
     _text_rendered = TextField(blank=True, null=True, editable=False)
 
     images = models.ManyToManyField(PostImage, null=True, blank=True,
-                                    related_name='ip+', db_index=True)
+                                    related_name='post_images', db_index=True)
+    attachments = models.ManyToManyField(Attachment, null=True, blank=True,
+            related_name='attachment_posts')
 
     poster_ip = models.GenericIPAddressField()
 
     # TODO This field can be removed cause UID is used for update now
     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)
     threads = models.ManyToManyField('Thread', db_index=True)
     thread = models.ForeignKey('Thread', db_index=True, related_name='pt+')
 
     url = models.TextField()
     uid = models.TextField(db_index=True)
 
     # 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)
 
+    tripcode = models.CharField(max_length=50, null=True)
+
     def __str__(self):
         return 'P#{}/{}'.format(self.id, self.title)
 
     def get_referenced_posts(self):
         threads = self.get_threads().all()
         return self.referenced_posts.filter(threads__in=threads) \
             .order_by('pub_time').distinct().all()
 
     def get_title(self) -> str:
         """
         Gets original post title or part of its text.
         """
 
         title = self.title
         if not title:
             title = self.get_text()
 
         return title
 
     def build_refmap(self) -> 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.
         """
 
-        post_urls = [REFMAP_STR.format(refpost.get_absolute_url(), refpost.id)
+        post_urls = [refpost.get_link_view()
                      for refpost in self.referenced_posts.all()]
 
         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.get_thread().get_opening_post_id() == self.id
 
     def get_absolute_url(self):
         if self.url:
             return self.url
         else:
             opening_id = self.get_thread().get_opening_post_id()
             post_url = reverse('thread', kwargs={'post_id': opening_id})
             if self.id != opening_id:
                 post_url += '#' + str(self.id)
             return post_url
 
     def get_thread(self):
         return self.thread
 
     def get_threads(self) -> QuerySet:
         """
         Gets post's thread.
         """
 
         return self.threads
 
     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.
         """
 
         thread = self.get_thread()
         is_opening = kwargs.get(PARAMETER_IS_OPENING, self.is_opening())
 
         if is_opening:
             opening_post_id = self.id
         else:
             opening_post_id = thread.get_opening_post_id()
 
         css_class = 'post'
         if thread.archived:
             css_class += ' archive_post'
         elif not thread.can_bump():
             css_class += ' dead_post'
 
         params = dict()
         for param in POST_VIEW_PARAMS:
             if param in kwargs:
                 params[param] = kwargs[param]
 
         params.update({
             PARAMETER_POST: self,
             PARAMETER_IS_OPENING: is_opening,
             PARAMETER_THREAD: thread,
             PARAMETER_CSS_CLASS: css_class,
             PARAMETER_OP_ID: opening_post_id,
         })
 
         return render_to_string('boards/post.html', params)
 
     def get_search_view(self, *args, **kwargs):
         return self.get_view(need_op_data=True, *args, **kwargs)
 
     def get_first_image(self) -> PostImage:
         return self.images.earliest('id')
 
     def delete(self, using=None):
         """
         Deletes all post images and the post itself.
         """
 
         for image in self.images.all():
-            image_refs_count = Post.objects.filter(images__in=[image]).count()
+            image_refs_count = image.post_images.count()
             if image_refs_count == 1:
                 image.delete()
 
+        for attachment in self.attachments.all():
+            attachment_refs_count = attachment.attachment_posts.count()
+            if attachment_refs_count == 1:
+                attachment.delete()
+
         if self.global_id:
             self.global_id.delete()
 
         thread = self.get_thread()
         thread.last_edit_time = timezone.now()
         thread.save()
 
         super(Post, self).delete(using)
 
         logging.getLogger('boards.post.delete').info(
             'Deleted post {}'.format(self))
 
     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 notify_clients(self, recursive=True):
         """
         Sends post HTML data to the thread web socket.
         """
 
         if not settings.get_bool('External', 'WebsocketsEnabled'):
             return
 
         thread_ids = list()
         for thread in self.get_threads().all():
             thread_ids.append(thread.id)
 
             thread.notify_clients()
 
         if recursive:
             for reply_number in re.finditer(REGEX_REPLY, self.get_raw_text()):
                 post_id = reply_number.group(1)
 
                 try:
                     ref_post = Post.objects.get(id=post_id)
 
                     if ref_post.get_threads().exclude(id__in=thread_ids).exists():
                         # If post is in this thread, its thread was already notified.
                         # Otherwise, notify its thread separately.
                         ref_post.notify_clients(recursive=False)
                 except ObjectDoesNotExist:
                     pass
 
     def build_url(self):
         self.url = self.get_absolute_url()
         self.save(update_fields=['url'])
 
     def save(self, force_insert=False, force_update=False, using=None,
              update_fields=None):
         self._text_rendered = Parser().parse(self.get_raw_text())
 
         self.uid = str(uuid.uuid4())
         if update_fields is not None and 'uid' not in update_fields:
             update_fields += ['uid']
 
         if self.id:
             for thread in self.get_threads().all():
                 thread.last_edit_time = self.last_edit_time
 
                 thread.save(update_fields=['last_edit_time'])
 
         super().save(force_insert, force_update, using, update_fields)
 
     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()):
             absolute_post_id = str(Post.objects.get(id=post_id).global_id)
             replacements[post_id] = absolute_post_id
 
         text = self.get_raw_text()
         for key in replacements:
             text = text.replace('[post]{}[/post]'.format(key),
                                 '[post]{}[/post]'.format(replacements[key]))
 
         return text
 
     def get_absolute_id(self) -> str:
         """
         If the post has many threads, shows its main thread OP id in the post
         ID.
         """
 
         if self.get_threads().count() > 1:
             return '{}/{}'.format(self.get_thread().get_opening_post_id(), self.id)
         else:
             return str(self.id)
 
     def connect_notifications(self):
         for reply_number in re.finditer(REGEX_NOTIFICATION, self.get_raw_text()):
             user_name = reply_number.group(1).lower()
             Notification.objects.get_or_create(name=user_name, post=self)
 
     def connect_replies(self):
         """
         Connects replies to a post to show them as a reflink map
         """
 
         for reply_number in re.finditer(REGEX_REPLY, self.get_raw_text()):
             post_id = reply_number.group(1)
 
             try:
                 referenced_post = Post.objects.get(id=post_id)
 
                 referenced_post.referenced_posts.add(self)
                 referenced_post.last_edit_time = self.pub_time
                 referenced_post.build_refmap()
                 referenced_post.save(update_fields=['refmap', 'last_edit_time'])
             except ObjectDoesNotExist:
                 pass
 
     def connect_threads(self, opening_posts):
         for opening_post in opening_posts:
             threads = opening_post.get_threads().all()
             for thread in threads:
                 if thread.can_bump():
                     thread.update_bump_status()
 
                 thread.last_edit_time = self.last_edit_time
                 thread.save(update_fields=['last_edit_time', 'bumpable'])
             self.threads.add(opening_post.get_thread())
+
+    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

boards/models/post/manager.py

@@ -1,128 +1,140 b''
 from datetime import datetime, timedelta, date
 from datetime import time as dtime
 import logging
 from django.db import models, transaction
 from django.utils import timezone
 from boards import utils
 from boards.mdx_neboard import Parser
-from boards.models import PostImage
+from boards.models import PostImage, Attachment
 import boards.models
 
 __author__ = 'vurdalak'
 
 
 NO_IP = '0.0.0.0'
 POSTS_PER_DAY_RANGE = 7
 
+IMAGE_TYPES = (
+    'jpeg',
+    'jpg',
+    'png',
+    'bmp',
+    'gif',
+)
+
 
 class PostManager(models.Manager):
     @transaction.atomic
-    def create_post(self, title: str, text: str, image=None, thread=None,
-                    ip=NO_IP, tags: list=None, opening_posts: list=None):
+    def create_post(self, title: str, text: str, file=None, thread=None,
+                    ip=NO_IP, tags: list=None, opening_posts: list=None, tripcode=None):
         """
         Creates new post
         """
 
         is_banned = boards.models.Ban.objects.filter(ip=ip).exists()
 
         # TODO Raise specific exception and catch it in the views
         if is_banned:
             raise Exception("This user is banned")
 
         if not tags:
             tags = []
         if not opening_posts:
             opening_posts = []
 
         posting_time = timezone.now()
         new_thread = False
         if not thread:
             thread = boards.models.thread.Thread.objects.create(
                 bump_time=posting_time, last_edit_time=posting_time)
             list(map(thread.tags.add, tags))
             boards.models.thread.Thread.objects.process_oldest_threads()
             new_thread = True
 
         pre_text = Parser().preparse(text)
 
         post = self.create(title=title,
                            text=pre_text,
                            pub_time=posting_time,
                            poster_ip=ip,
                            thread=thread,
-                           last_edit_time=posting_time)
+                           last_edit_time=posting_time,
+                           tripcode=tripcode)
         post.threads.add(thread)
 
-        post.set_global_id()
-
         logger = logging.getLogger('boards.post.create')
 
         logger.info('Created post {} by {}'.format(post, post.poster_ip))
 
-        if image:
-            post.images.add(PostImage.objects.create_with_hash(image))
-
-        if not new_thread:
-            thread.last_edit_time = posting_time
-            thread.bump()
-            thread.save()
+        # TODO Move this to other place
+        if file:
+            file_type = file.name.split('.')[-1].lower()
+            if file_type in IMAGE_TYPES:
+                post.images.add(PostImage.objects.create_with_hash(file))
+            else:
+                post.attachments.add(Attachment.objects.create_with_hash(file))
 
         post.build_url()
         post.connect_replies()
         post.connect_threads(opening_posts)
         post.connect_notifications()
-
-        return post
+        post.set_global_id()
 
-    @transaction.atomic
-    def import_post(self, title: str, text: str, pub_time: str, global_id,
-                    opening_post=None, tags=list()):
-        if opening_post is None:
-            thread = boards.models.thread.Thread.objects.create(
-                bump_time=pub_time, last_edit_time=pub_time)
-            list(map(thread.tags.add, tags))
-        else:
-            thread = opening_post.get_thread()
-
-        post = self.create(title=title, text=text,
-                           pub_time=pub_time,
-                           poster_ip=NO_IP,
-                           last_edit_time=pub_time,
-                           thread_id=thread.id, global_id=global_id)
-
-        post.build_url()
-        post.connect_replies()
-        post.connect_notifications()
+        # Thread needs to be bumped only when the post is already created
+        if not new_thread:
+            thread.last_edit_time = posting_time
+            thread.bump()
+            thread.save()
 
         return post
 
     def delete_posts_by_ip(self, ip):
         """
         Deletes all posts of the author with same IP
         """
 
         posts = self.filter(poster_ip=ip)
         for post in posts:
             post.delete()
 
     @utils.cached_result()
     def get_posts_per_day(self) -> float:
         """
         Gets average count of posts per day for the last 7 days
         """
 
         day_end = date.today()
         day_start = day_end - timedelta(POSTS_PER_DAY_RANGE)
 
         day_time_start = timezone.make_aware(datetime.combine(
             day_start, dtime()), timezone.get_current_timezone())
         day_time_end = timezone.make_aware(datetime.combine(
             day_end, dtime()), timezone.get_current_timezone())
 
         posts_per_period = float(self.filter(
             pub_time__lte=day_time_end,
             pub_time__gte=day_time_start).count())
 
         ppd = posts_per_period / POSTS_PER_DAY_RANGE
 
         return ppd
+
+    @transaction.atomic
+    def import_post(self, title: str, text: str, pub_time: str, global_id,
+                    opening_post=None, tags=list()):
+        if opening_post is None:
+            thread = boards.models.thread.Thread.objects.create(
+                bump_time=pub_time, last_edit_time=pub_time)
+            list(map(thread.tags.add, tags))
+        else:
+            thread = opening_post.get_thread()
+
+        post = self.create(title=title, text=text,
+                           pub_time=pub_time,
+                           poster_ip=NO_IP,
+                           last_edit_time=pub_time,
+                           thread_id=thread.id, global_id=global_id)
+
+        post.build_url()
+        post.connect_replies()
+        post.connect_notifications()

boards/models/tag.py

@@ -1,82 +1,109 b''
 from django.template.loader import render_to_string
 from django.db import models
 from django.db.models import Count
 from django.core.urlresolvers import reverse
 
 from boards.models.base import Viewable
 from boards.utils import cached_result
+import boards
+
+__author__ = 'neko259'
 
 
-__author__ = 'neko259'
+RELATED_TAGS_COUNT = 5
 
 
 class TagManager(models.Manager):
 
     def get_not_empty_tags(self):
         """
         Gets tags that have non-archived threads.
         """
 
-        return self.annotate(num_threads=Count('thread')).filter(num_threads__gt=0)\
+        return self.annotate(num_threads=Count('thread_tags')).filter(num_threads__gt=0)\
             .order_by('-required', '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])
 
 
 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'
         ordering = ('name',)
 
     name = models.CharField(max_length=100, db_index=True, unique=True)
     required = models.BooleanField(default=False, db_index=True)
+    description = models.TextField(blank=True)
 
     def __str__(self):
         return self.name
 
     def is_empty(self) -> bool:
         """
         Checks if the tag has some threads.
         """
 
         return self.get_thread_count() == 0
 
-    def get_thread_count(self) -> int:
-        return self.get_threads().count()
+    def get_thread_count(self, archived=None) -> int:
+        threads = self.get_threads()
+        if archived is not None:
+            threads = threads.filter(archived=archived)
+        return threads.count()
+
+    def get_active_thread_count(self) -> int:
+        return self.get_thread_count(archived=False)
 
     def get_absolute_url(self):
         return reverse('tag', kwargs={'tag_name': self.name})
 
     def get_threads(self):
-        return self.thread_set.order_by('-bump_time')
+        return self.thread_tags.order_by('-bump_time')
 
     def is_required(self):
         return self.required
 
     def get_view(self):
         link = '<a class="tag" href="{}">{}</a>'.format(
             self.get_absolute_url(), self.name)
         if self.is_required():
             link = '<b>{}</b>'.format(link)
         return link
 
     def get_search_view(self, *args, **kwargs):
         return render_to_string('boards/tag.html', {
             'tag': self,
         })
 
     @cached_result()
     def get_post_count(self):
         return self.get_threads().aggregate(num_posts=Count('post'))['num_posts']
+
+    def get_description(self):
+        return self.description
+
+    def get_random_image_post(self, archived=False):
+        posts = boards.models.Post.objects.annotate(images_count=Count(
+            'images')).filter(images_count__gt=0, threads__tags__in=[self])
+        if archived is not None:
+            posts = posts.filter(thread__archived=archived)
+        return posts.order_by('?').first()
+
+    def get_first_letter(self):
+        return self.name and self.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])

boards/models/thread.py

@@ -1,227 +1,230 b''
 import logging
 from adjacent import Client
 
 from django.db.models import Count, Sum, QuerySet
 from django.utils import timezone
 from django.db import models
 
 from boards import settings
 import boards
 from boards.utils import cached_result, datetime_to_epoch
 from boards.models.post import Post
 from boards.models.tag import Tag
 
 
 __author__ = 'neko259'
 
 
 logger = logging.getLogger(__name__)
 
 
 WS_NOTIFICATION_TYPE_NEW_POST = 'new_post'
 WS_NOTIFICATION_TYPE = 'notification_type'
 
 WS_CHANNEL_THREAD = "thread:"
 
 
 class ThreadManager(models.Manager):
     def process_oldest_threads(self):
         """
          Preserves maximum thread count. If there are too many threads,
          archive or delete the old ones.
          """
 
         threads = Thread.objects.filter(archived=False).order_by('-bump_time')
         thread_count = threads.count()
 
         max_thread_count = settings.get_int('Messages', 'MaxThreadCount')
         if thread_count > max_thread_count:
             num_threads_to_delete = thread_count - max_thread_count
             old_threads = threads[thread_count - num_threads_to_delete:]
 
             for thread in old_threads:
                 if settings.get_bool('Storage', 'ArchiveThreads'):
                     self._archive_thread(thread)
                 else:
                     thread.delete()
 
             logger.info('Processed %d old threads' % num_threads_to_delete)
 
     def _archive_thread(self, thread):
         thread.archived = True
         thread.bumpable = False
         thread.last_edit_time = timezone.now()
         thread.update_posts_time()
         thread.save(update_fields=['archived', 'last_edit_time', 'bumpable'])
 
 
 def get_thread_max_posts():
     return settings.get_int('Messages', 'MaxPostsPerThread')
 
 
 class Thread(models.Model):
     objects = ThreadManager()
 
     class Meta:
         app_label = 'boards'
 
-    tags = models.ManyToManyField('Tag')
+    tags = models.ManyToManyField('Tag', related_name='thread_tags')
     bump_time = models.DateTimeField(db_index=True)
     last_edit_time = models.DateTimeField()
     archived = models.BooleanField(default=False)
     bumpable = models.BooleanField(default=True)
     max_posts = models.IntegerField(default=get_thread_max_posts)
 
     def get_tags(self) -> QuerySet:
         """
         Gets a sorted tag list.
         """
 
         return self.tags.order_by('name')
 
     def bump(self):
         """
         Bumps (moves to up) thread if possible.
         """
 
         if self.can_bump():
             self.bump_time = self.last_edit_time
 
             self.update_bump_status()
 
             logger.info('Bumped thread %d' % self.id)
 
     def has_post_limit(self) -> bool:
         return self.max_posts > 0
 
     def update_bump_status(self, exclude_posts=None):
         if self.has_post_limit() and self.get_reply_count() >= self.max_posts:
             self.bumpable = False
             self.update_posts_time(exclude_posts=exclude_posts)
 
     def _get_cache_key(self):
         return [datetime_to_epoch(self.last_edit_time)]
 
     @cached_result(key_method=_get_cache_key)
     def get_reply_count(self) -> int:
         return self.get_replies().count()
 
     @cached_result(key_method=_get_cache_key)
     def get_images_count(self) -> int:
         return self.get_replies().annotate(images_count=Count(
             'images')).aggregate(Sum('images_count'))['images_count__sum']
 
     def can_bump(self) -> bool:
         """
         Checks if the thread can be bumped by replying to it.
         """
 
         return self.bumpable and not self.archived
 
     def get_last_replies(self) -> QuerySet:
         """
         Gets several last replies, not including opening post
         """
 
         last_replies_count = settings.get_int('View', 'LastRepliesCount')
 
         if last_replies_count > 0:
             reply_count = self.get_reply_count()
 
             if reply_count > 0:
                 reply_count_to_show = min(last_replies_count,
                                           reply_count - 1)
                 replies = self.get_replies()
                 last_replies = replies[reply_count - reply_count_to_show:]
 
                 return last_replies
 
     def get_skipped_replies_count(self) -> int:
         """
         Gets number of posts between opening post and last replies.
         """
         reply_count = self.get_reply_count()
         last_replies_count = min(settings.get_int('View', 'LastRepliesCount'),
                                  reply_count - 1)
         return reply_count - last_replies_count - 1
 
     def get_replies(self, view_fields_only=False) -> QuerySet:
         """
         Gets sorted thread posts
         """
 
         query = Post.objects.filter(threads__in=[self])
         query = query.order_by('pub_time').prefetch_related('images', 'thread', 'threads')
         if view_fields_only:
             query = query.defer('poster_ip')
         return query.all()
 
     def get_top_level_replies(self) -> QuerySet:
         return self.get_replies().exclude(refposts__threads__in=[self])
 
     def get_replies_with_images(self, view_fields_only=False) -> QuerySet:
         """
         Gets replies that have at least one image attached
         """
 
         return self.get_replies(view_fields_only).annotate(images_count=Count(
             'images')).filter(images_count__gt=0)
 
     def get_opening_post(self, only_id=False) -> Post:
         """
         Gets the first post of the thread
         """
 
         query = self.get_replies().order_by('pub_time')
         if only_id:
             query = query.only('id')
         opening_post = query.first()
 
         return opening_post
 
     @cached_result()
     def get_opening_post_id(self) -> int:
         """
         Gets ID of the first thread post.
         """
 
         return self.get_opening_post(only_id=True).id
 
     def get_pub_time(self):
         """
         Gets opening post's pub time because thread does not have its own one.
         """
 
         return self.get_opening_post().pub_time
 
     def __str__(self):
         return 'T#{}/{}'.format(self.id, self.get_opening_post_id())
 
     def get_tag_url_list(self) -> list:
         return boards.models.Tag.objects.get_tag_url_list(self.get_tags())
 
     def update_posts_time(self, exclude_posts=None):
         last_edit_time = self.last_edit_time
 
         for post in self.post_set.all():
             if exclude_posts is None or post not in exclude_posts:
                 # Manual update is required because uids are generated on save
                 post.last_edit_time = last_edit_time
                 post.save(update_fields=['last_edit_time'])
 
                 post.get_threads().update(last_edit_time=last_edit_time)
 
     def notify_clients(self):
         if not settings.get_bool('External', 'WebsocketsEnabled'):
             return
 
         client = Client()
 
         channel_name = WS_CHANNEL_THREAD + str(self.get_opening_post_id())
         client.publish(channel_name, {
             WS_NOTIFICATION_TYPE: WS_NOTIFICATION_TYPE_NEW_POST,
             })
         client.send()
 
     def get_absolute_url(self):
         return self.get_opening_post().get_absolute_url()
+
+    def get_required_tags(self):
+        return self.get_tags().filter(required=True)

boards/static/css/base.css

@@ -1,105 +1,136 b''
 .ui-button {
    display: none;
 }
 
 .ui-dialog-content {
     padding: 0;
     min-height: 0;
 }
 
 .mark_btn {
     cursor: pointer;
 }
 
 .img-full {
     position: fixed;
     background-color: #CCC;
     border: 1px solid #000;
     cursor: pointer;
 }
 
 .strikethrough {
     text-decoration: line-through;
 }
 
 .post_preview {
     z-index: 300;
     position:absolute;
 }
 
 .gallery_image {
     display: inline-block;
 }
 
 @media print {
     .post-form-w {
         display: none;
     }
 }
 
 input[name="image"] {
      display: block;
      width: 100px;
      height: 100px;
      cursor: pointer;
      position: absolute;
      opacity: 0;
      z-index: 1;
 }
 
 .file_wrap {
      width: 100px;
      height: 100px;
      border: solid 1px white;
      display: inline-block;
 }
 
 form > .file_wrap {
     float: left;
 }
 
 .file-thumb {
     width: 100px;
     height: 100px;
     background-size: cover;
     background-position: center;
 }
 
 .compact-form-text {
     margin-left:110px;
 }
 
 textarea, input {
     -moz-box-sizing: border-box;
     -webkit-box-sizing: border-box;
     box-sizing: border-box;
 }
 
 .compact-form-text > textarea {
     height: 100px;
     width: 100%;
 }
 
 .post-button-form {
     display: inline;
 }
 
 .post-button-form > button, #autoupdate {
     border: none;
     margin: inherit;
     padding: inherit;
     background: none;
     font-size: inherit;
 }
 
 #form-close-button {
     display: none;
 }
 
 .post-image-full {
     width: 100%;
+    height: auto;
 }
 
 #preview-text {
     display: none;
 }
+
+.random-images-table {
+    text-align: center;
+    width: 100%;
+}
+
+.random-images-table > div {
+    margin-left: auto;
+    margin-right: auto;
+}
+
+.tag-image, .tag-text-data {
+    display: inline-block;
+}
+
+.tag-text-data > h2 {
+    margin: 0;
+}
+
+.tag-image {
+    margin-right: 5px;
+}
+
+.reply-to-message {
+    display: none;
+}
+
+.tripcode {
+    padding: 2px;
+}
  No newline at end of file

boards/static/css/md/base_page.css

@@ -1,555 +1,559 b''
 * {
    text-decoration: none;
    font-weight: inherit;
 }
 
 b, strong {
    font-weight: bold;
 }
 
 html {
     background: #555;
     color: #ffffff;
 }
 
 body {
     margin: 0;
 }
 
 #admin_panel {
     background: #FF0000;
     color: #00FF00
 }
 
 .input_field_error {
     color: #FF0000;
 }
 
 .title {
     font-weight: bold;
     color: #ffcc00;
 }
 
 .link, a {
     color: #afdcec;
 }
 
 .block {
     display: inline-block;
     vertical-align: top;
 }
 
 .tag {
     color: #FFD37D;
 }
 
 .post_id {
     color: #fff380;
 }
 
 .post, .dead_post, .archive_post, #posts-table {
     background: #333;
     padding: 10px;
     clear: left;
     word-wrap: break-word;
     border-top: 1px solid #777;
     border-bottom: 1px solid #777;
 }
 
 .post + .post {
     border-top: none;
 }
 
 .dead_post + .dead_post {
     border-top: none;
 }
 
 .archive_post + .archive_post {
     border-top: none;
 }
 
 .metadata {
     padding-top: 5px;
     margin-top: 10px;
     border-top: solid 1px #666;
     color: #ddd;
 }
 
 .navigation_panel, .tag_info {
     background: #222;
     margin-bottom: 5px;
     margin-top: 5px;
     padding: 10px;
     border-bottom: solid 1px #888;
     border-top: solid 1px #888;
     color: #eee;
 }
 
 .navigation_panel .link:first-child {
     border-right: 1px solid #fff;
     font-weight: bold;
     margin-right: 1ex;
     padding-right: 1ex;
 }
 
 .navigation_panel .right-link {
     border-left: 1px solid #fff;
     border-right: none;
     float: right;
     margin-left: 1ex;
     margin-right: 0;
     padding-left: 1ex;
     padding-right: 0;
 }
 
 .navigation_panel .link {
     font-weight: bold;
 }
 
 .navigation_panel::after, .post::after {
     clear: both;
     content: ".";
     display: block;
     height: 0;
     line-height: 0;
     visibility: hidden;
 }
 
 .header {
     border-bottom: solid 2px #ccc;
     margin-bottom: 5px;
     border-top: none;
     margin-top: 0;
 }
 
 .footer {
     border-top: solid 2px #ccc;
     margin-top: 5px;
     border-bottom: none;
     margin-bottom: 0;
 }
 
 p, .br {
     margin-top: .5em;
     margin-bottom: .5em;
 }
 
 .post-form-w {
     background: #333344;
     border-top: solid 1px #888;
     border-bottom: solid 1px #888;
     color: #fff;
     padding: 10px;
     margin-bottom: 5px;
     margin-top: 5px;
 }
 
 .form-row {
     width: 100%;
     display: table-row;
 }
 
 .form-label {
     padding: .25em 1ex .25em 0;
     vertical-align: top;
     display: table-cell;
 }
 
 .form-input {
     padding: .25em 0;
     width: 100%;
     display: table-cell;
 }
 
 .form-errors {
     font-weight: bolder;
     vertical-align: middle;
     display: table-cell;
 }
 
-.post-form input:not([name="image"]), .post-form textarea, .post-form select {
+.post-form input:not([name="image"]):not([type="checkbox"]):not([type="submit"]), .post-form textarea, .post-form select {
     background: #333;
     color: #fff;
     border: solid 1px;
     padding: 0;
     font: medium sans-serif;
     width: 100%;
 }
 
 .post-form textarea {
     resize: vertical;
 }
 
 .form-submit {
     display: table;
     margin-bottom: 1ex;
     margin-top: 1ex;
 }
 
 .form-title {
     font-weight: bold;
     font-size: 2ex;
     margin-bottom: 0.5ex;
 }
 
-.post-form input[type="submit"], input[type="submit"] {
+input[type="submit"], button {
     background: #222;
     border: solid 2px #fff;
     color: #fff;
     padding: 0.5ex;
+    margin-right: 0.5ex;
 }
 
 input[type="submit"]:hover {
     background: #060;
 }
 
+.form-submit > button:hover {
+    background: #006;
+}
+
 blockquote {
     border-left: solid 2px;
     padding-left: 5px;
     color: #B1FB17;
     margin: 0;
 }
 
 .post > .image {
     float: left;
     margin: 0 1ex .5ex 0;
     min-width: 1px;
     text-align: center;
     display: table-row;
 }
 
 .post > .metadata {
     clear: left;
 }
 
 .get {
     font-weight: bold;
     color: #d55;
 }
 
 * {
     text-decoration: none;
 }
 
-.dead_post {
-    border-left: solid 5px #982C2C;
+.dead_post > .post-info {
+    font-style: italic;
 }
 
-.archive_post {
-    border-left: solid 5px #B7B7B7;
+.archive_post > .post-info {
+    text-decoration: line-through;
 }
 
 .mark_btn {
     border: 1px solid;
     padding: 2px 2ex;
     display: inline-block;
     margin: 0 5px 4px 0;
 }
 
 .mark_btn:hover {
     background: #555;
 }
 
 .quote {
     color: #92cf38;
     font-style: italic;
 }
 
 .multiquote {
     padding: 3px;
     display: inline-block;
     background: #222;
     border-style: solid;
     border-width: 1px 1px 1px 4px;
     font-size: 0.9em;
 }
 
 .spoiler {
     background: black;
     color: black;
     padding: 0 1ex 0 1ex;
 }
 
 .spoiler:hover {
     color: #ddd;
 }
 
 .comment {
     color: #eb2;
 }
 
 a:hover {
     text-decoration: underline;
 }
 
 .last-replies {
     margin-left: 3ex;
     margin-right: 3ex;
     border-left: solid 1px #777;
     border-right: solid 1px #777;
 }
 
 .last-replies > .post:first-child {
     border-top: none;
 }
 
 .thread {
     margin-bottom: 3ex;
     margin-top: 1ex;
 }
 
 .post:target {
     border: solid 2px white;
 }
 
 pre{
     white-space:pre-wrap
 }
 
 li {
     list-style-position: inside;
 }
 
 .fancybox-skin {
     position: relative;
     background-color: #fff;
     color: #ddd;
     text-shadow: none;
 }
 
 .fancybox-image {
     border: 1px solid black;
 }
 
 .image-mode-tab {
     background: #444;
     color: #eee;
     margin-top: 5px;
     padding: 5px;
     border-top: 1px solid #888;
     border-bottom: 1px solid #888;
 }
 
 .image-mode-tab > label {
     margin: 0 1ex;
 }
 
 .image-mode-tab > label > input {
     margin-right: .5ex;
 }
 
 #posts-table {
     margin-top: 5px;
     margin-bottom: 5px;
 }
 
 .tag_info > h2 {
     margin: 0;
 }
 
 .post-info {
     color: #ddd;
     margin-bottom: 1ex;
 }
 
 .moderator_info {
     color: #e99d41;
-    float: right;
-    font-weight: bold;
     opacity: 0.4;
 }
 
 .moderator_info:hover {
     opacity: 1;
 }
 
 .refmap {
     font-size: 0.9em;
     color: #ccc;
     margin-top: 1em;
 }
 
 .fav {
     color: yellow;
 }
 
 .not_fav {
     color: #ccc;
 }
 
 .role {
     text-decoration: underline;
 }
 
 .form-email {
     display: none;
 }
 
 .bar-value {
     background: rgba(50, 55, 164, 0.45);
     font-size: 0.9em;
     height: 1.5em;
 }
 
 .bar-bg {
     position: relative;
     border-top: solid 1px #888;
     border-bottom: solid 1px #888;
     margin-top: 5px;
     overflow: hidden;
 }
 
 .bar-text {
     padding: 2px;
     position: absolute;
     left: 0;
     top: 0;
 }
 
 .page_link {
     background: #444;
     border-top: solid 1px #888;
     border-bottom: solid 1px #888;
     padding: 5px;
     color: #eee;
     font-size: 2ex;
 }
 
 .skipped_replies {
     padding: 5px;
     margin-left: 3ex;
     margin-right: 3ex;
     border-left: solid 1px #888;
     border-right: solid 1px #888;
     border-bottom: solid 1px #888;
     background: #000;
 }
 
 .current_page {
     padding: 2px;
     background-color: #afdcec;
     color: #000;
 }
 
 .current_mode {
     font-weight: bold;
 }
 
 .gallery_image {
     border: solid 1px;
-    padding: 0.5ex;
     margin: 0.5ex;
     text-align: center;
 }
 
 code {
     border: dashed 1px #ccc;
     background: #111;
     padding: 2px;
     font-size: 1.2em;
     display: inline-block;
 }
 
 pre {
     overflow: auto;
 }
 
 .img-full {
     background: #222;
     border: solid 1px white;
 }
 
 .tag_item {
     display: inline-block;
 }
 
 #id_models li {
     list-style: none;
 }
 
 #id_q {
     margin-left: 1ex;
 }
 
 ul {
     padding-left: 0px;
 }
 
 .quote-header {
     border-bottom: 2px solid #ddd;
     margin-bottom: 1ex;
     padding-bottom: .5ex;
     color: #ddd;
     font-size: 1.2em;
 }
 
 .global-id {
     font-weight: bolder;
     opacity: .5;
 }
 
 /* Post */
 .post > .message, .post > .image {
         padding-left: 1em;
 }
 
 /* Reflink preview */
 .post_preview {
     border-left: 1px solid #777;
     border-right: 1px solid #777;
     max-width: 600px;
 }
 
 /* Code highlighter */
 .hljs {
     color: #fff;
     background: #000;
     display: inline-block;
 }
 
 .hljs, .hljs-subst, .hljs-tag .hljs-title, .lisp .hljs-title, .clojure .hljs-built_in, .nginx .hljs-title {
     color: #fff;
 }
 
 #up {
     position: fixed;
     bottom: 5px;
     right: 5px;
     border: 1px solid #777;
     background: #000;
     padding: 4px;
 }
 
 .user-cast {
     border: solid #ffffff 1px;
     padding: .2ex;
     background: #152154;
     color: #fff;
 }
 
 .highlight {
-    background-color: #222;
+    background: #222;
 }
 
 .post-button-form > button:hover {
     text-decoration: underline;
 }
 
 .tree_reply > .post {
-    margin-left: 1ex;
     margin-top: 1ex;
     border-left: solid 1px #777;
-    border-right: solid 1px #777;
+    padding-right: 0;
 }
 
 #preview-text {
     border: solid 1px white;
     margin: 1ex 0 1ex 0;
     padding: 1ex;
 }
 
-button {
-    border: 1px solid white;
-    margin-bottom: .5ex;
-    margin-top: .5ex;
+.image-metadata {
+    font-style: italic;
+    font-size: 0.9em;
 }
+
+.tripcode {
+    color: white;
+}

boards/static/css/pg/base_page.css

@@ -1,378 +1,383 b''
 html {
     background: rgb(238, 238, 238);
     color: rgb(51, 51, 51);
 }
 
 #admin_panel {
     background: #FF0000;
     color: #00FF00
 }
 
 .input_field {
 
 }
 
 .input_field_name {
 
 }
 
 .input_field_error {
     color: #FF0000;
 }
 
 
 .title {
     font-weight: bold;
     color: #333;
     font-size: 2ex;
 }
 
 .link, a {
     color: #ff7000;
 }
 
 .block {
     display: inline-block;
     vertical-align: top;
 }
 
 .tag {
     color: #222;
 }
 
 .post_id:hover {
     color: #11f;
 }
 
 .post_id {
     color: #444;
 }
 
 .post, .dead_post, #posts-table {
     margin: 5px;
     padding: 10px;
     background: rgb(221, 221, 221);
     border: 1px solid rgb(204, 204, 204);
     border-radius: 5px 5px 5px 5px;
     clear: left;
     word-wrap: break-word;
     display: table;
 }
 
 .metadata {
     padding: 5px;
     margin-top: 10px;
     border: solid 1px #666;
     font-size: 0.9em;
     display: table;
 }
 
 .navigation_panel, .tag_info, .page_link {
     margin: 5px;
     padding: 10px;
     border: 1px solid rgb(204, 204, 204);
     border-radius: 5px 5px 5px 5px;
 }
 
 .navigation_panel .link {
     border-right: 1px solid #000;
     font-weight: bold;
     margin-right: 1ex;
     padding-right: 1ex;
 }
 .navigation_panel .link:last-child {
     border-left: 1px solid #000;
     border-right: none;
     float: right;
     margin-left: 1ex;
     margin-right: 0;
     padding-left: 1ex;
     padding-right: 0;
 }
 
 .navigation_panel::after, .post::after {
     clear: both;
     content: ".";
     display: block;
     height: 0;
     line-height: 0;
     visibility: hidden;
 }
 
 p {
     margin-top: .5em;
     margin-bottom: .5em;
 }
 
 .post-form-w {
     display: table;
     padding: 10px;
     margin: 5px
 }
 
 .form-row {
     display: table-row;
 }
 
 .form-label, .form-input, .form-errors {
     display: table-cell;
 }
 
 .form-label {
     padding: .25em 1ex .25em 0;
     vertical-align: top;
 }
 
 .form-input {
     padding: .25em 0;
 }
 
 .form-errors {
     padding-left: 1ex;
     font-weight: bold;
     vertical-align: middle;
 }
 
 .post-form input:not([name="image"]), .post-form textarea {
     background: #fff;
     color: #000;
     border: solid 1px;
     padding: 0;
     width: 100%;
     font: medium sans;
 }
 
 .form-submit {
     border-bottom: 2px solid #ddd;
     margin-bottom: .5em;
     padding-bottom: .5em;
 }
 
 .form-title {
     font-weight: bold;
 }
 
 input[type="submit"] {
     background: #fff;
     border: solid 1px #000;
     color: #000;
 }
 
 blockquote {
     border-left: solid 2px;
     padding-left: 5px;
     color: #B1FB17;
     margin: 0;
 }
 
 .post > .image {
     float: left;
     margin: 0 1ex .5ex 0;
     min-width: 1px;
     text-align: center;
     display: table-row;
 }
 
 .post > .metadata {
     clear: left;
 }
 
 .get {
     font-weight: bold;
     color: #d55;
 }
 
 * {
     text-decoration: none;
 }
 
 .dead_post {
     border-top: solid #d5494f;
 }
 
 .archive_post {
     border-top: solid #575e9f;
 }
 
 .quote {
     color: #080;
     font-style: italic;
 }
 
 .spoiler {
     background: white;
     color: white;
 }
 
 .spoiler:hover {
     color: black;
 }
 
 .comment {
     color: #8B6914;
     font-style: italic;
 }
 
 a:hover {
     text-decoration: underline;
 }
 
 .last-replies {
     margin-left: 3ex;
 }
 
 .thread {
     margin-bottom: 3ex;
 }
 
 .post:target {
     border: solid 2px black;
 }
 
 pre{
     white-space:pre-wrap
 }
 
 li {
     list-style-position: inside;
 }
 
 .fancybox-skin {
     position: relative;
     background-color: #fff;
     color: #ddd;
     text-shadow: none;
 }
 
 .fancybox-image {
     border: 1px solid black;
 }
 
 .image-mode-tab {
     display: table;
     margin: 5px;
     padding: 5px;
     background: rgb(221, 221, 221);
     border: 1px solid rgb(204, 204, 204);
     border-radius: 5px 5px 5px 5px;
 }
 
 .image-mode-tab > label {
     margin: 0 1ex;
 }
 
 .image-mode-tab > label > input {
     margin-right: .5ex;
 }
 
 #posts-table {
     margin: 5px;
 }
 
 .tag_info, .page_link {
     display: table;
 }
 
 .tag_info > h2 {
     margin: 0;
 }
 
 .moderator_info {
     color: #e99d41;
     border: dashed 1px;
     padding: 3px;
 }
 
 .refmap {
     font-size: 0.9em;
     color: #444;
     margin-top: 1em;
 }
 
 input[type="submit"]:hover {
         background: #ccc;
 }
 
 
 .fav {
     color: rgb(255, 102, 0);
 }
 
 .not_fav {
     color: #555;
 }
 
 .role {
     text-decoration: underline;
 }
 
 .form-email {
     display: none;
 }
 
 .mark_btn {
     padding: 2px 2ex;
     border: 1px solid;
 }
 
 .mark_btn:hover {
     background: #ccc;
 }
 
 .bar-value {
     background: rgba(251, 199, 16, 0.61);
     padding: 2px;
     font-size: 0.9em;
     height: 1.5em;
 }
 
 .bar-bg {
     position: relative;
     border: 1px solid rgb(204, 204, 204);
     border-radius: 5px 5px 5px 5px;
     margin: 5px;
     overflow: hidden;
 }
 
 .bar-text {
     padding: 2px;
     position: absolute;
     left: 0;
     top: 0;
 }
 
 .skipped_replies {
     margin: 5px;
 }
 
 .current_page, .current_mode {
     border: solid 1px #000;
     padding: 2px;
 }
 
 .tag_item {
     display: inline-block;
     border: 1px solid #ccc;
     margin: 0.3ex;
     padding: 0.2ex;
 }
 
 .multiquote {
     padding: 3px;
     display: inline-block;
     background: #ddd;
     border-style: solid;
     border-width: 1px 1px 1px 4px;
     border-color: #222;
     font-size: 0.9em;
 }
 
 .highlight {
     background-color: #F9E8A5;
 }
 
 #preview-text {
     border: solid 1px black;
     margin: 1ex 0 1ex 0;
     padding: 1ex;
 }
+
+.image-metadata {
+    font-style: italic;
+    font-size: 0.9em;
+}
  No newline at end of file

boards/static/css/sw/base_page.css

@@ -1,409 +1,418 b''
 * {
     font-size: inherit;
     margin: 0;
     padding: 0;
 }
 html {
     background: #fff;
     color: #000;
     font: medium sans-serif;
 }
 a {
     color: inherit;
     text-decoration: underline;
 }
 li {
     list-style-position: inside;
 }
 
 #admin_panel {
     background: #182F6F;
     color: #fff;
     padding: .5ex 1ex .5ex 1ex;
 }
 
 .navigation_panel {
     background: #182F6F;
     color: #B4CFEC;
     margin-bottom: 1em;
     padding: .5ex 1ex 1ex 1ex;
 }
 .navigation_panel::after {
     clear: both;
     content: ".";
     display: block;
     height: 0;
     line-height: 0;
     visibility: hidden;
 }
 
 .navigation_panel a:link, .navigation_panel a:visited, .navigation_panel a:hover {
     text-decoration: none;
 }
 
 .navigation_panel .link {
     border-right: 1px solid #fff;
     color: #fff;
     font-weight: bold;
     margin-right: 1ex;
     padding-right: 1ex;
 }
 .navigation_panel .right-link {
     border-left: 1px solid #fff;
     border-right: none;
     float: right;
     margin-left: 1ex;
     margin-right: 0;
     padding-left: 1ex;
     padding-right: 0;
 }
 
 .navigation_panel .tag {
     color: #fff;
 }
 
 .input_field {
 
 }
 
 .input_field_name {
 
 }
 
 .input_field_error {
     color: #FF0000;
 }
 
 
 .title {
     color: #182F6F;
     font-weight: bold;
 }
 
 .post-form-w {
     background: #182F6F;
     border-radius: 1ex;
     color: #fff;
     margin: 1em 1ex;
     padding: 1ex;
 }
 
 .form-row {
     display: table;
     width: 100%;
 }
 .form-label, .form-input {
     display: table-cell;
     vertical-align: top;
 }
 .form-label {
     padding: .25em 1ex .25em 0;
     width: 14ex;
 }
 .form-input {
     padding: .25em 0;
 }
 .form-input > * {
     background: #fff;
     color: #000;
     border: none;
     padding: 0;
     resize: vertical;
 }
 
 .form-input > :not(.file_wrap) {
     width: 100%;
 }
 
 .form-submit {
     border-bottom: 1px solid #666;
     margin-bottom: .5em;
     padding-bottom: .5em;
 }
 .form-title {
     font-weight: bold;
     margin-bottom: .5em;
 }
 .post-form .settings_item {
     margin: .5em 0;
 }
 .form-submit input {
     margin-top: .5em;
     padding: .2em 1ex;
 }
 .form-label {
     text-align: left;
 }
 
 .block {
     display: inline-block;
     vertical-align: top;
 }
 
 .post_id {
     color: #a00;
 }
 
 .post {
     clear: left;
     margin: 0 1ex 1em 1ex;
     overflow-x: auto;
     word-wrap: break-word;
     background: #FFF;
     padding: 1ex;
     border: 1px solid #666;
     box-shadow: 1px 1px 2px 1px #666;
 }
 
 #posts > .post:last-child {
     border-bottom: none;
     padding-bottom: 0;
 }
 
 .metadata {
     background: #C0E4E8;
     border: 1px solid #7F9699;
     border-radius: .4ex;
     display: table;
     margin-top: .5em;
     padding: .4em;
 }
 
 .post ul, .post ol {
     margin: .5em 0 .5em 3ex;
 }
 .post li {
     margin: .2em 0;
 }
 .post p {
     margin: .5em 0;
 }
 .post blockquote {
     border-left: 3px solid #182F6F;
     margin: .5em 0 .5em 3ex;
     padding-left: 1ex;
 }
 .post blockquote > blockquote {
     padding-top: .1em;
 }
 
 .post > .image {
     float: left;
     margin-right: 1ex;
 }
 .post > .metadata {
     clear: left;
 }
 
 .post > .message .get {
     color: #182F6F; font-weight: bold;
 }
 
 .dead_post > .metadata {
     background: #eee;
 }
 
 .quote, .multiquote {
     color: #182F6F;
 }
 
 .spoiler {
     background: black;
     color: black;
 }
 
 .spoiler:hover {
     background: #ffffff;
 }
 
 .comment {
     color: #557055;
 }
 
 .last-replies {
     margin-left: 6ex;
 }
 
 .thread > .post > .message > .post-info {
     border-bottom: 1px solid #ccc;
     padding-bottom: .5em;
 }
 
 :target .post_id {
     background: #182F6F;
     color: #FFF;
     text-decoration: none;
 }
 
 .image-mode-tab {
     background: #182F6F;
     color: #FFF;
     display: table;
     margin: 1em auto 1em 0;
     padding: .2em .5ex;
 }
 
 .image-mode-tab > label {
     margin: 0 1ex;
 }
 
 .image-mode-tab > label > input {
     margin-right: .5ex;
 }
 
 .tag_info, .page_link {
     margin: 1em 0;
     text-align: center;
 }
 
 .form-errors {
     margin-left: 1ex;
 }
 
 .moderator_info {
     font-weight: bold;
     float: right;
 }
 
 .refmap {
     border: 1px dashed #aaa;
     padding: 0.5em;
     display: table;
 }
 
 .fav {
     color: blue;
 }
 
 .not_fav {
     color: #ccc;
 }
 
 .role {
     text-decoration: underline;
 }
 
 .form-email {
     display: none;
 }
 
 .bar-value {
     background: #E3E7F2;
     padding: .1em 1ex;
     moz-box-sizing: border-box;
     box-sizing: border-box;
     height: 1.5em;
 }
 
 .bar-bg {
     background: #EA4649;
     border: 1px solid #666;
     margin: 0 1ex 1em 1ex;
     position: relative;
     overflow: hidden;
 }
 
 .bar-text {
     padding: 2px;
     position: absolute;
     left: 0;
     top: 0;
 }
 
 .skipped_replies {
     margin: 1ex;
 }
 
 #mark-panel {
     background: #eee;
     border-bottom: 1px solid #182F6F;
 }
 
 .mark_btn {
     display: inline-block;
     padding: .2em 1ex;
     border-left: 1px solid #182F6F;
 }
 
 .mark_btn:first-child {
     border-left: none;
 }
 
 .mark_btn:last-child {
     border-right: 1px solid #182F6F;
 }
 
 .current_page {
     border-bottom: 1px solid #FFF;
     padding: 0px 0.5ex;
 }
 
 .image-mode-tab a {
     text-decoration: none;
 }
 .image-mode-tab .current_mode::before {
     content: "✓ ";
     padding: 0 0 0 .5ex;
     color: #182F6F;
     background: #FFF;
 }
 .image-mode-tab .current_mode {
     padding: 0 .5ex 0 0;
     color: #182F6F;
     background: #FFF;
 }
 
 .gallery_image_metadata {
     margin-bottom: 1em;
 }
 
 .gallery_image {
     padding: 4px;
     margin: .5em 0 0 1ex;
     text-align: center;
     vertical-align: top;
 }
 
 .swappable-form-full > form {
     display: table;
     width: 100%;
 }
 
 #id_models li {
     list-style: none;
 }
 
 #id_q {
     margin-left: 1ex;
 }
 
 .br {
     margin-top: 0.5em;
     margin-bottom: 0.5em;
 }
 
 .message, .refmap {
     margin-top: .5em;
 }
 
 .user-cast {
     padding: 0.2em .5ex;
     background: #008;
     color: #FFF;
     display: inline-block;
     text-decoration: none;
 }
 
 .highlight {
     background-color: #D4F0F9;
 }
 
 .dead_post {
     border-right: 1ex solid #666;
 }
 
 #preview-text {
     border: solid 1px white;
     margin: 1ex 0 1ex 0;
     padding: 1ex;
 }
+
+.image-metadata {
+    font-style: italic;
+    font-size: 0.9em;
+}
+
+audio {
+    margin-top: 1em;
+}

boards/static/js/image.js

@@ -1,148 +1,160 b''
 /*
  @licstart  The following is the entire license notice for the
  JavaScript code in this page.
 
 
  Copyright (C) 2013  neko259
 
  The JavaScript code in this page is free software: you can
  redistribute it and/or modify it under the terms of the GNU
  General Public License (GNU GPL) as published by the Free Software
  Foundation, either version 3 of the License, or (at your option)
  any later version.  The code is distributed WITHOUT ANY WARRANTY;
  without even the implied warranty of MERCHANTABILITY or FITNESS
  FOR A PARTICULAR PURPOSE.  See the GNU GPL for more details.
 
  As additional permission under GNU GPL version 3 section 7, you
  may distribute non-source (e.g., minimized or compacted) forms of
  that code without the copy of the GNU GPL normally required by
  section 4, provided you include this license notice and a URL
  through which recipients can access the Corresponding Source.
 
  @licend  The above is the entire license notice
  for the JavaScript code in this page.
  */
 
 
 var IMAGE_VIEWERS = [
     ['simple', new SimpleImageViewer()],
     ['popup', new PopupImageViewer()]
 ];
 
 var FULL_IMG_CLASS = 'post-image-full';
 
 
 function ImageViewer() {}
 ImageViewer.prototype.view = function (post) {};
 
 function SimpleImageViewer() {}
 SimpleImageViewer.prototype.view = function (post) {
     var images = post.find('img');
     images.toggle();
 
     // When we first enlarge an image, a full image needs to be created
     if (images.length == 1) {
+        var thumb = images.first();
+
+        var width = thumb.attr('data-width');
+        var height = thumb.attr('data-height');
+
+        if (width == null || height == null) {
+            width = '100%';
+            height = '100%';
+        }
+
         var parent = images.first().parent();
         var link = parent.attr('href');
 
         var fullImg = $('<img />')
             .addClass(FULL_IMG_CLASS)
-            .attr('src', link);
+            .attr('src', link)
+            .attr('width', width)
+            .attr('height', height);
 
         parent.append(fullImg);
     }
 };
 
 function PopupImageViewer() {}
 PopupImageViewer.prototype.view = function (post) {
     var margin = 20; //..change
 
     var el = post;
     var thumb_id = 'full' + el.find('img').attr('alt');
 
     var existingPopups = $('#' + thumb_id);
     if(!existingPopups.length) {
         var imgElement= el.find('img');
 
         var img_w = imgElement.attr('data-width');
         var img_h = imgElement.attr('data-height');
 
         var win = $(window);
 
         var win_w = win.width();
         var win_h = win.height();
         //new image size
         if (img_w > win_w) {
             img_h = img_h * (win_w/img_w) - margin;
             img_w = win_w - margin;
         }
         if (img_h > win_h) {
             img_w = img_w * (win_h/img_h) - margin;
             img_h = win_h - margin;
         }
 
         var img_pv = new Image();
         var newImage = $(img_pv);
         newImage.addClass('img-full')
             .attr('id', thumb_id)
             .attr('src', $(el).attr('href'))
             .appendTo($(el))
             .css({
                 'width': img_w,
                 'height': img_h,
                 'left': (win_w - img_w) / 2,
                 'top': ((win_h - img_h) / 2)
             })
         //scaling preview
         .mousewheel(function(event, delta) {
             var cx = event.originalEvent.clientX,
             cy = event.originalEvent.clientY,
             i_w = parseFloat(newImage.width()),
             i_h = parseFloat(newImage.height()),
             newIW = i_w * (delta > 0 ? 1.25 : 0.8),
             newIH = i_h * (delta > 0 ? 1.25 : 0.8);
 
             newImage.width(newIW);
             newImage.height(newIH);
             //set position
             newImage.css({
                 left: parseInt(cx - (newIW/i_w) * (cx - parseInt($(img_pv).position().left, 10)), 10),
                 top:  parseInt(cy - (newIH/i_h) * (cy - parseInt($(img_pv).position().top, 10)), 10)
             });
 
             return false;
         }
         )
             .draggable({
                 addClasses: false,
                 stack: '.img-full'
             });
     } else {
         existingPopups.remove();
     }
 };
 
 function addImgPreview() {
     var viewerName = $('body').attr('data-image-viewer');
     var viewer = ImageViewer();
     for (var i = 0; i < IMAGE_VIEWERS.length; i++) {
         var item = IMAGE_VIEWERS[i];
         if (item[0] === viewerName) {
             viewer = item[1];
             break;
         }
     }
 
     //keybind
     $(document).on('keyup.removepic', function(e) {
         if(e.which === 27) {
             $('.img-full').remove();
         }
     });
 
     $('body').on('click', '.thumb', function() {
         viewer.view($(this));
 
         return false;
     });
 }

boards/static/js/thread.js

@@ -1,103 +1,109 b''
 /*
  @licstart  The following is the entire license notice for the
  JavaScript code in this page.
 
 
  Copyright (C) 2013  neko259
 
  The JavaScript code in this page is free software: you can
  redistribute it and/or modify it under the terms of the GNU
  General Public License (GNU GPL) as published by the Free Software
  Foundation, either version 3 of the License, or (at your option)
  any later version.  The code is distributed WITHOUT ANY WARRANTY;
  without even the implied warranty of MERCHANTABILITY or FITNESS
  FOR A PARTICULAR PURPOSE.  See the GNU GPL for more details.
 
  As additional permission under GNU GPL version 3 section 7, you
  may distribute non-source (e.g., minimized or compacted) forms of
  that code without the copy of the GNU GPL normally required by
  section 4, provided you include this license notice and a URL
  through which recipients can access the Corresponding Source.
 
  @licend  The above is the entire license notice
  for the JavaScript code in this page.
  */
 
 var CLOSE_BUTTON = '#form-close-button';
+var REPLY_TO_MSG = '.reply-to-message';
+var REPLY_TO_MSG_ID = '#reply-to-message-id';
+
 var $html = $("html, body");
 
 function moveCaretToEnd(el) {
         if (typeof el.selectionStart == "number") {
             el.selectionStart = el.selectionEnd = el.value.length;
         } else if (typeof el.createTextRange != "undefined") {
             el.focus();
             var range = el.createTextRange();
             range.collapse(false);
             range.select();
         }
 }
 
 function getForm() {
     return $('.post-form-w');
 }
 
 function resetFormPosition() {
     var form = getForm();
     form.insertAfter($('.thread'));
 
     $(CLOSE_BUTTON).hide();
+    $(REPLY_TO_MSG).hide();
 }
 
 function showFormAfter(blockToInsertAfter) {
     var form = getForm();
     form.insertAfter(blockToInsertAfter);
 
     $(CLOSE_BUTTON).show();
     form.show();
+    $(REPLY_TO_MSG_ID).text(blockToInsertAfter.attr('id'));
+    $(REPLY_TO_MSG).show();
 }
 
 function addQuickReply(postId) {
     // If we click "reply" on the same post, it means "cancel"
     if (getForm().prev().attr('id') == postId) {
         resetFormPosition();
     } else {
         var postLinkRaw = '[post]' + postId + '[/post]'
 
             var textToAdd = '';
         var blockToInsert = null;
 
         var textAreaJq = $('textarea');
 
         if (postId != null) {
             var post = $('#' + postId);
 
             // If this is not OP, add reflink to the post. If there already is
             // the same reflink, don't add it again.
             if (!post.is(':first-child') && textAreaJq.val().indexOf(postLinkRaw) < 0) {
                 textToAdd += postLinkRaw + '\n';
             }
 
             blockToInsert = post;
         } else {
             blockToInsert = $('.thread');
         }
 
         var selection = window.getSelection().toString();
         if (selection.length > 0) {
             textToAdd += '[quote]' + selection + '[/quote]\n';
         }
 
         textAreaJq.val(textAreaJq.val()+ textToAdd);
 
         showFormAfter(blockToInsert);
 
         textAreaJq.focus();
         var textarea = document.getElementsByTagName('textarea')[0];
         moveCaretToEnd(textarea);
     }
 }
 
 function scrollToBottom() {
     $html.animate({scrollTop: $html.height()}, "fast");
 }
 

boards/static/js/thread_update.js

@@ -1,391 +1,456 b''
 /*
  @licstart  The following is the entire license notice for the
  JavaScript code in this page.
 
 
  Copyright (C) 2013-2014  neko259
 
  The JavaScript code in this page is free software: you can
  redistribute it and/or modify it under the terms of the GNU
  General Public License (GNU GPL) as published by the Free Software
  Foundation, either version 3 of the License, or (at your option)
  any later version.  The code is distributed WITHOUT ANY WARRANTY;
  without even the implied warranty of MERCHANTABILITY or FITNESS
  FOR A PARTICULAR PURPOSE.  See the GNU GPL for more details.
 
  As additional permission under GNU GPL version 3 section 7, you
  may distribute non-source (e.g., minimized or compacted) forms of
  that code without the copy of the GNU GPL normally required by
  section 4, provided you include this license notice and a URL
  through which recipients can access the Corresponding Source.
 
  @licend  The above is the entire license notice
  for the JavaScript code in this page.
  */
 
 var CLASS_POST = '.post'
 
 var POST_ADDED = 0;
 var POST_UPDATED = 1;
 
 var JS_AUTOUPDATE_PERIOD = 20000;
 
+var ALLOWED_FOR_PARTIAL_UPDATE = [
+    'refmap',
+    'post-info'
+];
+
+var ATTR_CLASS = 'class';
+var ATTR_UID = 'data-uid';
+
 var wsUser = '';
 
 var unreadPosts = 0;
 var documentOriginalTitle = '';
 
 // Thread ID does not change, can be stored one time
 var threadId = $('div.thread').children(CLASS_POST).first().attr('id');
 
 /**
  * Connect to websocket server and subscribe to thread updates. On any update we
  * request a thread diff.
  *
  * @returns {boolean} true if connected, false otherwise
  */
 function connectWebsocket() {
     var metapanel = $('.metapanel')[0];
 
     var wsHost = metapanel.getAttribute('data-ws-host');
     var wsPort = metapanel.getAttribute('data-ws-port');
 
     if (wsHost.length > 0 && wsPort.length > 0) {
         var centrifuge = new Centrifuge({
             "url": 'ws://' + wsHost + ':' + wsPort + "/connection/websocket",
             "project": metapanel.getAttribute('data-ws-project'),
             "user": wsUser,
             "timestamp": metapanel.getAttribute('data-ws-token-time'),
             "token": metapanel.getAttribute('data-ws-token'),
             "debug": false
         });
 
         centrifuge.on('error', function(error_message) {
             console.log("Error connecting to websocket server.");
             console.log(error_message);
             console.log("Using javascript update instead.");
 
             // If websockets don't work, enable JS update instead
             enableJsUpdate()
         });
 
         centrifuge.on('connect', function() {
             var channelName = 'thread:' + threadId;
             centrifuge.subscribe(channelName, function(message) {
                 getThreadDiff();
             });
 
             // For the case we closed the browser and missed some updates
             getThreadDiff();
             $('#autoupdate').hide();
         });
 
         centrifuge.connect();
 
         return true;
     } else {
         return false;
     }
 }
 
 /**
  * Get diff of the posts from the current thread timestamp.
  * This is required if the browser was closed and some post updates were
  * missed.
  */
 function getThreadDiff() {
     var lastUpdateTime = $('.metapanel').attr('data-last-update');
     var lastPostId = $('.post').last().attr('id');
 
     var uids = '';
     var posts = $('.post');
     for (var i = 0; i < posts.length; i++) {
         uids += posts[i].getAttribute('data-uid') + ' ';
     }
 
     var data = {
         uids: uids,
         thread: threadId
     }
 
     var diffUrl = '/api/diff_thread/';
 
     $.post(diffUrl,
         data,
         function(data) {
             var updatedPosts = data.updated;
             var addedPostCount = 0;
 
             for (var i = 0; i < updatedPosts.length; i++) {
                 var postText = updatedPosts[i];
                 var post = $(postText);
 
                 if (updatePost(post) == POST_ADDED) {
                     addedPostCount++;
                 }
             }
 
             var hasMetaUpdates = updatedPosts.length > 0;
             if (hasMetaUpdates) {
                 updateMetadataPanel();
             }
 
             if (addedPostCount > 0) {
                 updateBumplimitProgress(addedPostCount);
             }
 
             if (updatedPosts.length > 0) {
                 showNewPostsTitle(addedPostCount);
             }
 
             // TODO Process removed posts if any
             $('.metapanel').attr('data-last-update', data.last_update);
         },
         'json'
     )
 }
 
 /**
  * Add or update the post on html page.
  */
 function updatePost(postHtml) {
     // This needs to be set on start because the page is scrolled after posts
     // are added or updated
     var bottom = isPageBottom();
 
     var post = $(postHtml);
 
     var threadBlock = $('div.thread');
 
     var postId = post.attr('id');
 
     // If the post already exists, replace it. Otherwise add as a new one.
     var existingPosts = threadBlock.children('.post[id=' + postId + ']');
 
     var type;
 
     if (existingPosts.size() > 0) {
-        existingPosts.replaceWith(post);
+        replacePartial(existingPosts.first(), post, false);
+        post = existingPosts.first();
 
         type = POST_UPDATED;
     } else {
         post.appendTo(threadBlock);
 
         if (bottom) {
             scrollToBottom();
         }
 
         type = POST_ADDED;
     }
 
     processNewPost(post);
 
     return type;
 }
 
 /**
  * Initiate a blinking animation on a node to show it was updated.
  */
 function blink(node) {
     var blinkCount = 2;
 
     var nodeToAnimate = node;
     for (var i = 0; i < blinkCount; i++) {
         nodeToAnimate = nodeToAnimate.fadeTo('fast', 0.5).fadeTo('fast', 1.0);
     }
 }
 
 function isPageBottom() {
     var scroll = $(window).scrollTop() / ($(document).height()
         - $(window).height());
 
     return scroll == 1
 }
 
 function enableJsUpdate() {
     setInterval(getThreadDiff, JS_AUTOUPDATE_PERIOD);
     return true;
 }
 
 function initAutoupdate() {
     if (location.protocol === 'https:') {
         return enableJsUpdate();
     } else {
         if (connectWebsocket()) {
             return true;
         } else {
             return enableJsUpdate();
         }
     }
 }
 
 function getReplyCount() {
     return $('.thread').children(CLASS_POST).length
 }
 
 function getImageCount() {
     return $('.thread').find('img').length
 }
 
 /**
  * Update post count, images count and last update time in the metadata
  * panel.
  */
 function updateMetadataPanel() {
     var replyCountField = $('#reply-count');
     var imageCountField = $('#image-count');
 
     replyCountField.text(getReplyCount());
     imageCountField.text(getImageCount());
 
     var lastUpdate = $('.post:last').children('.post-info').first()
         .children('.pub_time').first().html();
     if (lastUpdate !== '') {
         var lastUpdateField = $('#last-update');
         lastUpdateField.html(lastUpdate);
         blink(lastUpdateField);
     }
 
     blink(replyCountField);
     blink(imageCountField);
 }
 
 /**
  * Update bumplimit progress bar
  */
 function updateBumplimitProgress(postDelta) {
     var progressBar = $('#bumplimit_progress');
     if (progressBar) {
         var postsToLimitElement = $('#left_to_limit');
 
         var oldPostsToLimit = parseInt(postsToLimitElement.text());
         var postCount = getReplyCount();
         var bumplimit = postCount - postDelta + oldPostsToLimit;
 
         var newPostsToLimit = bumplimit - postCount;
         if (newPostsToLimit <= 0) {
             $('.bar-bg').remove();
         } else {
             postsToLimitElement.text(newPostsToLimit);
             progressBar.width((100 - postCount / bumplimit * 100.0) + '%');
         }
     }
 }
 
 /**
  * Show 'new posts' text in the title if the document is not visible to a user
  */
 function showNewPostsTitle(newPostCount) {
     if (document.hidden) {
         if (documentOriginalTitle === '') {
             documentOriginalTitle = document.title;
         }
         unreadPosts = unreadPosts + newPostCount;
 
         var newTitle = '* ';
         if (unreadPosts > 0) {
             newTitle += '[' + unreadPosts + '] ';
         }
         newTitle += documentOriginalTitle;
 
         document.title = newTitle;
 
         document.addEventListener('visibilitychange', function() {
             if (documentOriginalTitle !== '') {
                 document.title = documentOriginalTitle;
                 documentOriginalTitle = '';
                 unreadPosts = 0;
             }
 
             document.removeEventListener('visibilitychange', null);
         });
     }
 }
 
 /**
  * Clear all entered values in the form fields
  */
 function resetForm(form) {
     form.find('input:text, input:password, input:file, select, textarea').val('');
     form.find('input:radio, input:checkbox')
              .removeAttr('checked').removeAttr('selected');
     $('.file_wrap').find('.file-thumb').remove();
     $('#preview-text').hide();
 }
 
 /**
  * When the form is posted, this method will be run as a callback
  */
 function updateOnPost(response, statusText, xhr, form) {
     var json = $.parseJSON(response);
     var status = json.status;
 
     showAsErrors(form, '');
 
     if (status === 'ok') {
         resetFormPosition();
         resetForm(form);
         getThreadDiff();
         scrollToBottom();
     } else {
         var errors = json.errors;
         for (var i = 0; i < errors.length; i++) {
             var fieldErrors = errors[i];
 
             var error = fieldErrors.errors;
 
             showAsErrors(form, error);
         }
     }
 }
 
 /**
  * Show text in the errors row of the form.
  * @param form
  * @param text
  */
 function showAsErrors(form, text) {
     form.children('.form-errors').remove();
 
     if (text.length > 0) {
         var errorList = $('<div class="form-errors">' + text + '<div>');
         errorList.appendTo(form);
     }
 }
 
 /**
  * Run js methods that are usually run on the document, on the new post
  */
 function processNewPost(post) {
     addRefLinkPreview(post[0]);
     highlightCode(post);
     blink(post);
 }
 
+function replacePartial(oldNode, newNode, recursive) {
+    if (!equalNodes(oldNode, newNode)) {
+        // Update parent node attributes
+        updateNodeAttr(oldNode, newNode, ATTR_CLASS);
+        updateNodeAttr(oldNode, newNode, ATTR_UID);
+
+        // Replace children
+        var children = oldNode.children();
+        if (children.length == 0) {
+            console.log(oldContent);
+            console.log(newContent)
+
+            oldNode.replaceWith(newNode);
+        } else {
+            var newChildren = newNode.children();
+            newChildren.each(function(i) {
+                var newChild = newChildren.eq(i);
+                var newChildClass = newChild.attr(ATTR_CLASS);
+
+                // Update only certain allowed blocks (e.g. not images)
+                if (ALLOWED_FOR_PARTIAL_UPDATE.indexOf(newChildClass) > -1) {
+                    var oldChild = oldNode.children('.' + newChildClass);
+
+                    if (oldChild.length == 0) {
+                        oldNode.append(newChild);
+                    } else {
+                        if (!equalNodes(oldChild, newChild)) {
+                            if (recursive) {
+                                replacePartial(oldChild, newChild, false);
+                            } else {
+                                oldChild.replaceWith(newChild);
+                            }
+                        }
+                    }
+                }
+            });
+        }
+    }
+}
+
+/**
+ * Compare nodes by content
+ */
+function equalNodes(node1, node2) {
+    return node1[0].outerHTML == node2[0].outerHTML;
+}
+
+/**
+ * Update attribute of a node if it has changed
+ */
+function updateNodeAttr(oldNode, newNode, attrName) {
+    var oldAttr = oldNode.attr(attrName);
+    var newAttr = newNode.attr(attrName);
+    if (oldAttr != newAttr) {
+        oldNode.attr(attrName, newAttr);
+    };
+}
+
 $(document).ready(function(){
     if (initAutoupdate()) {
         // Post form data over AJAX
         var threadId = $('div.thread').children('.post').first().attr('id');
 
         var form = $('#form');
 
         if (form.length > 0) {
             var options = {
                 beforeSubmit: function(arr, $form, options) {
                     showAsErrors($('form'), gettext('Sending message...'));
                 },
                 success: updateOnPost,
                 error: function() {
                     showAsErrors($('form'), gettext('Server error!'));
                 },
                 url: '/api/add_post/' + threadId + '/'
             };
 
             form.ajaxForm(options);
 
             resetForm(form);
         }
     }
-
-    $('#autoupdate').click(getThreadDiff);
 });

boards/templates/boards/all_threads.html

@@ -1,166 +1,186 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load board %}
 {% load static %}
 {% load tz %}
 
 {% block head %}
     <meta name="robots" content="noindex">
 
     {% if tag %}
         <title>{{ tag.name }} - {{ site_name }}</title>
     {% else %}
         <title>{{ site_name }}</title>
     {% endif %}
 
     {% if prev_page_link %}
         <link rel="prev" href="{{ prev_page_link }}" />
     {% endif %}
     {% if next_page_link %}
         <link rel="next" href="{{ next_page_link }}" />
     {% endif %}
 
 {% endblock %}
 
 {% block content %}
 
     {% get_current_language as LANGUAGE_CODE %}
     {% get_current_timezone as TIME_ZONE %}
 
     {% for banner in banners %}
         <div class="post">
             <div class="title">{{ banner.title }}</div>
             <div>{{ banner.text }}</div>
             <div>{% trans 'Related message' %}: <a href="{{ banner.post.get_absolute_url }}">>>{{ banner.post.id }}</a></div>
         </div>
     {% endfor %}
 
 {% if tag %}
     <div class="tag_info">
+        {% if random_image_post %}
+            <div class="tag-image">
+                {% with image=random_image_post.images.first %}
+                    <a href="{{ random_image_post.get_absolute_url }}"><img 
+                        src="{{ image.image.url_200x150 }}"
+                        width="{{ image.pre_width }}"
+                        height="{{ image.pre_height }}"/></a>
+                {% endwith %}
+            </div>
+        {% endif %}
+        <div class="tag-text-data">
         <h2>
             <form action="{% url 'tag' tag.name %}" method="post" class="post-button-form">
                 {% if is_favorite %}
                     <button name="method" value="unsubscribe" class="fav">★</button>
                 {% else %}
                     <button name="method" value="subscribe" class="not_fav">★</button>
                 {% endif %}
             </form>
             <form action="{% url 'tag' tag.name %}" method="post" class="post-button-form">
                 {% if is_hidden %}
                     <button name="method" value="unhide" class="fav">H</button>
                 {% else %}
                     <button name="method" value="hide" class="not_fav">H</button>
                 {% endif %}
             </form>
-            {% autoescape off %}
-                {{ tag.get_view }}
-            {% endautoescape %}
+                {{ tag.get_view|safe }}
             {% if moderator %}
-            <span class="moderator_info">[<a href="{% url 'admin:boards_tag_change' tag.id %}">{% trans 'Edit tag' %}</a>]</span>
+                <span class="moderator_info">| <a href="{% url 'admin:boards_tag_change' tag.id %}">{% trans 'Edit tag' %}</a></span>
             {% endif %}
         </h2>
-        <p>{% blocktrans with thread_count=tag.get_thread_count post_count=tag.get_post_count %}This tag has {{ thread_count }} threads and {{ post_count }} posts.{% endblocktrans %}</p>
+            {% if tag.get_description %}
+                <p>{{ tag.get_description|safe }}</p>
+            {% endif %}
+            <p>{% blocktrans with active_thread_count=tag.get_active_thread_count thread_count=tag.get_thread_count post_count=tag.get_post_count %}This tag has {{ thread_count }} threads ({{ active_thread_count}} active) and {{ post_count }} posts.{% endblocktrans %}</p>
+            {% if related_tags %}
+                <p>{% trans 'Related tags:' %}
+                {% for rel_tag in related_tags %}
+                    {{ rel_tag.get_view|safe }}{% if not forloop.last %}, {% else %}.{% endif %}
+                {% endfor %}
+                </p>
+            {% endif %}
+        </div>
     </div>
 {% endif %}
 
     {% if threads %}
         {% if prev_page_link %}
             <div class="page_link">
                 <a href="{{ prev_page_link }}">{% trans "Previous page" %}</a>
             </div>
         {% endif %}
 
         {% for thread in threads %}
             <div class="thread">
                 {% post_view thread.get_opening_post moderator=moderator is_opening=True thread=thread truncated=True need_open_link=True %}
                 {% if not thread.archived %}
                     {% with last_replies=thread.get_last_replies %}
                         {% if last_replies %}
                             {% with skipped_replies_count=thread.get_skipped_replies_count %}
                                 {% if skipped_replies_count %}
                                     <div class="skipped_replies">
                                         <a href="{% url 'thread' thread.get_opening_post_id %}">
                                             {% blocktrans with count=skipped_replies_count %}Skipped {{ count }} replies. Open thread to see all replies.{% endblocktrans %}
                                         </a>
                                     </div>
                                 {% endif %}
                             {% endwith %}
                             <div class="last-replies">
                                 {% for post in last_replies %}
                                     {% post_view post is_opening=False moderator=moderator truncated=True %}
                                 {% endfor %}
                             </div>
                         {% endif %}
                     {% endwith %}
                 {% endif %}
             </div>
         {% endfor %}
 
         {% if next_page_link %}
             <div class="page_link">
                 <a href="{{ next_page_link }}">{% trans "Next page" %}</a>
             </div>
         {% endif %}
     {% else %}
         <div class="post">
             {% trans 'No threads exist. Create the first one!' %}</div>
     {% endif %}
 
     <div class="post-form-w">
         <script src="{% static 'js/panel.js' %}"></script>
         <div class="post-form">
             <div class="form-title">{% trans "Create new thread" %}</div>
             <div class="swappable-form-full">
             <form enctype="multipart/form-data" method="post" id="form">{% csrf_token %}
                 {{ form.as_div }}
                 <div class="form-submit">
                     <input type="submit" value="{% trans "Post" %}"/>
+                    <button id="preview-button" onclick="return false;">{% trans 'Preview' %}</button>
                 </div>
             </form>
             </div>
             <div>
                 {% trans 'Tags must be delimited by spaces. Text or image is required.' %}
             </div>
-            <div><button id="preview-button">{% trans 'Preview' %}</button></div>
             <div id="preview-text"></div>
             <div><a href="{% url "staticpage" name="help" %}">{% trans 'Text syntax' %}</a></div>
             <div><a href="{% url "tags" "required" %}">{% trans 'Tags' %}</a></div>
         </div>
     </div>
 
     <script src="{% static 'js/form.js' %}"></script>
     <script src="{% static 'js/thread_create.js' %}"></script>
 
 {% endblock %}
 
 {% block metapanel %}
 
     <span class="metapanel">
         <b><a href="{% url "authors" %}">{{ site_name }}</a> {{ version }}</b>
         {% trans "Pages:" %}
         [
         {% with dividers=paginator.get_dividers %}
             {% for page in paginator.get_divided_range %}
                 {% if page in dividers %}
                     …,
                 {% endif %}
                 <a
                     {% ifequal page current_page.number %}
                         class="current_page"
                     {% endifequal %}
                     href="
                 {% if tag %}
                 {% url "tag" tag_name=tag.name %}?page={{ page }}
                 {% else %}
                     {% url "index" %}?page={{ page }}
                 {% endif %}
                 ">{{ page }}</a>
                 {% if not forloop.last %},{% endif %}
             {% endfor %}
         {% endwith %}
         ]
         [<a href="rss/">RSS</a>]
     </span>
 
 {% endblock %}

boards/templates/boards/base.html

@@ -1,73 +1,74 b''
 {% load staticfiles %}
 {% load i18n %}
 {% load l10n %}
 {% load static from staticfiles %}
 
 <!DOCTYPE html>
 <html>
 <head>
     <link rel="stylesheet" type="text/css" href="{% static 'css/base.css' %}" media="all"/>
     <link rel="stylesheet" type="text/css" href="{% static 'css/3party/highlight.css' %}" media="all"/>
     <link rel="stylesheet" type="text/css" href="{% static 'css/3party/jquery-ui.min.css' %}" media="all"/>
     <link rel="stylesheet" type="text/css" href="{% static theme_css %}" media="all"/>
 
     <link rel="alternate" type="application/rss+xml" href="rss/" title="{% trans 'Feed' %}"/>
 
     <link rel="icon" type="image/png"
         href="{% static 'favicon.png' %}">
 
     <meta name="viewport" content="width=device-width, initial-scale=1"/>
     <meta charset="utf-8"/>
 
     {% block head %}{% endblock %}
 </head>
 <body data-image-viewer="{{ image_viewer }}">
     <script src="{% static 'js/jquery-2.0.1.min.js' %}"></script>
     <script src="{% static 'js/3party/jquery-ui.min.js' %}"></script>
     <script src="{% static 'js/jquery.mousewheel.js' %}"></script>
     <script src="{% url 'js_info_dict' %}"></script>
 
     <div class="navigation_panel header">
         <a class="link" href="{% url 'index' %}">{% trans "All threads" %}</a>
         {% if tags_str %}
             {% autoescape off %}
                 {{ tags_str }},
             {% endautoescape %}
         {% else %}
             {% trans 'Add tags' %} → 
         {% endif %}
         <a href="{% url 'tags' 'required'%}" title="{% trans 'Tag management' %}">{% trans "tags" %}</a>,
             <a href="{% url 'search' %}" title="{% trans 'Search' %}">{% trans 'search' %}</a>,
-        <a href="{% url 'feed' %}" title="{% trans 'Feed' %}">{% trans 'feed' %}</a>
+        <a href="{% url 'feed' %}" title="{% trans 'Feed' %}">{% trans 'feed' %}</a>,
+        <a href="{% url 'random' %}" title="{% trans 'Random images' %}">{% trans 'random' %}</a>
 
         {% if username %}
             <a class="right-link link" href="{% url 'notifications' username %}" title="{% trans 'Notifications' %}">
                 {% trans 'Notifications' %}
                 {% ifnotequal new_notifications_count 0 %}
                     (<b>{{ new_notifications_count }}</b>)
                 {% endifnotequal %}
             </a>
         {% endif %}
 
         <a class="right-link link" href="{% url 'settings' %}">{% trans 'Settings' %}</a>
     </div>
 
     {% block content %}{% endblock %}
 
     <script src="{% static 'js/3party/highlight.min.js' %}"></script>
     <script src="{% static 'js/popup.js' %}"></script>
     <script src="{% static 'js/image.js' %}"></script>
     <script src="{% static 'js/refpopup.js' %}"></script>
     <script src="{% static 'js/main.js' %}"></script>
 
     <div class="navigation_panel footer">
         {% block metapanel %}{% endblock %}
         [<a href="{% url 'admin:index' %}">{% trans 'Admin' %}</a>]
         {% with ppd=posts_per_day|floatformat:2 %}
             {% blocktrans %}Speed: {{ ppd }} posts per day{% endblocktrans %}
         {% endwith %}
         <a class="link" href="#top" id="up">{% trans 'Up' %}</a>
     </div>
 
 </body>
 </html>

boards/templates/boards/feed.html

@@ -1,71 +1,71 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load board %}
 {% load static %}
 {% load tz %}
 
 {% block head %}
     <meta name="robots" content="noindex">
 
     <title>{{ site_name }} - {% trans "feed" %}</title>
 
     {% if prev_page_link %}
         <link rel="prev" href="{{ prev_page_link }}" />
     {% endif %}
     {% if next_page_link %}
         <link rel="next" href="{{ next_page_link }}" />
     {% endif %}
 
 {% endblock %}
 
 {% block content %}
 
     {% get_current_language as LANGUAGE_CODE %}
     {% get_current_timezone as TIME_ZONE %}
 
     {% if posts %}
         {% if prev_page_link %}
             <div class="page_link">
                 <a href="{{ prev_page_link }}">{% trans "Previous page" %}</a>
             </div>
         {% endif %}
 
         {% for post in posts %}
             {% post_view post moderator=moderator truncated=True need_op_data=True %}
         {% endfor %}
 
         {% if next_page_link %}
             <div class="page_link">
                 <a href="{{ next_page_link }}">{% trans "Next page" %}</a>
             </div>
         {% endif %}
     {% else %}
         <div class="post">
             {% trans 'No posts exist. Create the first one!' %}</div>
     {% endif %}
 {% endblock %}
 
 {% block metapanel %}
 
     <span class="metapanel">
         <b><a href="{% url "authors" %}">{{ site_name }}</a> {{ version }}</b>
         {% trans "Pages:" %}
         [
         {% with dividers=paginator.get_dividers %}
             {% for page in paginator.get_divided_range %}
                 {% if page in dividers %}
                     …,
                 {% endif %}
                 <a
                     {% ifequal page current_page.number %}
                         class="current_page"
                     {% endifequal %}
-                    href="{% url "feed" %}?page={{ page }}">{{ page }}</a>
+                    href="{% url "feed" %}?page={{ page }}{{ additional_attrs }}">{{ page }}</a>
                 {% if not forloop.last %},{% endif %}
             {% endfor %}
         {% endwith %}
         ]
     </span>
 
 {% endblock %}

boards/templates/boards/post.html

@@ -1,107 +1,113 b''
 {% load i18n %}
 {% load board %}
 
 {% get_current_language as LANGUAGE_CODE %}
 
 <div class="{{ css_class }}" id="{{ post.id }}" data-uid="{{ post.uid }}">
     <div class="post-info">
-        <a class="post_id" href="{{ post.get_absolute_url }}">({{ post.get_absolute_id }})</a>
+        <a class="post_id" href="{{ post.get_absolute_url }}">#{{ post.get_absolute_id }}</a>
         <span class="title">{{ post.title }}</span>
         <span class="pub_time"><time datetime="{{ post.pub_time|date:'c' }}">{{ post.pub_time }}</time></span>
+        {% if post.tripcode %}
+            {% with tripcode=post.get_tripcode %}
+            <a href="{% url 'feed' %}?tripcode={{ tripcode.get_full_text }}"
+               class="tripcode" title="{{ tripcode.get_full_text }}"
+               style="border: solid 2px #{{ tripcode.get_color }}; border-left: solid 1ex #{{ tripcode.get_color }};">{{ tripcode.get_short_text }}</a>
+            {% endwith %}
+        {% endif %}
         {% comment %}
             Thread death time needs to be shown only if the thread is alredy archived
             and this is an opening post (thread death time) or a post for popup
             (we don't see OP here so we show the death time in the post itself).
         {% endcomment %}
         {% if thread.archived %}
             {% if is_opening %}
             — <time datetime="{{ thread.bump_time|date:'c' }}">{{ thread.bump_time }}</time>
             {% endif %}
         {% endif %}
         {% if is_opening %}
             {% if need_open_link %}
                 {% if thread.archived %}
                     <a class="link" href="{% url 'thread' post.id %}">{% trans "Open" %}</a>
                 {% else %}
                     <a class="link" href="{% url 'thread' post.id %}#form">{% trans "Reply" %}</a>
                 {% endif %}
             {% endif %}
         {% else %}
             {% if need_op_data %}
                 {% with thread.get_opening_post as op %}
-                    {% trans " in " %}<a href="{{ op.get_absolute_url }}">&gt;&gt;{{ op.id }}</a> <span class="title">{{ op.get_title|striptags|truncatewords:5 }}</span>
+                    {% trans " in " %}{{ op.get_link_view|safe }} <span class="title">{{ op.get_title|striptags|truncatewords:5 }}</span>
                 {% endwith %}
             {% endif %}
         {% endif %}
         {% if reply_link and not thread.archived %}
             <a href="#form" onclick="addQuickReply('{{ post.id }}'); return false;">{% trans 'Reply' %}</a>
         {% endif %}
 
         {% if post.global_id %}
             <a class="global-id" href="{% url 'post_sync_data' post.id %}"> [RAW] </a>
         {% endif %}
 
         {% if moderator %}
             <span class="moderator_info">
-                <a href="{% url 'admin:boards_post_change' post.id %}">{% trans 'Edit' %}</a>
+                | <a href="{% url 'admin:boards_post_change' post.id %}">{% trans 'Edit' %}</a>
                 {% if is_opening %}
                     | <a href="{% url 'admin:boards_thread_change' thread.id %}">{% trans 'Edit thread' %}</a>
                 {% endif %}
             </span>
         {% endif %}
     </div>
     {% comment %}
         Post images. Currently only 1 image can be posted and shown, but post model
         supports multiple.
     {%  endcomment %}
     {% if post.images.exists %}
-        {% with post.images.all.0 as image %}
-            {% autoescape off %}
-                {{ image.get_view }}
-            {% endautoescape %}
+        {% with post.images.first as image %}
+            {{ image.get_view|safe }}
+        {% endwith %}
+    {% endif %}
+    {% if post.attachments.exists %}
+        {% with post.attachments.first as file %}
+            {{ file.get_view|safe }}
         {% endwith %}
     {% endif %}
     {% comment %}
         Post message (text)
     {% endcomment %}
     <div class="message">
         {% autoescape off %}
             {% if truncated %}
                 {{ post.get_text|truncatewords_html:50 }}
             {% else %}
                 {{ post.get_text }}
             {% endif %}
         {% endautoescape %}
+    </div>
         {% if post.is_referenced %}
             {% if mode_tree %}
                 <div class="tree_reply">
                     {% for refpost in post.get_referenced_posts %}
                         {% post_view refpost mode_tree=True %}
                     {% endfor %}
                 </div>
             {% else %}
                 <div class="refmap">
-                    {% autoescape off %}
-                        {% trans "Replies" %}: {{ post.refmap }}
-                    {% endautoescape %}
+                {% trans "Replies" %}: {{ post.refmap|safe }}
                 </div>
             {% endif %}
         {% endif %}
-    </div>
     {% comment %}
         Thread metadata: counters, tags etc
     {% endcomment %}
     {% if is_opening %}
         <div class="metadata">
             {% if is_opening and need_open_link %}
                 {{ thread.get_reply_count }} {% trans 'messages' %},
                 {{ thread.get_images_count }} {% trans 'images' %}.
             {% endif %}
             <span class="tags">
-                {% autoescape off %}
-                    {{ thread.get_tag_url_list }}
-                {% endautoescape %}
+                {{ thread.get_tag_url_list|safe }}
             </span>
         </div>
     {% endif %}
 </div>

boards/templates/boards/settings.html

@@ -1,43 +1,40 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load tz %}
 
 {% block head %}
     <meta name="robots" content="noindex">
     <title>{% trans 'Settings' %} - {{ site_name }}</title>
 {% endblock %}
 
 {% block content %}
-
     <div class="post">
         <p>
             {% if moderator %}
                 {% trans 'You are moderator.' %}
             {% endif %}
         </p>
         {% if hidden_tags %}
             <p>{% trans 'Hidden tags:' %}
                 {% for tag in hidden_tags %}
-                    {% autoescape off %}
-                        {{ tag.get_view }}
-                    {% endautoescape %}
+                    {{ tag.get_view|safe }}
                 {% endfor %}
             </p>
         {% else %}
             <p>{% trans 'No hidden tags.' %}</p>
         {% endif %}
     </div>
 
     <div class="post-form-w">
     <div class="post-form">
         <form method="post">{% csrf_token %}
             {{ form.as_div }}
             <div class="form-submit">
                 <input type="submit" value="{% trans "Save" %}" />
             </div>
         </form>
     </div>
     </div>
 
 {% endblock %}

boards/templates/boards/tag.html

@@ -1,5 +1,3 b''
 <div class="post">
-    {% autoescape off %}
-        {{ tag.get_view }}
-    {% endautoescape %}
+    {{ tag.get_view|safe }}
 </div>

boards/templates/boards/tags.html

@@ -1,28 +1,47 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 
 {% block head %}
     <title>Neboard - {% trans "Tags" %}</title>
 {% endblock %}
 
 {% block content %}
 
+{% regroup section_tags by get_first_letter as section_tag_list %}
+{% regroup all_tags by get_first_letter as other_tag_list %}
+
 <div class="post">
-    {% if all_tags %}
-        {% for tag in all_tags %}
-            <div class="tag_item">
+    {% if section_tags %}
+        <div>
+        {% trans 'Sections:' %}
+        {% for letter in section_tag_list %}
+            <br />({{ letter.grouper|upper }})
+            {% for tag in letter.list %}
                 {% autoescape off %}
-                    {{ tag.get_view }}
+                    {{ tag.get_view }}{% if not forloop.last %},{% endif %}
                 {% endautoescape %}
-            </div>
+            {% endfor %}
         {% endfor %}
-    {% else %}
-        {% trans 'No tags found.' %}
+        </div>
     {% endif %}
+    {% if all_tags %}
+        <div>
+        {% trans 'Other tags:' %}
+        {% for letter in other_tag_list %}
+            <br />({{ letter.grouper|upper }})
+            {% for tag in letter.list %}
+                {% autoescape off %}
+                    {{ tag.get_view }}{% if not forloop.last %},{% endif %}
+                {% endautoescape %}
+            {% endfor %}
+        {% endfor %}
+        </div>
+    {% endif %}
+
     {% if query %}
-        <div><a href="{% url 'tags' %}">{% trans 'All tags' %}</a></div>
+        <div><a href="{% url 'tags' %}">{% trans 'All tags...' %}</a></div>
     {% endif %}
 </div>
 
 {% endblock %}

boards/templates/boards/thread.html

@@ -1,43 +1,40 b''
 {% extends "boards/base.html" %}
 
 {% load i18n %}
 {% load static from staticfiles %}
 {% load board %}
 {% load tz %}
 
 {% block head %}
     <title>{{ opening_post.get_title|striptags|truncatewords:10 }}
         - {{ site_name }}</title>
 {% endblock %}
 
 {% block content %}
     <div class="image-mode-tab">
         <a {% ifequal mode 'normal' %}class="current_mode"{% endifequal %} href="{% url 'thread' opening_post.id %}">{% trans 'Normal' %}</a>,
         <a {% ifequal mode 'gallery' %}class="current_mode"{% endifequal %} href="{% url 'thread_gallery' opening_post.id %}">{% trans 'Gallery' %}</a>,
         <a {% ifequal mode 'tree' %}class="current_mode"{% endifequal %} href="{% url 'thread_tree' opening_post.id %}">{% trans 'Tree' %}</a>
     </div>
 
     {% block thread_content %}
     {% endblock %}
 {% endblock %}
 
 {% block metapanel %}
 
     <span class="metapanel"
           data-last-update="{{ last_update }}"
           data-ws-token-time="{{ ws_token_time }}"
           data-ws-token="{{ ws_token }}"
           data-ws-project="{{ ws_project }}"
           data-ws-host="{{ ws_host }}"
           data-ws-port="{{ ws_port }}">
 
-        {% block thread_meta_panel %}
-        {% endblock %}
-
         <span id="reply-count">{{ thread.get_reply_count }}</span>{% if thread.has_post_limit %}/{{ thread.max_posts }}{% endif %} {% trans 'messages' %},
             <span id="image-count">{{ thread.get_images_count }}</span> {% trans 'images' %}.
             {% trans 'Last update: ' %}<span id="last-update"><time datetime="{{ thread.last_edit_time|date:'c' }}">{{ thread.last_edit_time }}</time></span>
             [<a href="rss/">RSS</a>]
     </span>
 
 {% endblock %}

boards/templates/boards/thread_normal.html

@@ -1,61 +1,57 b''
 {% extends "boards/thread.html" %}
 
 {% load i18n %}
 {% load static from staticfiles %}
 {% load board %}
 {% load tz %}
 
 {% block thread_content %}
     {% get_current_language as LANGUAGE_CODE %}
     {% get_current_timezone as TIME_ZONE %}
 
     {% if bumpable and thread.has_post_limit %}
         <div class="bar-bg">
             <div class="bar-value" style="width:{{ bumplimit_progress }}%" id="bumplimit_progress">
             </div>
             <div class="bar-text">
                 <span id="left_to_limit">{{ posts_left }}</span> {% trans 'posts to bumplimit' %}
             </div>
         </div>
     {% endif %}
 
     <div class="thread">
         {% for post in thread.get_replies %}
             {% post_view post moderator=moderator reply_link=True %}
         {% endfor %}
     </div>
 
     {% if not thread.archived %}
         <div class="post-form-w">
             <script src="{% static 'js/panel.js' %}"></script>
-            <div class="form-title">{% trans "Reply to thread" %} #{{ opening_post.id }}</div>
+            <div class="form-title">{% trans "Reply to thread" %} #{{ opening_post.id }}<span class="reply-to-message"> {% trans "to message " %} #<span id="reply-to-message-id"></span></span></div>
             <div class="post-form" id="compact-form">
                 <div class="swappable-form-full">
                     <form enctype="multipart/form-data" method="post" id="form">{% csrf_token %}
                         <div class="compact-form-text"></div>
                         {{ form.as_div }}
                         <div class="form-submit">
                             <input type="submit" value="{% trans "Post" %}"/>
+                            <button id="preview-button" onclick="return false;">{% trans 'Preview' %}</button>
                         </div>
                     </form>
                 </div>
-                <div><button id="preview-button">{% trans 'Preview' %}</button></div>
                 <div id="preview-text"></div>
                 <div><a href="{% url "staticpage" name="help" %}">
                     {% trans 'Text syntax' %}</a></div>
                 <div><a id="form-close-button" href="#" onClick="resetFormPosition(); return false;">{% trans 'Close form' %}</a></div>
             </div>
         </div>
 
         <script src="{% static 'js/jquery.form.min.js' %}"></script>
     {% endif %}
 
     <script src="{% static 'js/form.js' %}"></script>
     <script src="{% static 'js/thread.js' %}"></script>
     <script src="{% static 'js/thread_update.js' %}"></script>
     <script src="{% static 'js/3party/centrifuge.js' %}"></script>
 {% endblock %}
-
-{% block thread_meta_panel %}
-    <button id="autoupdate">{% trans 'Update' %}</button>
-{% endblock %}

boards/urls.py

@@ -1,88 +1,91 b''
 from django.conf.urls import patterns, url
 from django.views.i18n import javascript_catalog
 
 from boards import views
 from boards.rss import AllThreadsFeed, TagThreadsFeed, ThreadPostsFeed
 from boards.views import api, tag_threads, all_threads, \
     settings, all_tags, feed
 from boards.views.authors import AuthorsView
 from boards.views.notifications import NotificationView
 from boards.views.search import BoardSearchView
 from boards.views.static import StaticPageView
 from boards.views.preview import PostPreviewView
 from boards.views.sync import get_post_sync_data, response_get
+from boards.views.random import RandomImageView
 
 
 js_info_dict = {
     'packages': ('boards',),
 }
 
 urlpatterns = patterns('',
     # /boards/
     url(r'^$', all_threads.AllThreadsView.as_view(), name='index'),
 
     # /boards/tag/tag_name/
     url(r'^tag/(?P<tag_name>\w+)/$', tag_threads.TagView.as_view(),
         name='tag'),
 
     # /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'^tags/(?P<query>\w+)?/?$', all_tags.AllTagsView.as_view(), name='tags'),
     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'),
+
     # RSS feeds
     url(r'^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/$', javascript_catalog, js_info_dict,
         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'),
 
     # Sync protocol API
     url(r'^api/sync/pull/$', api.sync_pull, name='api_sync_pull'),
     url(r'^api/sync/get/$', response_get, name='api_sync_pull'),
     # TODO 'get' request
 
     # Search
     url(r'^search/$', BoardSearchView.as_view(), name='search'),
 
     # Notifications
     url(r'^notifications/(?P<username>\w+)$', 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/utils.py

@@ -1,84 +1,92 b''
 """
 This module contains helper functions and helper classes.
 """
+import hashlib
 import time
 import hmac
 
 from django.core.cache import cache
 from django.db.models import Model
 
 from django.utils import timezone
 
 from neboard import settings
 
 
 CACHE_KEY_DELIMITER = '_'
 PERMISSION_MODERATE = 'moderation'
 
 def get_client_ip(request):
     x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
     if x_forwarded_for:
         ip = x_forwarded_for.split(',')[-1].strip()
     else:
         ip = request.META.get('REMOTE_ADDR')
     return ip
 
 
 # TODO The output format is not epoch because it includes microseconds
 def datetime_to_epoch(datetime):
     return int(time.mktime(timezone.localtime(
         datetime,timezone.get_current_timezone()).timetuple())
                * 1000000 + datetime.microsecond)
 
 
 def get_websocket_token(user_id='', timestamp=''):
     """
     Create token to validate information provided by new connection.
     """
 
     sign = hmac.new(settings.CENTRIFUGE_PROJECT_SECRET.encode())
     sign.update(settings.CENTRIFUGE_PROJECT_ID.encode())
     sign.update(user_id.encode())
     sign.update(timestamp.encode())
     token = sign.hexdigest()
 
     return token
 
 
 def cached_result(key_method=None):
     """
     Caches method result in the Django's cache system, persisted by object name,
     object name and model id if object is a Django model.
     """
     def _cached_result(function):
         def inner_func(obj, *args, **kwargs):
             # TODO Include method arguments to the cache key
             cache_key_params = [obj.__class__.__name__, function.__name__]
             if isinstance(obj, Model):
                 cache_key_params.append(str(obj.id))
 
             if key_method is not None:
                 cache_key_params += [str(arg) for arg in key_method(obj)]
 
             cache_key = CACHE_KEY_DELIMITER.join(cache_key_params)
 
             persisted_result = cache.get(cache_key)
             if persisted_result is not None:
                 result = persisted_result
             else:
                 result = function(obj, *args, **kwargs)
                 cache.set(cache_key, result)
 
             return result
 
         return inner_func
     return _cached_result
 
 
 def is_moderator(request):
     try:
         moderate = request.user.has_perm(PERMISSION_MODERATE)
     except AttributeError:
         moderate = False
 
-    return moderate
  No newline at end of file
+    return moderate
+
+
+def get_file_hash(file) -> str:
+    md5 = hashlib.md5()
+    for chunk in file.chunks():
+        md5.update(chunk)
+    return md5.hexdigest()

boards/views/all_tags.py

@@ -1,22 +1,23 b''
 from django.shortcuts import render
 
 from boards.views.base import BaseBoardView
 from boards.models.tag import Tag
 
 
+PARAM_SECTION_TAGS = 'section_tags'
 PARAM_TAGS = 'all_tags'
 PARAM_QUERY = 'query'
 
 
 class AllTagsView(BaseBoardView):
 
     def get(self, request, query=None):
         params = dict()
 
-        if query == 'required':
-            params[PARAM_TAGS] = Tag.objects.filter(required=True)
-        else:
-            params[PARAM_TAGS] = Tag.objects.get_not_empty_tags()
+        params[PARAM_SECTION_TAGS] = Tag.objects.filter(required=True)
+        if query != 'required':
+            params[PARAM_TAGS] = Tag.objects.get_not_empty_tags().filter(
+                    required=False)
         params[PARAM_QUERY] = query
 
         return render(request, 'boards/tags.html', params)

boards/views/all_threads.py

@@ -1,169 +1,170 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
 import requests
 
 from boards import utils, settings
 from boards.abstracts.paginator import get_paginator
 from boards.abstracts.settingsmanager import get_settings_manager
 from boards.forms import ThreadForm, PlainErrorList
 from boards.models import Post, Thread, Ban, Tag, PostImage, Banner
 from boards.views.banned import BannedView
 from boards.views.base import BaseBoardView, CONTEXT_FORM
 from boards.views.posting_mixin import PostMixin
 
 
 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_BANNERS = 'banners'
 
 PARAMETER_PREV_LINK = 'prev_page_link'
 PARAMETER_NEXT_LINK = 'next_page_link'
 
 TEMPLATE = 'boards/all_threads.html'
 DEFAULT_PAGE = 1
 
 
 class AllThreadsView(PostMixin, BaseBoardView):
 
     def __init__(self):
         self.settings_manager = None
         super(AllThreadsView, self).__init__()
 
     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)
 
         self.settings_manager = get_settings_manager(request)
         paginator = get_paginator(self.get_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_BANNERS] = Banner.objects.order_by('-id').all()
 
         self.get_page_context(paginator, params, page)
 
         return render(request, TEMPLATE, params)
 
     def post(self, request):
         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_page_context(self, paginator, params, page):
         """
         Get pagination context variables
         """
 
         params[PARAMETER_PAGINATOR] = paginator
         current_page = paginator.page(int(page))
         params[PARAMETER_CURRENT_PAGE] = current_page
         if current_page.has_previous():
             params[PARAMETER_PREV_LINK] = self.get_previous_page_link(
                     current_page)
         if current_page.has_next():
             params[PARAMETER_NEXT_LINK] = self.get_next_page_link(current_page)
 
     def get_previous_page_link(self, current_page):
         return reverse('index') + '?page=' \
                 + str(current_page.previous_page_number())
 
     def get_next_page_link(self, current_page):
         return reverse('index') + '?page=' \
                 + str(current_page.next_page_number())
 
     @staticmethod
     def parse_tags_string(tag_strings):
         """
         Parses tag list string and returns tag object list.
         """
 
         tags = []
 
         if tag_strings:
             tag_strings = tag_strings.split(TAG_DELIMITER)
             for tag_name in tag_strings:
                 tag_name = tag_name.strip().lower()
                 if len(tag_name) > 0:
                     tag, created = Tag.objects.get_or_create(name=tag_name)
                     tags.append(tag)
 
         return tags
 
     @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 = data[FORM_TITLE]
+        title = form.get_title()
         text = data[FORM_TEXT]
-        image = form.get_image()
+        file = form.get_file()
         threads = data[FORM_THREADS]
 
         text = self._remove_invalid_links(text)
 
         tag_strings = data[FORM_TAGS]
 
         tags = self.parse_tags_string(tag_strings)
 
-        post = Post.objects.create_post(title=title, text=text, image=image,
-                                        ip=ip, tags=tags, opening_posts=threads)
+        post = Post.objects.create_post(title=title, text=text, file=file,
+                                        ip=ip, tags=tags, opening_posts=threads,
+                                        tripcode=form.get_tripcode())
 
         # This is required to update the threads to which posts we have replied
         # when creating this one
         post.notify_clients()
 
         if html_response:
             return redirect(post.get_absolute_url())
 
     def get_threads(self):
         """
         Gets list of threads that will be shown on a page.
         """
 
         return Thread.objects.order_by('-bump_time')\
             .exclude(tags__in=self.settings_manager.get_hidden_tags())

boards/views/feed.py

@@ -1,71 +1,81 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
-import requests
+from django.shortcuts import render
 
-from boards import utils, settings
 from boards.abstracts.paginator import get_paginator
 from boards.abstracts.settingsmanager import get_settings_manager
-from boards.models import Post, Thread, Ban, Tag, PostImage, Banner
+from boards.models import Post
 from boards.views.base import BaseBoardView
 from boards.views.posting_mixin import PostMixin
 
+POSTS_PER_PAGE = 10
 
 PARAMETER_CURRENT_PAGE = 'current_page'
 PARAMETER_PAGINATOR = 'paginator'
 PARAMETER_POSTS = 'posts'
+PARAMETER_ADDITONAL_ATTRS = 'additional_attrs'
 
 PARAMETER_PREV_LINK = 'prev_page_link'
 PARAMETER_NEXT_LINK = 'next_page_link'
 
 TEMPLATE = 'boards/feed.html'
 DEFAULT_PAGE = 1
 
 
 class FeedView(PostMixin, BaseBoardView):
 
     def get(self, request):
         page = request.GET.get('page', DEFAULT_PAGE)
+        tripcode = request.GET.get('tripcode', None)
 
         params = self.get_context_data(request=request)
 
         settings_manager = get_settings_manager(request)
 
-        paginator = get_paginator(Post.objects
-                .exclude(threads__tags__in=settings_manager.get_hidden_tags())
-                .order_by('-pub_time')
-                .prefetch_related('images', 'thread', 'threads'), 10)
+        posts = Post.objects.exclude(
+            threads__tags__in=settings_manager.get_hidden_tags()).order_by(
+            '-pub_time').prefetch_related('images', 'thread', 'threads')
+        if tripcode:
+            posts = posts.filter(tripcode=tripcode)
+
+        paginator = get_paginator(posts, POSTS_PER_PAGE)
         paginator.current_page = int(page)
 
         params[PARAMETER_POSTS] = paginator.page(page).object_list
 
-        self.get_page_context(paginator, params, page)
+        additional_params = dict()
+        if tripcode:
+            additional_params['tripcode'] = tripcode
+            params[PARAMETER_ADDITONAL_ATTRS] = '&tripcode=' + tripcode
+
+        self.get_page_context(paginator, params, page, additional_params)
 
         return render(request, TEMPLATE, params)
 
     # TODO Dedup this into PagedMixin
-    def get_page_context(self, paginator, params, page):
+    def get_page_context(self, paginator, params, page, additional_params):
         """
         Get pagination context variables
         """
 
         params[PARAMETER_PAGINATOR] = paginator
         current_page = paginator.page(int(page))
         params[PARAMETER_CURRENT_PAGE] = current_page
         if current_page.has_previous():
             params[PARAMETER_PREV_LINK] = self.get_previous_page_link(
                     current_page)
+            for param in additional_params.keys():
+                params[PARAMETER_PREV_LINK] += '&{}={}'.format(
+                    param, additional_params[param])
         if current_page.has_next():
             params[PARAMETER_NEXT_LINK] = self.get_next_page_link(current_page)
+            for param in additional_params.keys():
+                params[PARAMETER_NEXT_LINK] += '&{}={}'.format(
+                    param, additional_params[param])
 
     def get_previous_page_link(self, current_page):
         return reverse('feed') + '?page={}'.format(
                 current_page.previous_page_number())
 
     def get_next_page_link(self, current_page):
         return reverse('feed') + '?page={}'.format(
                 current_page.next_page_number())

boards/views/settings.py

@@ -1,77 +1,76 b''
 from django.db import transaction
 from django.shortcuts import render, redirect
 from django.utils import timezone
 
 from boards.abstracts.settingsmanager import get_settings_manager, \
     SETTING_USERNAME, SETTING_LAST_NOTIFICATION_ID, SETTING_IMAGE_VIEWER
 from boards.middlewares import SESSION_TIMEZONE
 from boards.views.base import BaseBoardView, CONTEXT_FORM
 from boards.forms import SettingsForm, PlainErrorList
 from boards import settings
 
-
 FORM_THEME = 'theme'
 FORM_USERNAME = 'username'
 FORM_TIMEZONE = 'timezone'
 FORM_IMAGE_VIEWER = 'image_viewer'
 
 CONTEXT_HIDDEN_TAGS = 'hidden_tags'
 
 TEMPLATE = 'boards/settings.html'
 
 
 class SettingsView(BaseBoardView):
 
     def get(self, request):
         params = dict()
         settings_manager = get_settings_manager(request)
 
         selected_theme = settings_manager.get_theme()
 
         form = SettingsForm(
             initial={
                 FORM_THEME: selected_theme,
                 FORM_IMAGE_VIEWER: settings_manager.get_setting(
                     SETTING_IMAGE_VIEWER,
                     default=settings.get('View', 'DefaultImageViewer')),
                 FORM_USERNAME: settings_manager.get_setting(SETTING_USERNAME),
                 FORM_TIMEZONE: request.session.get(
                     SESSION_TIMEZONE, timezone.get_current_timezone()),
             },
             error_class=PlainErrorList)
 
         params[CONTEXT_FORM] = form
         params[CONTEXT_HIDDEN_TAGS] = settings_manager.get_hidden_tags()
 
         return render(request, TEMPLATE, params)
 
     def post(self, request):
         settings_manager = get_settings_manager(request)
 
         with transaction.atomic():
             form = SettingsForm(request.POST, error_class=PlainErrorList)
 
             if form.is_valid():
                 selected_theme = form.cleaned_data[FORM_THEME]
                 username = form.cleaned_data[FORM_USERNAME].lower()
 
                 settings_manager.set_theme(selected_theme)
                 settings_manager.set_setting(SETTING_IMAGE_VIEWER,
                                              form.cleaned_data[FORM_IMAGE_VIEWER])
 
                 old_username = settings_manager.get_setting(SETTING_USERNAME)
                 if username != old_username:
                     settings_manager.set_setting(SETTING_USERNAME, username)
                     settings_manager.set_setting(SETTING_LAST_NOTIFICATION_ID, None)
 
                 request.session[SESSION_TIMEZONE] = form.cleaned_data[FORM_TIMEZONE]
 
                 return redirect('settings')
             else:
                 params = dict()
 
                 params[CONTEXT_FORM] = form
                 params[CONTEXT_HIDDEN_TAGS] = settings_manager.get_hidden_tags()
 
                 return render(request, TEMPLATE, params)
 

boards/views/tag_threads.py

@@ -1,120 +1,126 b''
 from django.shortcuts import get_object_or_404, redirect
 from django.core.urlresolvers import reverse
 
 from boards.abstracts.settingsmanager import get_settings_manager, \
         SETTING_FAVORITE_TAGS, SETTING_HIDDEN_TAGS
-from boards.models import Tag
+from boards.models import Tag, PostImage
 from boards.views.all_threads import AllThreadsView, DEFAULT_PAGE
 from boards.views.mixins import DispatcherMixin
 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 = get_object_or_404(Tag, name=self.tag_name)
 
         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 = get_object_or_404(Tag, name=self.tag_name)
         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.name in fav_tag_names
         params[PARAM_IS_HIDDEN] = hidden_tag_names is not None and tag.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_previous_page_link(self, current_page):
         return reverse('tag', kwargs={
             'tag_name': self.tag_name,
         }) + '?page=' + str(current_page.previous_page_number())
 
     def get_next_page_link(self, current_page):
         return reverse('tag', kwargs={
             'tag_name': self.tag_name,
         }) + '?page=' + str(current_page.next_page_number())
 
     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 'method' in request.POST:
             self.dispatch_method(request)
             form = None
 
             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, page, form)
+            return self.get(request, tag_name, form)
 
     def subscribe(self, request):
         tag = get_object_or_404(Tag, name=self.tag_name)
 
         settings_manager = get_settings_manager(request)
         settings_manager.add_fav_tag(tag)
 
     def unsubscribe(self, request):
         tag = get_object_or_404(Tag, name=self.tag_name)
 
         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.
         """
 
         tag = get_object_or_404(Tag, name=self.tag_name)
 
         settings_manager = get_settings_manager(request)
         settings_manager.add_hidden_tag(tag)
 
     def unhide(self, request):
         """
         Removed tag from user's hidden tags.
         """
 
         tag = get_object_or_404(Tag, name=self.tag_name)
 
         settings_manager = get_settings_manager(request)
         settings_manager.del_hidden_tag(tag)

boards/views/thread/thread.py

@@ -1,138 +1,140 b''
+import hashlib
 from django.core.exceptions import ObjectDoesNotExist
 from django.http import Http404
 from django.shortcuts import get_object_or_404, render, redirect
 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.forms import PostForm, PlainErrorList
 from boards.models import Post
 from boards.views.base import BaseBoardView, CONTEXT_FORM
 from boards.views.posting_mixin import PostMixin
 
 import neboard
 
 
 CONTEXT_LASTUPDATE = "last_update"
 CONTEXT_THREAD = 'thread'
 CONTEXT_WS_TOKEN = 'ws_token'
 CONTEXT_WS_PROJECT = 'ws_project'
 CONTEXT_WS_HOST = 'ws_host'
 CONTEXT_WS_PORT = 'ws_port'
 CONTEXT_WS_TIME = 'ws_token_time'
 CONTEXT_MODE = 'mode'
 CONTEXT_OP = 'opening_post'
 
 FORM_TITLE = 'title'
 FORM_TEXT = 'text'
 FORM_IMAGE = 'image'
 FORM_THREADS = 'threads'
 
 
 class ThreadView(BaseBoardView, PostMixin, FormMixin):
 
     def get(self, request, post_id, form: PostForm=None):
         try:
             opening_post = Post.objects.get(id=post_id)
         except ObjectDoesNotExist:
             raise Http404
 
         # If this is not OP, don't show it as it is
         if not opening_post.is_opening():
             return redirect(opening_post.get_thread().get_opening_post()
                 .get_absolute_url())
 
         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
 
         if settings.get_bool('External', 'WebsocketsEnabled'):
             token_time = format(timezone.now(), u'U')
 
             params[CONTEXT_WS_TIME] = token_time
             params[CONTEXT_WS_TOKEN] = utils.get_websocket_token(
                 timestamp=token_time)
             params[CONTEXT_WS_PROJECT] = neboard.settings.CENTRIFUGE_PROJECT_ID
             params[CONTEXT_WS_HOST] = request.get_host().split(':')[0]
             params[CONTEXT_WS_PORT] = neboard.settings.CENTRIFUGE_PORT
 
         params.update(self.get_data(thread_to_show))
 
         return render(request, self.get_template(), params)
 
     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 not opening_post.get_thread().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 = data[FORM_TITLE]
+        title = form.get_title()
         text = data[FORM_TEXT]
-        image = form.get_image()
+        file = form.get_file()
         threads = data[FORM_THREADS]
 
         text = self._remove_invalid_links(text)
 
         post_thread = opening_post.get_thread()
 
-        post = Post.objects.create_post(title=title, text=text, image=image,
+        post = Post.objects.create_post(title=title, text=text, file=file,
                                         thread=post_thread, ip=ip,
-                                        opening_posts=threads)
+                                        opening_posts=threads,
+                                        tripcode=form.get_tripcode())
         post.notify_clients()
 
         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