apps/catalogue/fields.py

   1 # -*- coding: utf-8 -*-
   2 # This file is part of Wolnelektury, licensed under GNU Affero GPLv3 or later.
   3 # Copyright © Fundacja Nowoczesna Polska. See NOTICE for more information.
   4 #
   5 from django.conf import settings
   6 from django.core.files import File
   7 from django.db import models
   8 from django.db.models.fields.files import FieldFile
   9 from catalogue import app_settings
  10 from catalogue.constants import LANGUAGES_3TO2
  11 from catalogue.utils import remove_zip, truncate_html_words
  12 from celery.task import Task, task
  13 from waiter.utils import clear_cache
  14
  15
  16 class EbookFieldFile(FieldFile):
  17     """Represents contents of an ebook file field."""
  18
  19     def build(self):
  20         """Build the ebook immediately."""
  21         return self.field.builder.build(self)
  22
  23     def build_delay(self):
  24         """Builds the ebook in a delayed task."""
  25         return self.field.builder.delay(self.instance, self.field.attname)
  26
  27
  28 class EbookField(models.FileField):
  29     """Represents an ebook file field, attachable to a model."""
  30     attr_class = EbookFieldFile
  31
  32     def __init__(self, format_name, *args, **kwargs):
  33         super(EbookField, self).__init__(*args, **kwargs)
  34         self.format_name = format_name
  35
  36     def deconstruct(self):
  37         name, path, args, kwargs = super(EbookField, self).deconstruct()
  38         args.insert(0, self.format_name)
  39         return name, path, args, kwargs
  40
  41     @property
  42     def builder(self):
  43         """Finds a celery task suitable for the format of the field."""
  44         return BuildEbook.for_format(self.format_name)
  45
  46     def contribute_to_class(self, cls, name):
  47         super(EbookField, self).contribute_to_class(cls, name)
  48
  49         def has(model_instance):
  50             return bool(getattr(model_instance, self.attname, None))
  51         has.__doc__ = None
  52         has.__name__ = str("has_%s" % self.attname)
  53         has.short_description = self.name
  54         has.boolean = True
  55         setattr(cls, 'has_%s' % self.attname, has)
  56
  57
  58 class BuildEbook(Task):
  59     formats = {}
  60
  61     @classmethod
  62     def register(cls, format_name):
  63         """A decorator for registering subclasses for particular formats."""
  64         def wrapper(builder):
  65             cls.formats[format_name] = builder
  66             return builder
  67         return wrapper
  68
  69     @classmethod
  70     def for_format(cls, format_name):
  71         """Returns a celery task suitable for specified format."""
  72         return cls.formats.get(format_name, BuildEbookTask)
  73
  74     @staticmethod
  75     def transform(wldoc, fieldfile):
  76         """Transforms an librarian.WLDocument into an librarian.OutputFile.
  77
  78         By default, it just calls relevant wldoc.as_??? method.
  79
  80         """
  81         return getattr(wldoc, "as_%s" % fieldfile.field.format_name)()
  82
  83     def run(self, obj, field_name):
  84         """Just run `build` on FieldFile, can't pass it directly to Celery."""
  85         return self.build(getattr(obj, field_name))
  86
  87     def build(self, fieldfile):
  88         book = fieldfile.instance
  89         out = self.transform(book.wldocument(), fieldfile)
  90         fieldfile.save(None, File(open(out.get_filename())), save=False)
  91         if book.pk is not None:
  92             type(book).objects.filter(pk=book.pk).update(**{
  93                 fieldfile.field.attname: fieldfile
  94             })
  95         if fieldfile.field.format_name in app_settings.FORMAT_ZIPS:
  96             remove_zip(app_settings.FORMAT_ZIPS[fieldfile.field.format_name])
  97 # Don't decorate BuildEbook, because we want to subclass it.
  98 BuildEbookTask = task(BuildEbook, ignore_result=True)
  99
 100
 101 @BuildEbook.register('txt')
 102 @task(ignore_result=True)
 103 class BuildTxt(BuildEbook):
 104     @staticmethod
 105     def transform(wldoc, fieldfile):
 106         return wldoc.as_text()
 107
 108
 109 @BuildEbook.register('pdf')
 110 @task(ignore_result=True)
 111 class BuildPdf(BuildEbook):
 112     @staticmethod
 113     def transform(wldoc, fieldfile):
 114         return wldoc.as_pdf(morefloats=settings.LIBRARIAN_PDF_MOREFLOATS,
 115             cover=True)
 116
 117     def build(self, fieldfile):
 118         BuildEbook.build(self, fieldfile)
 119         clear_cache(fieldfile.instance.slug)
 120
 121
 122 @BuildEbook.register('epub')
 123 @task(ignore_result=True)
 124 class BuildEpub(BuildEbook):
 125     @staticmethod
 126     def transform(wldoc, fieldfile):
 127         return wldoc.as_epub(cover=True)
 128
 129
 130 @BuildEbook.register('html')
 131 @task(ignore_result=True)
 132 class BuildHtml(BuildEbook):
 133     def build(self, fieldfile):
 134         from django.core.files.base import ContentFile
 135         from fnpdjango.utils.text.slughifi import slughifi
 136         from sortify import sortify
 137         from librarian import html
 138         from catalogue.models import Fragment, Tag
 139
 140         book = fieldfile.instance
 141
 142         html_output = self.transform(
 143                         book.wldocument(parse_dublincore=False),
 144                         fieldfile)
 145
 146         # Delete old fragments, create from scratch if necessary.
 147         book.fragments.all().delete()
 148
 149         if html_output:
 150             meta_tags = list(book.tags.filter(
 151                 category__in=('author', 'epoch', 'genre', 'kind')))
 152             book_tag = book.book_tag()
 153
 154             lang = book.language
 155             lang = LANGUAGES_3TO2.get(lang, lang)
 156             if lang not in [ln[0] for ln in settings.LANGUAGES]:
 157                 lang = None
 158
 159             fieldfile.save(None, ContentFile(html_output.get_string()),
 160                     save=False)
 161             type(book).objects.filter(pk=book.pk).update(**{
 162                 fieldfile.field.attname: fieldfile
 163             })
 164
 165             # get ancestor l-tags for adding to new fragments
 166             ancestor_tags = []
 167             p = book.parent
 168             while p:
 169                 ancestor_tags.append(p.book_tag())
 170                 p = p.parent
 171
 172             # Extract fragments
 173             closed_fragments, open_fragments = html.extract_fragments(fieldfile.path)
 174             for fragment in closed_fragments.values():
 175                 try:
 176                     theme_names = [s.strip() for s in fragment.themes.split(',')]
 177                 except AttributeError:
 178                     continue
 179                 themes = []
 180                 for theme_name in theme_names:
 181                     if not theme_name:
 182                         continue
 183                     if lang == settings.LANGUAGE_CODE:
 184                         # Allow creating themes if book in default language.
 185                         tag, created = Tag.objects.get_or_create(
 186                                             slug=slughifi(theme_name),
 187                                             category='theme')
 188                         if created:
 189                             tag.name = theme_name
 190                             setattr(tag, "name_%s" % lang, theme_name)
 191                             tag.sort_key = sortify(theme_name.lower())
 192                             tag.save()
 193                         themes.append(tag)
 194                     elif lang is not None:
 195                         # Don't create unknown themes in non-default languages.
 196                         try:
 197                             tag = Tag.objects.get(category='theme',
 198                                     **{"name_%s" % lang: theme_name})
 199                         except Tag.DoesNotExist:
 200                             pass
 201                         else:
 202                             themes.append(tag)
 203                 if not themes:
 204                     continue
 205
 206                 text = fragment.to_string()
 207                 short_text = truncate_html_words(text, 15)
 208                 if text == short_text:
 209                     short_text = ''
 210                 new_fragment = Fragment.objects.create(anchor=fragment.id,
 211                         book=book, text=text, short_text=short_text)
 212
 213                 new_fragment.save()
 214                 new_fragment.tags = set(meta_tags + themes + [book_tag] + ancestor_tags)
 215             book.fix_tree_tags()
 216             book.html_built.send(sender=book)
 217             return True
 218         book.fix_tree_tags()
 219         return False
 220
 221 @BuildEbook.register('cover_thumb')
 222 @task(ignore_result=True)
 223 class BuildCoverThumb(BuildEbook):
 224     @classmethod
 225     def transform(cls, wldoc, fieldfile):
 226         from librarian.cover import WLCover
 227         return WLCover(wldoc.book_info, height=193).output_file()
 228
 229
 230
 231 class OverwritingFieldFile(FieldFile):
 232     """
 233         Deletes the old file before saving the new one.
 234     """
 235
 236     def save(self, name, content, *args, **kwargs):
 237         leave = kwargs.pop('leave', None)
 238         # delete if there's a file already and there's a new one coming
 239         if not leave and self and (not hasattr(content, 'path') or
 240                                    content.path != self.path):
 241             self.delete(save=False)
 242         return super(OverwritingFieldFile, self).save(
 243                 name, content, *args, **kwargs)
 244
 245
 246 class OverwritingFileField(models.FileField):
 247     attr_class = OverwritingFieldFile
 248
 249
 250 try:
 251     # check for south
 252     from south.modelsinspector import add_introspection_rules
 253 except ImportError:
 254     pass
 255 else:
 256     add_introspection_rules([
 257         (
 258             [EbookField],
 259             [],
 260             {'format_name': ('format_name', {})}
 261         )
 262     ], ["^catalogue\.fields\.EbookField"])
 263     add_introspection_rules([], ["^catalogue\.fields\.OverwritingFileField"])