Added image aliases to upload the same images (like "fake" or "gtfo")

boards/abstracts/attachment_alias.py

@@ -0,0 +1,27 b''
+from boards.abstracts.settingsmanager import SessionSettingsManager
+from boards.models import PostImage
+
+class AttachmentAlias:
+    def get_image(alias):
+        pass
+
+
+class SessionAttachmentAlias(AttachmentAlias):
+    def __init__(self, session):
+        self.session = session
+
+    def get_image(self, alias):
+        settings_manager = SessionSettingsManager(self.session)
+        return settings_manager.get_image_by_alias(alias)
+
+
+class ModelAttachmentAlias(AttachmentAlias):
+    def get_image(self, alias):
+        return PostImage.objects.filter(alias=alias).first()
+
+
+def get_image_by_alias(alias, session):
+    image = SessionAttachmentAlias(session).get_image(alias) or ModelAttachmentAlias().get_image(alias)
+
+    if image is not None:
+        return image

boards/migrations/0041_auto_20160124_2341.py

@@ -0,0 +1,24 b''
+# -*- coding: utf-8 -*-
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boards', '0040_thread_monochrome'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='attachment',
+            name='original_filename',
+            field=models.TextField(null=True),
+        ),
+        migrations.AddField(
+            model_name='postimage',
+            name='original_filename',
+            field=models.TextField(null=True),
+        ),
+    ]

boards/migrations/0042_auto_20160422_1053.py

@@ -0,0 +1,28 b''
+# -*- coding: utf-8 -*-
+# Generated by Django 1.9.5 on 2016-04-22 07:53
+from __future__ import unicode_literals
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('boards', '0041_auto_20160124_2341'),
+    ]
+
+    operations = [
+        migrations.RemoveField(
+            model_name='attachment',
+            name='original_filename',
+        ),
+        migrations.RemoveField(
+            model_name='postimage',
+            name='original_filename',
+        ),
+        migrations.AddField(
+            model_name='postimage',
+            name='alias',
+            field=models.TextField(blank=True, null=True, unique=True),
+        ),
+    ]

boards/abstracts/settingsmanager.py

@@ -1,183 +1,195 b''
 from boards.models import Tag
 from boards.models.thread import FAV_THREAD_NO_UPDATES
 
 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_FAVORITE_THREADS = 'favorite_threads'
 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'
+SETTING_IMAGES = 'images_aliases'
 
 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)
 
     def get_fav_threads(self) -> dict:
         return self.get_setting(SETTING_FAVORITE_THREADS, default=dict())
 
     def add_or_read_fav_thread(self, opening_post):
         threads = self.get_fav_threads()
         thread = opening_post.get_thread()
         # Don't check for new posts if the thread is archived already
         if thread.is_archived():
             last_id = FAV_THREAD_NO_UPDATES
         else:
             last_id = thread.get_replies().last().id
         threads[str(opening_post.id)] = last_id
         self.set_setting(SETTING_FAVORITE_THREADS, threads)
 
     def del_fav_thread(self, opening_post):
         threads = self.get_fav_threads()
         if self.thread_is_fav(opening_post):
             del threads[str(opening_post.id)]
             self.set_setting(SETTING_FAVORITE_THREADS, threads)
 
     def thread_is_fav(self, opening_post):
         return str(opening_post.id) in self.get_fav_threads()
 
     def get_notification_usernames(self):
         names = set()
         name_list = self.get_setting(SETTING_USERNAME)
         if name_list is not None:
             name_list = name_list.strip()
             if len(name_list) > 0:
                 names = name_list.lower().split(',')
                 names = set(name.strip() for name in names)
         return names
 
+    def get_image_by_alias(self, alias):
+        images = self.get_setting(SETTING_IMAGES)
+        if images is not None and len(images) > 0:
+            return images.get(alias)
+
+    def add_image_alias(self, alias, image):
+        images = self.get_setting(SETTING_IMAGES)
+        if images is None:
+            images = dict()
+        images.put(alias, image)
+
 
 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/admin.py

@@ -1,99 +1,111 b''
 from django.contrib import admin
-from boards.models import Post, Tag, Ban, Thread, Banner
 from django.utils.translation import ugettext_lazy as _
+from django.core.urlresolvers import reverse
+from boards.models import Post, Tag, Ban, Thread, Banner, PostImage
 
 
 @admin.register(Post)
 class PostAdmin(admin.ModelAdmin):
 
