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.
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 celery.utils.log import get_task_logger
14 from waiter.utils import clear_cache
16 task_logger = get_task_logger(__name__)
19 class EbookFieldFile(FieldFile):
20 """Represents contents of an ebook file field."""
23 """Build the ebook immediately."""
24 return self.field.builder.build(self)
26 def build_delay(self):
27 """Builds the ebook in a delayed task."""
28 return self.field.builder.delay(self.instance, self.field.attname)
31 class EbookField(models.FileField):
32 """Represents an ebook file field, attachable to a model."""
33 attr_class = EbookFieldFile
35 def __init__(self, format_name, *args, **kwargs):
36 super(EbookField, self).__init__(*args, **kwargs)
37 self.format_name = format_name
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
46 """Finds a celery task suitable for the format of the field."""
47 return BuildEbook.for_format(self.format_name)
49 def contribute_to_class(self, cls, name):
50 super(EbookField, self).contribute_to_class(cls, name)
52 def has(model_instance):
53 return bool(getattr(model_instance, self.attname, None))
55 has.__name__ = str("has_%s" % self.attname)
56 has.short_description = self.name
58 setattr(cls, 'has_%s' % self.attname, has)
61 class BuildEbook(Task):
65 def register(cls, format_name):
66 """A decorator for registering subclasses for particular formats."""
68 cls.formats[format_name] = builder
73 def for_format(cls, format_name):
74 """Returns a celery task suitable for specified format."""
75 return cls.formats.get(format_name, BuildEbookTask)
78 def transform(wldoc, fieldfile):
79 """Transforms an librarian.WLDocument into an librarian.OutputFile.
81 By default, it just calls relevant wldoc.as_??? method.
84 return getattr(wldoc, "as_%s" % fieldfile.field.format_name)()
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))
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
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)
107 @BuildEbook.register('txt')
108 @task(ignore_result=True)
109 class BuildTxt(BuildEbook):
111 def transform(wldoc, fieldfile):
112 return wldoc.as_text()
115 @BuildEbook.register('pdf')
116 @task(ignore_result=True)
117 class BuildPdf(BuildEbook):
119 def transform(wldoc, fieldfile):
120 return wldoc.as_pdf(morefloats=settings.LIBRARIAN_PDF_MOREFLOATS, cover=True)
122 def build(self, fieldfile):
123 BuildEbook.build(self, fieldfile)
124 clear_cache(fieldfile.instance.slug)
127 @BuildEbook.register('epub')
128 @task(ignore_result=True)
129 class BuildEpub(BuildEbook):
131 def transform(wldoc, fieldfile):
132 return wldoc.as_epub(cover=True)
135 @BuildEbook.register('html')
136 @task(ignore_result=True)
137 class BuildHtml(BuildEbook):
138 def build(self, fieldfile):
139 from django.core.files.base import ContentFile
140 from fnpdjango.utils.text.slughifi import slughifi
141 from sortify import sortify
142 from librarian import html
143 from catalogue.models import Fragment, Tag
145 book = fieldfile.instance
147 html_output = self.transform(
148 book.wldocument(parse_dublincore=False),
151 # Delete old fragments, create from scratch if necessary.
152 book.fragments.all().delete()
155 meta_tags = list(book.tags.filter(
156 category__in=('author', 'epoch', 'genre', 'kind')))
159 lang = LANGUAGES_3TO2.get(lang, lang)
160 if lang not in [ln[0] for ln in settings.LANGUAGES]:
163 fieldfile.save(None, ContentFile(html_output.get_string()), save=False)
164 type(book).objects.filter(pk=book.pk).update(**{
165 fieldfile.field.attname: fieldfile
169 closed_fragments, open_fragments = html.extract_fragments(fieldfile.path)
170 for fragment in closed_fragments.values():
172 theme_names = [s.strip() for s in fragment.themes.split(',')]
173 except AttributeError:
176 for theme_name in theme_names:
179 if lang == settings.LANGUAGE_CODE:
180 # Allow creating themes if book in default language.
181 tag, created = Tag.objects.get_or_create(
182 slug=slughifi(theme_name),
185 tag.name = theme_name
186 setattr(tag, "name_%s" % lang, theme_name)
187 tag.sort_key = sortify(theme_name.lower())
190 elif lang is not None:
191 # Don't create unknown themes in non-default languages.
193 tag = Tag.objects.get(category='theme', **{"name_%s" % lang: theme_name})
194 except Tag.DoesNotExist:
201 text = fragment.to_string()
202 short_text = truncate_html_words(text, 15)
203 if text == short_text:
205 new_fragment = Fragment.objects.create(anchor=fragment.id, book=book, text=text, short_text=short_text)
208 new_fragment.tags = set(meta_tags + themes)
209 book.html_built.send(sender=type(self), instance=book)
214 @BuildEbook.register('cover_thumb')
215 @task(ignore_result=True)
216 class BuildCoverThumb(BuildEbook):
218 def transform(cls, wldoc, fieldfile):
219 from librarian.cover import WLCover
220 return WLCover(wldoc.book_info, height=193).output_file()
223 class OverwritingFieldFile(FieldFile):
225 Deletes the old file before saving the new one.
228 def save(self, name, content, *args, **kwargs):
229 leave = kwargs.pop('leave', None)
230 # delete if there's a file already and there's a new one coming
231 if not leave and self and (not hasattr(content, 'path') or content.path != self.path):
232 self.delete(save=False)
233 return super(OverwritingFieldFile, self).save(name, content, *args, **kwargs)
236 class OverwritingFileField(models.FileField):
237 attr_class = OverwritingFieldFile