Fixed post deletion and export to JSON

boards/models/post/export.py

@@ -1,57 +1,57 b''
 from django.contrib.auth.context_processors import PermWrapper
 
 from boards import utils
 
 
 PARAMETER_TRUNCATED = 'truncated'
 
 DIFF_TYPE_HTML = 'html'
 DIFF_TYPE_JSON = 'json'
 
 
 class Exporter():
     @staticmethod
     def export(post, request, include_last_update) -> str:
         pass
 
 
 class HtmlExporter(Exporter):
     @staticmethod
     def export(post, request, include_last_update):
         if request is not None and PARAMETER_TRUNCATED in request.GET:
             truncated = True
             reply_link = False
         else:
             truncated = False
             reply_link = True
 
         return post.get_view(truncated=truncated, reply_link=reply_link,
                 perms=PermWrapper(request.user))
 
 
 class JsonExporter(Exporter):
     @staticmethod
     def export(post, request, include_last_update):
         post_json = {
             'id': post.id,
             'title': post.title,
             'text': post.get_raw_text(),
             }
-        if post.images.exists():
+        if post.attachments.exists():
             post_image = post.get_first_image()
-            post_json['image'] = post_image.image.url
-            post_json['image_preview'] = post_image.image.url_200x150
+            post_json['image'] = post_image.file.url
+            post_json['image_preview'] = post_image.get_preview_url()
         if include_last_update:
             post_json['bump_time'] = utils.datetime_to_epoch(
                 post.get_thread().bump_time)
         return post_json
 
 
 EXPORTERS = {
     DIFF_TYPE_HTML: HtmlExporter,
     DIFF_TYPE_JSON: JsonExporter,
 }
 
 
 def get_exporter(export_type: str) -> Exporter:
     return EXPORTERS[export_type]()

boards/signals.py

@@ -1,116 +1,108 b''
 import re
 from boards import thumbs
 from boards.mdx_neboard import get_parser
 
 from boards.models import Post, GlobalId, Attachment
 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.manager import post_import_deps
 from boards.models.user import Notification
 from django.db.models.signals import post_save, pre_save, pre_delete, \
     post_delete
 from django.dispatch import receiver
 from django.utils import timezone
 
 
 THUMB_SIZES = ((200, 150),)
 
 
 @receiver(post_save, sender=Post)
 def connect_replies(instance, **kwargs):
     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):
     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):
     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_images(instance, **kwargs):
-    for image in instance.images.all():
-        image_refs_count = image.post_images.count()
-        if image_refs_count == 1:
-            image.delete()
-
-
-@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_)