Unify thread and post creation into one method inside post manager, that can be called from almost anywhere (one step closer to ajax thread creation)

boards/abstracts/constants.py

@@ -1,4 +1,5 b''
 import re
 
 FILE_DIRECTORY = 'files/'
 REGEX_TAGS = re.compile(r'^[\w\s\d\']+$', re.UNICODE)
+REGEX_REPLY = re.compile(r'\[post\](\d+)\[/post\]')
  No newline at end of file

boards/models/post/__init__.py

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

boards/models/post/manager.py

@@ -1,228 +1,291 b''
 import logging
+import re
 from datetime import datetime, timedelta, date
 from datetime import time as dtime
 
 from django.core.exceptions import PermissionDenied
 from django.db import models, transaction
 from django.dispatch import Signal
+from django.shortcuts import redirect
 from django.utils import timezone
 
 import boards
 from boards import utils
 from boards.abstracts.exceptions import ArchiveException
-from boards.abstracts.constants import REGEX_TAGS
+from boards.abstracts.constants import REGEX_TAGS, REGEX_REPLY
 from boards.mdx_neboard import Parser
 from boards.models import Attachment
 from boards.models.attachment import StickerPack, AttachmentSticker
 from boards.models.user import Ban
 
 __author__ = 'neko259'
 
 POSTS_PER_DAY_RANGE = 7
 NO_IP = '0.0.0.0'
 
 
 post_import_deps = Signal()
 
+FORM_TEXT = 'text'
+FORM_TAGS = 'tags'
+
+REFLINK_PREFIX = '>>'
+
 
 class PostManager(models.Manager):
     @transaction.atomic
     def create_post(self, title: str, text: str, files=[], thread=None,
                     ip=NO_IP, tags: list=None,
                     tripcode='', monochrome=False, images=[],
                     file_urls=[], stickerpack=False):
         """
         Creates new post
         """
 
         if thread is not None and thread.is_archived():
             raise ArchiveException('Cannot post into an archived thread')
 
         if not utils.is_anonymous_mode():
             is_banned = Ban.objects.filter(ip=ip).exists()
         else:
             is_banned = False
 
         if is_banned:
             raise PermissionDenied()
 
         if not tags:
             tags = []
 
         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, stickerpack=stickerpack)
             list(map(thread.tags.add, tags))
             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)
 
         logger = logging.getLogger('boards.post.create')
 
         logger.info('Created post [{}] with text [{}] by {}'.format(post,
             post.get_text(),post.poster_ip))
 
         for file in files:
             self._add_file_to_post(file, post)
         for image in images:
             post.attachments.add(image)
         for file_url in file_urls:
             post.attachments.add(Attachment.objects.create_from_url(file_url))
 
         post.set_global_id()
 
         # 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()
 
         self._create_stickers(post)
 
         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
 
     def get_post_per_days(self, days) -> int:
         day_end = date.today() + timedelta(1)
         day_start = day_end - timedelta(days)
 
         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())
 
         return self.filter(
             pub_time__lte=day_time_end,
             pub_time__gte=day_time_start).count()
 
     @transaction.atomic
     def import_post(self, title: str, text: str, pub_time: str, global_id,
                     opening_post=None, tags=list(), files=list(),
                     file_urls=list(), tripcode=None, last_edit_time=None):
         is_opening = opening_post is None
         if is_opening:
             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=last_edit_time or pub_time,
                            global_id=global_id,
                            opening=is_opening,
                            thread=thread,
                            tripcode=tripcode)
 
         for file in files:
             self._add_file_to_post(file, post)
         for file_url in file_urls:
             post.attachments.add(Attachment.objects.create_from_url(file_url))
 
         url_to_post = '[post]{}[/post]'.format(str(global_id))
         replies = self.filter(text__contains=url_to_post)
         for reply in replies:
             post_import_deps.send(reply)
 
     @transaction.atomic
     def update_post(self, post, title: str, text: str, pub_time: str,
                     tags=list(), files=list(), file_urls=list(), tripcode=None):
         post.title = title
         post.text = text
         post.pub_time = pub_time
         post.tripcode = tripcode
         post.save()
 
         post.clear_cache()
 
         post.attachments.clear()
         for file in files:
             self._add_file_to_post(file, post)
         for file_url in file_urls:
             post.attachments.add(Attachment.objects.create_from_url(file_url))
 
         thread = post.get_thread()
         thread.tags.clear()
         list(map(thread.tags.add, tags))
 