-    list_display = ('id', 'title', 'text', 'poster_ip')
+    list_display = ('id', 'title', 'text', 'poster_ip', 'linked_images')
     list_filter = ('pub_time',)
     search_fields = ('id', 'title', 'text', 'poster_ip')
     exclude = ('referenced_posts', 'refmap')
-    readonly_fields = ('poster_ip', 'threads', 'thread', 'images',
+    readonly_fields = ('poster_ip', 'threads', 'thread', 'linked_images',
             'attachments', 'uid', 'url', 'pub_time', 'opening')
 
     def ban_poster(self, request, queryset):
         bans = 0
         for post in queryset:
             poster_ip = post.poster_ip
             ban, created = Ban.objects.get_or_create(ip=poster_ip)
             if created:
                 bans += 1
         self.message_user(request, _('{} posters were banned').format(bans))
 
     def ban_with_hiding(self, request, queryset):
         bans = 0
         hidden = 0
         for post in queryset:
             poster_ip = post.poster_ip
             ban, created = Ban.objects.get_or_create(ip=poster_ip)
             if created:
                 bans += 1
             posts = Post.objects.filter(poster_ip=poster_ip, id__gte=post.id)
             hidden += posts.count()
             posts.update(hidden=True)
         self.message_user(request, _('{} posters were banned, {} messages were hidden').format(bans, hidden))
 
+    def linked_images(self, obj: Post):
+        images = obj.images.all()
+        image_urls = ['<a href="{}">{}</a>'.format(reverse('admin:%s_%s_change' %(image._meta.app_label,  image._meta.model_name),  args=[image.id]), image.hash) for image in images]
+        return ', '.join(image_urls)
+    linked_images.allow_tags = True
+
 
     actions = ['ban_poster', 'ban_with_hiding']
 
 
 @admin.register(Tag)
 class TagAdmin(admin.ModelAdmin):
 
     def thread_count(self, obj: Tag) -> int:
         return obj.get_thread_count()
 
     def display_children(self, obj: Tag):
         return ', '.join([str(child) for child in obj.get_children().all()])
 
     def save_model(self, request, obj, form, change):
         super().save_model(request, obj, form, change)
         for thread in obj.get_threads().all():
             thread.refresh_tags()
 
     list_display = ('name', 'thread_count', 'display_children')
     search_fields = ('name',)
 
 
 @admin.register(Thread)
 class ThreadAdmin(admin.ModelAdmin):
 
     def title(self, obj: Thread) -> str:
         return obj.get_opening_post().get_title()
 
     def reply_count(self, obj: Thread) -> int:
         return obj.get_reply_count()
 
     def ip(self, obj: Thread):
         return obj.get_opening_post().poster_ip
 
     def display_tags(self, obj: Thread):
         return ', '.join([str(tag) for tag in obj.get_tags().all()])
 
     def op(self, obj: Thread):
         return obj.get_opening_post_id()
 
     # Save parent tags when editing tags
     def save_related(self, request, form, formsets, change):
         super().save_related(request, form, formsets, change)
         form.instance.refresh_tags()
 
     list_display = ('id', 'op', 'title', 'reply_count', 'status', 'ip',
             'display_tags')
     list_filter = ('bump_time', 'status')
     search_fields = ('id', 'title')
     filter_horizontal = ('tags',)
 
 
 @admin.register(Ban)
 class BanAdmin(admin.ModelAdmin):
     list_display = ('ip', 'can_read')
     list_filter = ('can_read',)
     search_fields = ('ip',)
 
 
 @admin.register(Banner)
 class BannerAdmin(admin.ModelAdmin):
     list_display = ('title', 'text')
+
+
[e-mail](PostImage)
+class PostImageAdmin(admin.ModelAdmin):
+    search_fields = ('alias',)

boards/forms.py

@@ -1,453 +1,469 b''
 import hashlib
 import re
 import time
 import logging
 
 import pytz
 
 from django import forms
 from django.core.files.uploadedfile import SimpleUploadedFile
 from django.core.exceptions import ObjectDoesNotExist
 from django.forms.utils import ErrorList
 from django.utils.translation import ugettext_lazy as _, ungettext_lazy
 from django.utils import timezone
 
 from boards.abstracts.settingsmanager import get_settings_manager
+from boards.abstracts.attachment_alias import get_image_by_alias
 from boards.mdx_neboard import formatters
 from boards.models.attachment.downloaders import Downloader
 from boards.models.post import TITLE_MAX_LENGTH
 from boards.models import Tag, Post
 from boards.utils import validate_file_size, get_file_mimetype, \
     FILE_EXTENSION_DELIMITER
 from neboard import settings
 import boards.settings as board_settings
 import neboard
 
 POW_HASH_LENGTH = 16
 POW_LIFE_MINUTES = 5
 
 REGEX_TAGS = re.compile(r'^[\w\s\d]+$', re.UNICODE)
 REGEX_USERNAMES = 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 %(delay)d second before sending message'
 ERROR_SPEED_PLURAL = 'Please wait %(delay)d seconds before sending message'
 
 TAG_MAX_LENGTH = 20
 
 TEXTAREA_ROWS = 4
 
 TRIPCODE_DELIM = '#'
 
 # TODO Maybe this may be converted into the database table?
 MIMETYPE_EXTENSIONS = {
     'image/jpeg': 'jpeg',
     'image/png': 'png',
     'image/gif': 'gif',
     'video/webm': 'webm',
     'application/pdf': 'pdf',
     'x-diff': 'diff',
     'image/svg+xml': 'svg',
     'application/x-shockwave-flash': 'swf',
     'image/x-ms-bmp': 'bmp',
     'image/bmp': 'bmp',
 }
 
 
 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=attrs)
 
         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,
                             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)
     file = forms.FileField(required=False, label=_('File'),
                              widget=forms.ClearableFileInput(
                                  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'}))
 
     guess = forms.CharField(widget=forms.HiddenInput(), required=False)
     timestamp = forms.CharField(widget=forms.HiddenInput(), required=False)
     iteration = forms.CharField(widget=forms.HiddenInput(), required=False)
 
     session = None
     need_to_ban = False
+    image = None
 
     def _update_file_extension(self, file):
         if file:
             mimetype = get_file_mimetype(file)
             extension = MIMETYPE_EXTENSIONS.get(mimetype)
             if extension:
                 filename = file.name.split(FILE_EXTENSION_DELIMITER, 1)[0]
                 new_filename = filename + FILE_EXTENSION_DELIMITER + extension
 
                 file.name = new_filename
             else:
                 logger = logging.getLogger('boards.forms.extension')
 
                 logger.info('Unrecognized file mimetype: {}'.format(mimetype))
 
     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_file(self):
         file = self.cleaned_data['file']
 
         if file:
             validate_file_size(file.size)
         self._update_file_extension(file)
 
         return file
 
     def clean_file_url(self):
         url = self.cleaned_data['file_url']
 
         file = None
+
         if url:
-            file = self._get_file_from_url(url)
+            file = get_image_by_alias(url, self.session)
+            self.image = file
 
-            if not file:
-                raise forms.ValidationError(_('Invalid URL'))
-            else:
-                validate_file_size(file.size)
+            if file is not None:
+                return
+
+            if file is None:
+                file = self._get_file_from_url(url)
+                if not file:
+                    raise forms.ValidationError(_('Invalid URL'))
+                else:
+                    validate_file_size(file.size)
         self._update_file_extension(file)
 
         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().is_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_file()
 
         limit_speed = board_settings.get_bool('Forms', 'LimitPostingSpeed')
 
         settings_manager = get_settings_manager(self)
         if not self.errors and limit_speed and not settings_manager.get_setting('confirmed_user'):
             pow_difficulty = board_settings.get_int('Forms', 'PowDifficulty')
             if pow_difficulty > 0:
                 # Limit only first post
                 if cleaned_data['timestamp'] \
                         and cleaned_data['iteration'] and cleaned_data['guess'] \
                         and not settings_manager.get_setting('confirmed_user'):
                     self._validate_hash(cleaned_data['timestamp'], cleaned_data['iteration'], cleaned_data['guess'], cleaned_data['text'])
             else:
                 # Limit every post
                 self._validate_posting_speed()
             settings_manager.set_setting('confirmed_user', True)
 
 
         return cleaned_data
 
     def get_file(self):
         """
         Gets file from form or 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 TRIPCODE_DELIM in title:
             code = title.split(TRIPCODE_DELIM, maxsplit=1)[1] + neboard.settings.SECRET_KEY
             tripcode = hashlib.md5(code.encode()).hexdigest()
         else:
             tripcode = ''
         return tripcode
 
     def get_title(self):
         title = self.cleaned_data['title']
         if title is not None and TRIPCODE_DELIM in title:
             return title.split(TRIPCODE_DELIM, maxsplit=1)[0]
         else:
             return title
 
+    def get_images(self):
+        if self.image:
+            return [self.image]
+        else:
+            return []
+
     def _clean_text_file(self):
         text = self.cleaned_data.get('text')
         file = self.get_file()
+        images = self.get_images()
 
-        if (not text) and (not file):
+        if (not text) and (not file) and len(images) == 0:
             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
 
             if LAST_POST_TIME not 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:
                 delay = posting_delay - current_delay
                 error_message = ungettext_lazy(ERROR_SPEED, ERROR_SPEED_PLURAL,
                                                delay) % {'delay': delay}
                 self._errors['text'] = self.error_class([error_message])
 
                 can_post = False
 
             if can_post:
                 self.session[LAST_POST_TIME] = now
 
     def _get_file_from_url(self, url: str) -> SimpleUploadedFile:
         """
         Gets an file file from URL.
         """
 
         img_temp = None
 
         try:
             for downloader in Downloader.__subclasses__():
                 if downloader.handles(url):
                     return downloader.download(url)
             # If nobody of the specific downloaders handles this, use generic
             # one
             return Downloader.download(url)
         except forms.ValidationError as e:
             raise e
         except Exception as e:
             raise forms.ValidationError(e)
 
     def _validate_hash(self, timestamp: str, iteration: str, guess: str, message: str):
         post_time = timezone.datetime.fromtimestamp(
             int(timestamp[:-3]), tz=timezone.get_current_timezone())
 
         payload = timestamp + message.replace('\r\n', '\n')
         difficulty = board_settings.get_int('Forms', 'PowDifficulty')
         target = str(int(2 ** (POW_HASH_LENGTH * 3) / difficulty))
         if len(target) < POW_HASH_LENGTH:
             target = '0' * (POW_HASH_LENGTH - len(target)) + target
 
         computed_guess = hashlib.sha256((payload + iteration).encode())\
                              .hexdigest()[0:POW_HASH_LENGTH]
         if guess != computed_guess or guess > target:
             self._errors['text'] = self.error_class(
                 [_('Invalid PoW.')])
 
 
 
 class ThreadForm(PostForm):
 
     tags = forms.CharField(
         widget=forms.TextInput(attrs={ATTRIBUTE_PLACEHOLDER: TAGS_PLACEHOLDER}),
         max_length=100, label=_('Tags'), required=True)
     monochrome = forms.BooleanField(label=_('Monochrome'), required=False)
 
     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
         tag_set = set()
         for tag_string in tags.split():
             tag, created = Tag.objects.get_or_create(name=tag_string.strip().lower())
             tag_set.add(tag)
 
             # If this is a new tag, don't check for its parents because nobody
             # added them yet
             if not created:
                 tag_set |= set(tag.get_all_parents())
 
         for tag in tag_set:
             if tag.required:
                 required_tag_exists = True
                 break
 
         if not required_tag_exists:
             raise forms.ValidationError(
                 _('Need at least one section.'))
 
         return tag_set
 
     def clean(self):
         cleaned_data = super(ThreadForm, self).clean()
 
         return cleaned_data
 
     def is_monochrome(self):
         return self.cleaned_data['monochrome']
 
 
 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_USERNAMES.match(username):
             raise forms.ValidationError(_('Inappropriate characters.'))
 
         return username
 
 
 class SearchForm(NeboardForm):
     query = forms.CharField(max_length=500, label=LABEL_SEARCH, required=False)

boards/models/attachment/downloaders.py

@@ -1,69 +1,70 b''
 import os
 import re
 
 from django.core.files.uploadedfile import SimpleUploadedFile, \
     TemporaryUploadedFile
 from pytube import YouTube
 import requests
 
 from boards.utils import validate_file_size
 
 YOUTUBE_VIDEO_FORMAT = 'webm'
 
 HTTP_RESULT_OK = 200
 
 HEADER_CONTENT_LENGTH = 'content-length'
 HEADER_CONTENT_TYPE = 'content-type'
 
 FILE_DOWNLOAD_CHUNK_BYTES = 200000
 
 YOUTUBE_URL = re.compile(r'https?://((www\.)?youtube\.com/watch\?v=|youtu.be/)\w+')
 
 
 class Downloader:
     @staticmethod
     def handles(url: str) -> bool:
         return False
 
     @staticmethod
     def download(url: str):
         # Verify content headers
         response_head = requests.head(url, verify=False)
         content_type = response_head.headers[HEADER_CONTENT_TYPE].split(';')[0]
         length_header = response_head.headers.get(HEADER_CONTENT_LENGTH)
         if length_header:
             length = int(length_header)
             validate_file_size(length)
         # Get the actual content into memory
         response = requests.get(url, verify=False, stream=True)
 
         # Download file, stop if the size exceeds limit
         size = 0
 
         # Set a dummy file name that will be replaced
         # anyway, just keep the valid extension
         filename = 'file.' + content_type.split('/')[1]
 
         file = TemporaryUploadedFile(filename, content_type, 0, None, None)
         for chunk in response.iter_content(FILE_DOWNLOAD_CHUNK_BYTES):
             size += len(chunk)
             validate_file_size(size)
             file.write(chunk)
 
         if response.status_code == HTTP_RESULT_OK:
             return file
 
 
 class YouTubeDownloader(Downloader):
     @staticmethod
     def download(url: str):
         yt = YouTube()
         yt.from_url(url)
         videos = yt.filter(YOUTUBE_VIDEO_FORMAT)
         if len(videos) > 0:
             video = videos[0]
             return Downloader.download(video.url)
 
     @staticmethod
     def handles(url: str) -> bool:
         return YOUTUBE_URL.match(url)
+

boards/models/image.py

@@ -1,97 +1,98 b''
 from django.db import models
 from django.template.defaultfilters import filesizeformat
 
 from boards import thumbs, utils
 import boards
 from boards.models.base import Viewable
 from boards.models import STATUS_ARCHIVE
 from boards.utils import get_upload_filename
 
 
 __author__ = 'neko259'
 
 
 IMAGE_THUMB_SIZE = (200, 150)
 HASH_LENGTH = 36
 
 CSS_CLASS_IMAGE = 'image'
 CSS_CLASS_THUMB = 'thumb'
 
 
 class PostImageManager(models.Manager):
     def create_with_hash(self, 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_random_images(self, count, tags=None):
         images = self.exclude(post_images__thread__status=STATUS_ARCHIVE)
         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',)
 
     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=get_upload_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)
+    alias = models.TextField(unique=True, null=True, blank=True)
 
     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 = 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, 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/manager.py

@@ -1,131 +1,133 b''
 import logging
 
 from datetime import datetime, timedelta, date
 from datetime import time as dtime
 
 from django.db import models, transaction
 from django.utils import timezone
 
 import boards
 
 from boards.models.user import Ban
 from boards.mdx_neboard import Parser
 from boards.models import PostImage, Attachment
 from boards import utils
 
 __author__ = 'neko259'
 
 IMAGE_TYPES = (
     'jpeg',
     'jpg',
     'png',
     'bmp',
     'gif',
 )
 
 POSTS_PER_DAY_RANGE = 7
 NO_IP = '0.0.0.0'
 
 
 class PostManager(models.Manager):
     @transaction.atomic
     def create_post(self, title: str, text: str, file=None, thread=None,
                     ip=NO_IP, tags: list=None, opening_posts: list=None,
-                    tripcode='', monochrome=False):
+                    tripcode='', monochrome=False, images=[]):
         """
         Creates new post
         """
 
         if thread is not None and thread.is_archived():
             raise Exception('Cannot post into an archived thread')
 
         if not utils.is_anonymous_mode():
             is_banned = Ban.objects.filter(ip=ip).exists()
         else:
             is_banned = False
 
         # 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,
                     monochrome=monochrome)
             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,
                            tripcode=tripcode,
                            opening=new_thread)
         post.threads.add(thread)
 
         logger = logging.getLogger('boards.post.create')
 
         logger.info('Created post [{}] with text [{}] by {}'.format(post,
             post.get_text(),post.poster_ip))
 
         # 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))
+        for image in images:
+            post.images.add(image)
 
         post.connect_threads(opening_posts)
 
         # 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
 

boards/templates/boards/settings.html

@@ -1,40 +1,44 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 %}
                     {{ tag.get_view|safe }}
                 {% endfor %}
             </p>
         {% else %}
             <p>{% trans 'No hidden tags.' %}</p>
         {% endif %}
+
+        {% for image in image_aliases %}
+            {{ image.alias }}: <img src="{{ image.image.url_200x150 }}" /> <br />
+        {% endfor %}
     </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/views/all_threads.py

@@ -1,168 +1,169 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.utils.decorators import method_decorator
 from django.views.decorators.csrf import csrf_protect
 
 from boards import utils, settings
 from boards.abstracts.paginator import get_paginator
 from boards.abstracts.settingsmanager import get_settings_manager
 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
 from boards.views.mixins import FileUploadMixin, PaginatedMixin
 
 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_ADDITIONAL = 'additional_params'
 PARAMETER_MAX_FILE_SIZE = 'max_file_size'
 PARAMETER_RSS_URL = 'rss_url'
 
 TEMPLATE = 'boards/all_threads.html'
 DEFAULT_PAGE = 1
 
 
 class AllThreadsView(PostMixin, FileUploadMixin, BaseBoardView, PaginatedMixin):
 
     def __init__(self):
         self.settings_manager = None
         super(AllThreadsView, self).__init__()
 
     @method_decorator(csrf_protect)
     def get(self, request, form: ThreadForm=None):
         page = request.GET.get('page', DEFAULT_PAGE)
 
         params = self.get_context_data(request=request)
 
         if not form:
             form = ThreadForm(error_class=PlainErrorList)
 
         self.settings_manager = get_settings_manager(request)
 
         threads = self.get_threads()
 
         order = request.GET.get('order', 'bump')
         if order == 'bump':
             threads = threads.order_by('-bump_time')
         else:
             threads = threads.filter(multi_replies__opening=True).order_by('-multi_replies__pub_time')
         filter = request.GET.get('filter')
         if filter == 'fav_tags':
             fav_tags = self.settings_manager.get_fav_tags()
             if len(fav_tags) > 0:
                 threads = threads.filter(tags__in=fav_tags)
         threads = threads.distinct()
 
         paginator = get_paginator(threads,
                                   settings.get_int('View', 'ThreadsPerPage'))
         paginator.current_page = int(page)
 
         try:
             threads = paginator.page(page).object_list
         except EmptyPage:
             raise Http404()
 
         params[PARAMETER_THREADS] = threads
         params[CONTEXT_FORM] = form
         params[PARAMETER_BANNERS] = Banner.objects.order_by('-id').all()
         params[PARAMETER_MAX_FILE_SIZE] = self.get_max_upload_size()
         params[PARAMETER_RSS_URL] = self.get_rss_url()
 
         paginator.set_url(self.get_reverse_url(), request.GET.dict())
         self.get_page_context(paginator, params, page)
 
         return render(request, TEMPLATE, params)
 
     @method_decorator(csrf_protect)
     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
         self.set_page_urls(paginator, params)
 
     def get_reverse_url(self):
         return reverse('index')
 
     @transaction.atomic
     def create_thread(self, request, form: ThreadForm, html_response=True):
         """
         Creates a new thread with an opening post.
         """
 
         ip = utils.get_client_ip(request)
         is_banned = Ban.objects.filter(ip=ip).exists()
 
         if is_banned:
             if html_response:
                 return redirect(BannedView().as_view())
             else:
                 return
 
         data = form.cleaned_data
 
         title = form.get_title()
         text = data[FORM_TEXT]
         file = form.get_file()
         threads = data[FORM_THREADS]
+        images = form.get_images()
 
         text = self._remove_invalid_links(text)
 
         tags = data[FORM_TAGS]
         monochrome = form.is_monochrome()
 
         post = Post.objects.create_post(title=title, text=text, file=file,
                                         ip=ip, tags=tags, opening_posts=threads,
                                         tripcode=form.get_tripcode(),
-                                        monochrome=monochrome)
+                                        monochrome=monochrome, images=images)
 
         # 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\
             .exclude(tags__in=self.settings_manager.get_hidden_tags())
 
     def get_rss_url(self):
         return self.get_reverse_url() + 'rss/'

boards/views/settings.py

@@ -1,76 +1,79 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
+from boards.models import PostImage
 
 FORM_THEME = 'theme'
 FORM_USERNAME = 'username'
 FORM_TIMEZONE = 'timezone'
 FORM_IMAGE_VIEWER = 'image_viewer'
 
 CONTEXT_HIDDEN_TAGS = 'hidden_tags'
+CONTEXT_IMAGE_ALIASES = 'image_aliases'
 
 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()
+        params[CONTEXT_IMAGE_ALIASES] = PostImage.objects.exclude(alias='').exclude(alias=None)
 
         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/thread/thread.py

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