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