+    def create_from_form(self, request, form, opening_post, html_response=True):
+        ip = utils.get_client_ip(request)
+
+        data = form.cleaned_data
+
+        title = form.get_title()
+        text = data[FORM_TEXT]
+        files = form.get_files()
+        file_urls = form.get_file_urls()
+        images = form.get_images()
+
+        text = self._remove_invalid_links(text)
+
+        if opening_post:
+            post_thread = opening_post.get_thread()
+            monochrome = False
+            stickerpack = False
+            tags = []
+        else:
+            tags = data[FORM_TAGS]
+            monochrome = form.is_monochrome()
+            stickerpack = form.is_stickerpack()
+            post_thread = None
+
+        post = self.create_post(title=title, text=text, files=files,
+                                thread=post_thread, ip=ip,
+                                tripcode=form.get_tripcode(),
+                                images=images, file_urls=file_urls,
+                                monochrome=monochrome,
+                                stickerpack=stickerpack, tags=tags)
+
+        if form.is_subscribe():
+            from boards.abstracts.settingsmanager import get_settings_manager
+            settings_manager = get_settings_manager(request)
+            settings_manager.add_or_read_fav_thread(
+                post_thread.get_opening_post())
+
+        if html_response:
+            return redirect(post.get_absolute_url())
+        else:
+            return post
+
     def _add_file_to_post(self, file, post):
         post.attachments.add(Attachment.objects.create_with_hash(file))
 
     def _create_stickers(self, post):
         thread = post.get_thread()
         stickerpack_thread = thread.is_stickerpack()
         if stickerpack_thread:
             logger = logging.getLogger('boards.stickers')
             if not post.is_opening():
                 has_title = len(post.title) > 0
                 has_one_attachment = post.attachments.count() == 1
                 opening_post = thread.get_opening_post()
                 valid_name = REGEX_TAGS.match(post.title)
                 if has_title and has_one_attachment and valid_name:
                     existing_sticker = AttachmentSticker.objects.filter(
                         name=post.get_title()).first()
                     attachment = post.attachments.first()
                     if existing_sticker:
                         existing_sticker.attachment = attachment
                         existing_sticker.save()
                         logger.info('Updated sticker {} with new attachment'.format(existing_sticker))
                     else:
                         try:
                             stickerpack = StickerPack.objects.get(
                                 name=opening_post.get_title(), tripcode=post.tripcode)
                             sticker = AttachmentSticker.objects.create(
                                 stickerpack=stickerpack, name=post.get_title(),
                                 attachment=attachment)
                             logger.info('Created sticker {}'.format(sticker))
                         except StickerPack.DoesNotExist:
                             pass
             else:
                 stickerpack, created = StickerPack.objects.get_or_create(
                     name=post.get_title(), tripcode=post.tripcode)
                 if created:
                     logger.info('Created stickerpack {}'.format(stickerpack))
+
+    def _remove_invalid_links(self, text):
+        """
+        Replace invalid links in posts so that they won't be parsed.
+        Invalid links are links to non-existent posts
+        """
+
+        for reply_number in re.finditer(REGEX_REPLY, text):
+            post_id = reply_number.group(1)
+            post = self.filter(id=post_id)
+            if not post.exists():
+                text = text.replace(REFLINK_PREFIX + post_id, post_id)
+
+        return text

boards/signals.py

@@ -1,143 +1,143 b''
 import re
 import os
 import logging
 
 from django.db.models.signals import post_save, pre_save, pre_delete, \
     post_delete
 from django.dispatch import receiver
 from django.utils import timezone
 
 from boards import thumbs
 from boards.mdx_neboard import get_parser
 
 from boards.models import Post, GlobalId, Attachment, Thread
 from boards.models.attachment import StickerPack, AttachmentSticker
 from boards.models.attachment.viewers import FILE_TYPES_IMAGE
