Allow deleting attachments with their files already deleted

boards/signals.py

@@ -1,135 +1,141 b''
 import re
 import os
 
 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
 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 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
-        os.remove(file)
+        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])
-                os.remove(thumb_file)
+                try:
+                    os.remove(thumb_file)
+                except FileNotFoundError:
+                    pass
 

boards/views/tag_gallery.py

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