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