-from boards.models.post import REGEX_NOTIFICATION, REGEX_REPLY,\
-        REGEX_GLOBAL_REPLY
+from boards.models.post import REGEX_NOTIFICATION, REGEX_GLOBAL_REPLY
+from boards.abstracts.constants import REGEX_REPLY
 from boards.models.post.manager import post_import_deps
 from boards.models.user import Notification
 from neboard.settings import MEDIA_ROOT
 
 
 THUMB_SIZES = ((200, 150),)
 
 
 @receiver(post_save, sender=Post)
 def connect_replies(instance, **kwargs):
     if not kwargs['update_fields']:
         for reply_number in re.finditer(REGEX_REPLY, instance.get_raw_text()):
             post_id = reply_number.group(1)
 
             try:
                 referenced_post = Post.objects.get(id=post_id)
 
                 if not referenced_post.referenced_posts.filter(
                         id=instance.id).exists():
                     referenced_post.referenced_posts.add(instance)
                     referenced_post.last_edit_time = instance.pub_time
                     referenced_post.build_refmap()
                     referenced_post.save(update_fields=['refmap', 'last_edit_time'])
             except Post.DoesNotExist:
                 pass
 
 
 @receiver(post_save, sender=Post)
 @receiver(post_import_deps, sender=Post)
 def connect_global_replies(instance, **kwargs):
     if not kwargs['update_fields']:
         for reply_number in re.finditer(REGEX_GLOBAL_REPLY, instance.get_raw_text()):
             key_type = reply_number.group(1)
             key = reply_number.group(2)
             local_id = reply_number.group(3)
 
             try:
                 global_id = GlobalId.objects.get(key_type=key_type, key=key,
                         local_id=local_id)
                 referenced_post = Post.objects.get(global_id=global_id)
                 referenced_post.referenced_posts.add(instance)
                 referenced_post.last_edit_time = instance.pub_time
                 referenced_post.build_refmap()
                 referenced_post.save(update_fields=['refmap', 'last_edit_time'])
             except (GlobalId.DoesNotExist, Post.DoesNotExist):
                 pass
 
 
 @receiver(post_save, sender=Post)
 def connect_notifications(instance, **kwargs):
     if not kwargs['update_fields']:
         for reply_number in re.finditer(REGEX_NOTIFICATION, instance.get_raw_text()):
             user_name = reply_number.group(1).lower()
             Notification.objects.get_or_create(name=user_name, post=instance)
 
 
 @receiver(pre_save, sender=Post)
 @receiver(post_import_deps, sender=Post)
 def parse_text(instance, **kwargs):
     instance._text_rendered = get_parser().parse(instance.get_raw_text())
 
 
 @receiver(pre_delete, sender=Post)
 def delete_attachments(instance, **kwargs):
     for attachment in instance.attachments.all():
         attachment_refs_count = attachment.attachment_posts.count()
         if attachment_refs_count == 1:
             attachment.delete()
 
 
 @receiver(post_delete, sender=Post)
 def update_thread_on_delete(instance, **kwargs):
     thread = instance.get_thread()
     thread.last_edit_time = timezone.now()
     thread.save()
 
 
 @receiver(post_delete, sender=Post)
 def delete_global_id(instance, **kwargs):
     if instance.global_id and instance.global_id.id:
         instance.global_id.delete()
 
 
 @receiver(post_save, sender=Attachment)
 def generate_thumb(instance, **kwargs):
     if instance.mimetype in FILE_TYPES_IMAGE:
         for size in THUMB_SIZES:
             (w, h) = size
             split = instance.file.name.rsplit('.', 1)
             thumb_name = '%s.%sx%s.%s' % (split[0], w, h, split[1])
 
             if not instance.file.storage.exists(thumb_name):
                 # you can use another thumbnailing function if you like
                 thumb_content = thumbs.generate_thumb(instance.file, size, split[1])
 
                 thumb_name_ = instance.file.storage.save(thumb_name, thumb_content)
 
                 if not thumb_name == thumb_name_:
                     raise ValueError(
                         'There is already a file named %s' % thumb_name_)
 
 
 @receiver(pre_delete, sender=Post)
 def rebuild_refmap(instance, **kwargs):
     for referenced_post in instance.refposts.all():
         referenced_post.build_refmap(excluded_ids=[instance.id])
         referenced_post.save(update_fields=['refmap'])
 
 
 @receiver(post_delete, sender=Attachment)
 def delete_file(instance, **kwargs):
     if instance.is_internal():
         file = MEDIA_ROOT + instance.file.name
         try:
             os.remove(file)
         except FileNotFoundError:
             pass
         if instance.mimetype in FILE_TYPES_IMAGE:
             for size in THUMB_SIZES:
                 file_name_parts = instance.file.name.split('.')
                 thumb_file = MEDIA_ROOT + '{}.{}x{}.{}'.format(file_name_parts[0], size[0], size[1], file_name_parts[1])
                 try:
                     os.remove(thumb_file)
                 except FileNotFoundError:
                     pass
 

boards/urls.py

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

boards/views/all_threads.py

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

boards/views/api.py

@@ -1,322 +1,321 b''
 import json
 import logging
 
 from django.core import serializers
 from django.db import transaction
 from django.db.models import Q
 from django.http import HttpResponse, HttpResponseBadRequest
 from django.shortcuts import get_object_or_404
 from django.views.decorators.csrf import csrf_protect
 
 from boards.abstracts.settingsmanager import get_settings_manager
 from boards.forms import PostForm, PlainErrorList
 from boards.mdx_neboard import Parser
 from boards.models import Post, Thread, Tag, TagAlias
 from boards.models.attachment import AttachmentSticker
 from boards.models.thread import STATUS_ARCHIVE
 from boards.models.user import Notification
 from boards.utils import datetime_to_epoch
-from boards.views.thread import ThreadView
 
 __author__ = 'neko259'
 
 PARAMETER_TRUNCATED = 'truncated'
 PARAMETER_TAG = 'tag'
 PARAMETER_OFFSET = 'offset'
 PARAMETER_DIFF_TYPE = 'type'
 PARAMETER_POST = 'post'
 PARAMETER_UPDATED = 'updated'
 PARAMETER_LAST_UPDATE = 'last_update'
 PARAMETER_THREAD = 'thread'
 PARAMETER_UIDS = 'uids'
 PARAMETER_SUBSCRIBED = 'subscribed'
 
 DIFF_TYPE_HTML = 'html'
 DIFF_TYPE_JSON = 'json'
 
 STATUS_OK = 'ok'
 STATUS_ERROR = 'error'
 
 logger = logging.getLogger(__name__)
 
 
 @transaction.atomic
 def api_get_threaddiff(request):
     """
     Gets posts that were changed or added since time
     """
 
     thread_id = request.POST.get(PARAMETER_THREAD)
     uids_str = request.POST.get(PARAMETER_UIDS)
 
     if not thread_id or not uids_str:
         return HttpResponse(content='Invalid request.')
 
     uids = uids_str.strip().split(' ')
 
     opening_post = get_object_or_404(Post, id=thread_id)
     thread = opening_post.get_thread()
 
     json_data = {
         PARAMETER_UPDATED: [],
         PARAMETER_LAST_UPDATE: None,  # TODO Maybe this can be removed already?
     }
     posts = Post.objects.filter(thread=thread).exclude(uid__in=uids)
 
     diff_type = request.GET.get(PARAMETER_DIFF_TYPE, DIFF_TYPE_HTML)
 
     for post in posts:
         json_data[PARAMETER_UPDATED].append(post.get_post_data(
             format_type=diff_type, request=request))
     json_data[PARAMETER_LAST_UPDATE] = str(thread.last_edit_time)
 
     settings_manager = get_settings_manager(request)
     json_data[PARAMETER_SUBSCRIBED] = str(settings_manager.thread_is_fav(opening_post))
 
     # 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)
 
     return HttpResponse(content=json.dumps(json_data))
 
 
 @csrf_protect
 def api_add_post(request, opening_post_id):
     """
     Adds a post and return the JSON response for it
     """
 
     # TODO Allow thread creation here too, without specifying opening post
     opening_post = get_object_or_404(Post, id=opening_post_id)
 
     status = STATUS_OK
     errors = []
 
     post = None
     if request.method == 'POST':
         form = PostForm(request.POST, request.FILES, error_class=PlainErrorList)
         form.session = request.session
 
         if form.need_to_ban:
             # Ban user because he is suspected to be a bot
             # _ban_current_user(request)
             status = STATUS_ERROR
         if form.is_valid():
-            post = ThreadView().new_post(request, form, opening_post,
-                                         html_response=False)
+            post = Post.objects.create_from_form(request, form, opening_post,
+                                                 html_response=False)
             if not post:
                 status = STATUS_ERROR
             else:
                 logger.info('Added post #%d via api.' % post.id)
         else:
             status = STATUS_ERROR
             errors = form.as_json_errors()
     else:
         status = STATUS_ERROR
 
     response = {
         'status': status,
         'errors': errors,
     }
 
     if post:
         response['post_id'] = post.id
 
     return HttpResponse(content=json.dumps(response))
 
 
 def get_post(request, post_id):
     """
     Gets the html of a post. Used for popups. Post can be truncated if used
     in threads list with 'truncated' get parameter.
     """
 
     post = get_object_or_404(Post, id=post_id)
     truncated = PARAMETER_TRUNCATED in request.GET
 
     return HttpResponse(content=post.get_view(truncated=truncated, need_op_data=True))
 
 
 def api_get_threads(request, count):
     """
     Gets the JSON thread opening posts list.
     Parameters that can be used for filtering:
     tag, offset (from which thread to get results)
     """
 
     if PARAMETER_TAG in request.GET:
         tag_name = request.GET[PARAMETER_TAG]
         if tag_name is not None:
             tag = get_object_or_404(Tag, name=tag_name)
             threads = tag.get_threads().exclude(status=STATUS_ARCHIVE)
     else: 
         threads = Thread.objects.exclude(status=STATUS_ARCHIVE)
 
     if PARAMETER_OFFSET in request.GET:
         offset = request.GET[PARAMETER_OFFSET]
         offset = int(offset) if offset is not None else 0
     else:
         offset = 0
 
     threads = threads.order_by('-bump_time')
     threads = threads[offset:offset + int(count)]
 
     opening_posts = []
     for thread in threads:
         opening_post = thread.get_opening_post()
 
         # TODO Add tags, replies and images count
         post_data = opening_post.get_post_data(include_last_update=True)
         post_data['status'] = thread.get_status()
 
         opening_posts.append(post_data)
 
     return HttpResponse(content=json.dumps(opening_posts))
 
 
 # TODO Test this
 def api_get_tags(request):
     """
     Gets all tags or user tags.
     """
 
     # TODO Get favorite tags for the given user ID
 
     tags = TagAlias.objects.all()
 
     term = request.GET.get('term')
     if term is not None:
         tags = tags.filter(name__contains=term)
 
     tag_names = [tag.name for tag in tags]
 
     return HttpResponse(content=json.dumps(tag_names))
 
 
 def api_get_stickers(request):
     term = request.GET.get('term')
     if not term:
         return HttpResponseBadRequest()
     
     global_stickers = AttachmentSticker.objects.filter(Q(name__icontains=term) | Q(stickerpack__name__icontains=term))
     local_stickers = [sticker for sticker in get_settings_manager(request).get_stickers() if term in sticker.name]
     stickers = list(global_stickers) + local_stickers
 
     image_dict = [{'thumb': sticker.attachment.get_thumb_url(),
                    'alias': str(sticker)}
                   for sticker in stickers]
 
     return HttpResponse(content=json.dumps(image_dict))
 
 
 # TODO The result can be cached by the thread last update time
 # TODO Test this
 def api_get_thread_posts(request, opening_post_id):
     """
     Gets the JSON array of thread posts
     """
 
     opening_post = get_object_or_404(Post, id=opening_post_id)
     thread = opening_post.get_thread()
     posts = thread.get_replies()
 
     json_data = {
         'posts': [],
         'last_update': None,
     }
     json_post_list = []
 
     for post in posts:
         json_post_list.append(post.get_post_data())
     json_data['last_update'] = datetime_to_epoch(thread.last_edit_time)
     json_data['posts'] = json_post_list
 
     return HttpResponse(content=json.dumps(json_data))
 
 
 def api_get_notifications(request, username):
     last_notification_id_str = request.GET.get('last', None)
     last_id = int(last_notification_id_str) if last_notification_id_str is not None else None
 
     posts = Notification.objects.get_notification_posts(usernames=[username],
                                                         last=last_id)
 
     json_post_list = []
     for post in posts:
         json_post_list.append(post.get_post_data())
     return HttpResponse(content=json.dumps(json_post_list))
 
 
 def api_get_post(request, post_id):
     """
     Gets the JSON of a post. This can be
     used as and API for external clients.
     """
 
     post = get_object_or_404(Post, id=post_id)
 
     json = serializers.serialize("json", [post], fields=(
         "pub_time", "_text_rendered", "title", "text", "image",
         "image_width", "image_height", "replies", "tags"
     ))
 
     return HttpResponse(content=json)
 
 
 def api_get_preview(request):
     raw_text = request.POST['raw_text']
 
     parser = Parser()
     return HttpResponse(content=parser.parse(parser.preparse(raw_text)))
 
 
 def api_get_new_posts(request):
     """
     Gets favorite threads and unread posts count.
     """
     posts = list()
 
     include_posts = 'include_posts' in request.GET
 
     settings_manager = get_settings_manager(request)
     fav_threads = settings_manager.get_fav_threads()
     fav_thread_ops = Post.objects.filter(id__in=fav_threads.keys())\
         .order_by('-pub_time').prefetch_related('thread')
 
     ops = [{'op': op, 'last_id': fav_threads[str(op.id)]} for op in fav_thread_ops]
     if include_posts:
         new_post_threads = Thread.objects.get_new_posts(ops)
         if new_post_threads:
             thread_ids = {thread.id: thread for thread in new_post_threads}
         else:
             thread_ids = dict()
 
         for op in fav_thread_ops:
             fav_thread_dict = dict()
 
             op_thread = op.get_thread()
             if op_thread.id in thread_ids:
                 thread = thread_ids[op_thread.id]
                 new_post_count = thread.new_post_count
                 fav_thread_dict['newest_post_link'] = thread.get_replies()\
                         .filter(id__gt=fav_threads[str(op.id)])\
                         .first().get_absolute_url(thread=thread)
             else:
                 new_post_count = 0
             fav_thread_dict['new_post_count'] = new_post_count
 
             fav_thread_dict['id'] = op.id
 
             fav_thread_dict['post_url'] = op.get_link_view()
             fav_thread_dict['title'] = op.title
 
             posts.append(fav_thread_dict)
     else:
         fav_thread_dict = dict()
         fav_thread_dict['new_post_count'] = \
             Thread.objects.get_new_post_count(ops)
         posts.append(fav_thread_dict)
 
     return HttpResponse(content=json.dumps(posts))

boards/views/feed.py

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

boards/views/mixins.py

@@ -1,61 +1,60 b''
 import boards
 
-
 PARAM_NEXT = 'next'
 PARAMETER_METHOD = 'method'
 
 PARAMETER_CURRENT_PAGE = 'current_page'
 PARAMETER_PAGINATOR = 'paginator'
 
 PARAMETER_PREV_LINK = 'prev_page_link'
 PARAMETER_NEXT_LINK = 'next_page_link'
 
+
 class DispatcherMixin:
     """
     This class contains a dispather method that can run a method specified by
     'method' request parameter.
     """
 
     def __init__(self):
         self.user = None
 
     def dispatch_method(self, *args, **kwargs):
         request = args[0]
 
         self.user = request.user
 
         method_name = None
         if PARAMETER_METHOD in request.GET:
             method_name = request.GET[PARAMETER_METHOD]
         elif PARAMETER_METHOD in request.POST:
             method_name = request.POST[PARAMETER_METHOD]
 
         if method_name:
             return getattr(self, method_name)(*args, **kwargs)
 
 
 class FileUploadMixin:
     def get_max_upload_size(self):
         return boards.settings.get_int('Forms', 'MaxFileSize')
 
 
 class PaginatedMixin:
     def get_page_context(self, paginator, page):
         """
         Get pagination context variables
         """
 
         params = {}
 
         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] = paginator.get_page_url(
                     current_page.previous_page_number())
         if current_page.has_next():
             params[PARAMETER_NEXT_LINK] = paginator.get_page_url(
                     current_page.next_page_number())
 
         return params
-

boards/views/tag_threads.py

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

boards/views/thread/thread.py

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