Annoy in book text too.
[wolnelektury.git] / src / catalogue / models / book.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 collections import OrderedDict
6 from datetime import date, timedelta
7 from random import randint
8 import os.path
9 import re
10 import urllib
11 from django.conf import settings
12 from django.db import connection, models, transaction
13 from django.db.models import permalink
14 import django.dispatch
15 from django.contrib.contenttypes.fields import GenericRelation
16 from django.core.urlresolvers import reverse
17 from django.utils.translation import ugettext_lazy as _, get_language
18 from django.utils.deconstruct import deconstructible
19 import jsonfield
20 from fnpdjango.storage import BofhFileSystemStorage
21 from ssify import flush_ssi_includes
22
23 from librarian.cover import WLCover
24 from librarian.html import transform_abstrakt
25 from newtagging import managers
26 from catalogue import constants
27 from catalogue.fields import EbookField
28 from catalogue.models import Tag, Fragment, BookMedia
29 from catalogue.utils import create_zip, gallery_url, gallery_path, split_tags
30 from catalogue.models.tag import prefetched_relations
31 from catalogue import app_settings
32 from catalogue import tasks
33 from wolnelektury.utils import makedirs
34
35 bofh_storage = BofhFileSystemStorage()
36
37
38 @deconstructible
39 class UploadToPath(object):
40     def __init__(self, path):
41         self.path = path
42
43     def __call__(self, instance, filename):
44         return self.path % instance.slug
45
46
47 _cover_upload_to = UploadToPath('book/cover/%s.jpg')
48 _cover_thumb_upload_to = UploadToPath('book/cover_thumb/%s.jpg')
49 _cover_api_thumb_upload_to = UploadToPath('book/cover_api_thumb/%s.jpg')
50 _simple_cover_upload_to = UploadToPath('book/cover_simple/%s.jpg')
51
52
53 def _ebook_upload_to(upload_path):
54     return UploadToPath(upload_path)
55
56
57 class Book(models.Model):
58     """Represents a book imported from WL-XML."""
59     title = models.CharField(_('title'), max_length=32767)
60     sort_key = models.CharField(_('sort key'), max_length=120, db_index=True, editable=False)
61     sort_key_author = models.CharField(
62         _('sort key by author'), max_length=120, db_index=True, editable=False, default=u'')
63     slug = models.SlugField(_('slug'), max_length=120, db_index=True, unique=True)
64     common_slug = models.SlugField(_('slug'), max_length=120, db_index=True)
65     language = models.CharField(_('language code'), max_length=3, db_index=True, default=app_settings.DEFAULT_LANGUAGE)
66     description = models.TextField(_('description'), blank=True)
67     abstract = models.TextField(_('abstract'), blank=True)
68     created_at = models.DateTimeField(_('creation date'), auto_now_add=True, db_index=True)
69     changed_at = models.DateTimeField(_('change date'), auto_now=True, db_index=True)
70     parent_number = models.IntegerField(_('parent number'), default=0)
71     extra_info = jsonfield.JSONField(_('extra information'), default={})
72     gazeta_link = models.CharField(blank=True, max_length=240)
73     wiki_link = models.CharField(blank=True, max_length=240)
74     print_on_demand = models.BooleanField(_('print on demand'), default=False)
75     recommended = models.BooleanField(_('recommended'), default=False)
76     audio_length = models.CharField(_('audio length'), blank=True, max_length=8)
77     preview = models.BooleanField(_('preview'), default=False)
78     preview_until = models.DateField(_('preview until'), blank=True, null=True)
79
80     # files generated during publication
81     cover = EbookField(
82         'cover', _('cover'),
83         null=True, blank=True,
84         upload_to=_cover_upload_to,
85         storage=bofh_storage, max_length=255)
86     # Cleaner version of cover for thumbs
87     cover_thumb = EbookField(
88         'cover_thumb', _('cover thumbnail'),
89         null=True, blank=True,
90         upload_to=_cover_thumb_upload_to,
91         max_length=255)
92     cover_api_thumb = EbookField(
93         'cover_api_thumb', _('cover thumbnail for mobile app'),
94         null=True, blank=True,
95         upload_to=_cover_api_thumb_upload_to,
96         max_length=255)
97     simple_cover = EbookField(
98         'simple_cover', _('cover for mobile app'),
99         null=True, blank=True,
100         upload_to=_simple_cover_upload_to,
101         max_length=255)
102     ebook_formats = constants.EBOOK_FORMATS
103     formats = ebook_formats + ['html', 'xml']
104
105     parent = models.ForeignKey('self', blank=True, null=True, related_name='children')
106     ancestor = models.ManyToManyField('self', blank=True, editable=False, related_name='descendant', symmetrical=False)
107
108     cached_author = models.CharField(blank=True, max_length=240, db_index=True)
109     has_audience = models.BooleanField(default=False)
110
111     objects = models.Manager()
112     tagged = managers.ModelTaggedItemManager(Tag)
113     tags = managers.TagDescriptor(Tag)
114     tag_relations = GenericRelation(Tag.intermediary_table_model)
115
116     html_built = django.dispatch.Signal()
117     published = django.dispatch.Signal()
118
119     SORT_KEY_SEP = '$'
120
121     class AlreadyExists(Exception):
122         pass
123
124     class Meta:
125         ordering = ('sort_key_author', 'sort_key')
126         verbose_name = _('book')
127         verbose_name_plural = _('books')
128         app_label = 'catalogue'
129
130     def __str__(self):
131         return self.title
132
133     def get_initial(self):
134         try:
135             return re.search(r'\w', self.title, re.U).group(0)
136         except AttributeError:
137             return ''
138
139     def authors(self):
140         return self.tags.filter(category='author')
141
142     def epochs(self):
143         return self.tags.filter(category='epoch')
144
145     def genres(self):
146         return self.tags.filter(category='genre')
147
148     def kinds(self):
149         return self.tags.filter(category='kind')
150
151     def tag_unicode(self, category):
152         relations = prefetched_relations(self, category)
153         if relations:
154             return ', '.join(rel.tag.name for rel in relations)
155         else:
156             return ', '.join(self.tags.filter(category=category).values_list('name', flat=True))
157
158     def tags_by_category(self):
159         return split_tags(self.tags.exclude(category__in=('set', 'theme')))
160
161     def author_unicode(self):
162         return self.cached_author
163
164     def kind_unicode(self):
165         return self.tag_unicode('kind')
166
167     def epoch_unicode(self):
168         return self.tag_unicode('epoch')
169
170     def genre_unicode(self):
171         return self.tag_unicode('genre')
172
173     def translator(self):
174         translators = self.extra_info.get('translators')
175         if not translators:
176             return None
177         if len(translators) > 3:
178             translators = translators[:2]
179             others = ' i inni'
180         else:
181             others = ''
182         return ', '.join(u'\xa0'.join(reversed(translator.split(', ', 1))) for translator in translators) + others
183
184     def cover_source(self):
185         return self.extra_info.get('cover_source', self.parent.cover_source() if self.parent else '')
186
187     def save(self, force_insert=False, force_update=False, **kwargs):
188         from sortify import sortify
189
190         self.sort_key = sortify(self.title)[:120]
191         self.title = str(self.title)  # ???
192
193         try:
194             author = self.authors().first().sort_key
195         except AttributeError:
196             author = u''
197         self.sort_key_author = author
198
199         self.cached_author = self.tag_unicode('author')
200         self.has_audience = 'audience' in self.extra_info
201
202         ret = super(Book, self).save(force_insert, force_update, **kwargs)
203
204         return ret
205
206     @permalink
207     def get_absolute_url(self):
208         return 'book_detail', [self.slug]
209
210     def gallery_path(self):
211         return gallery_path(self.slug)
212
213     def gallery_url(self):
214         return gallery_url(self.slug)
215
216     @property
217     def name(self):
218         return self.title
219
220     def language_code(self):
221         return constants.LANGUAGES_3TO2.get(self.language, self.language)
222
223     def language_name(self):
224         return dict(settings.LANGUAGES).get(self.language_code(), "")
225
226     def is_foreign(self):
227         return self.language_code() != settings.LANGUAGE_CODE
228
229     def set_audio_length(self):
230         length = self.get_audio_length()
231         if length > 0:
232             self.audio_length = self.format_audio_length(length)
233             self.save()
234
235     @staticmethod
236     def format_audio_length(seconds):
237         if seconds < 60*60:
238             minutes = seconds // 60
239             seconds = seconds % 60
240             return '%d:%02d' % (minutes, seconds)
241         else:
242             hours = seconds // 3600
243             minutes = seconds % 3600 // 60
244             seconds = seconds % 60
245             return '%d:%02d:%02d' % (hours, minutes, seconds)
246
247     def get_audio_length(self):
248         total = 0
249         for media in self.get_mp3() or ():
250             total += app_settings.GET_MP3_LENGTH(media.file.path)
251         return int(total)
252
253     def has_media(self, type_):
254         if type_ in Book.formats:
255             return bool(getattr(self, "%s_file" % type_))
256         else:
257             return self.media.filter(type=type_).exists()
258
259     def has_audio(self):
260         return self.has_media('mp3')
261
262     def get_media(self, type_):
263         if self.has_media(type_):
264             if type_ in Book.formats:
265                 return getattr(self, "%s_file" % type_)
266             else:
267                 return self.media.filter(type=type_)
268         else:
269             return None
270
271     def get_mp3(self):
272         return self.get_media("mp3")
273
274     def get_odt(self):
275         return self.get_media("odt")
276
277     def get_ogg(self):
278         return self.get_media("ogg")
279
280     def get_daisy(self):
281         return self.get_media("daisy")
282
283     def media_url(self, format_):
284         media = self.get_media(format_)
285         if media:
286             if self.preview:
287                 return reverse('embargo_link', kwargs={'slug': self.slug, 'format_': format_})
288             else:
289                 return media.url
290         else:
291             return None
292
293     def html_url(self):
294         return self.media_url('html')
295
296     def pdf_url(self):
297         return self.media_url('pdf')
298
299     def epub_url(self):
300         return self.media_url('epub')
301
302     def mobi_url(self):
303         return self.media_url('mobi')
304
305     def txt_url(self):
306         return self.media_url('txt')
307
308     def fb2_url(self):
309         return self.media_url('fb2')
310
311     def xml_url(self):
312         return self.media_url('xml')
313
314     def has_description(self):
315         return len(self.description) > 0
316     has_description.short_description = _('description')
317     has_description.boolean = True
318
319     def has_mp3_file(self):
320         return self.has_media("mp3")
321     has_mp3_file.short_description = 'MP3'
322     has_mp3_file.boolean = True
323
324     def has_ogg_file(self):
325         return self.has_media("ogg")
326     has_ogg_file.short_description = 'OGG'
327     has_ogg_file.boolean = True
328
329     def has_daisy_file(self):
330         return self.has_media("daisy")
331     has_daisy_file.short_description = 'DAISY'
332     has_daisy_file.boolean = True
333
334     def get_audiobooks(self):
335         ogg_files = {}
336         for m in self.media.filter(type='ogg').order_by().iterator():
337             ogg_files[m.name] = m
338
339         audiobooks = []
340         projects = set()
341         for mp3 in self.media.filter(type='mp3').iterator():
342             # ogg files are always from the same project
343             meta = mp3.extra_info
344             project = meta.get('project')
345             if not project:
346                 # temporary fallback
347                 project = u'CzytamySłuchając'
348
349             projects.add((project, meta.get('funded_by', '')))
350
351             media = {'mp3': mp3}
352
353             ogg = ogg_files.get(mp3.name)
354             if ogg:
355                 media['ogg'] = ogg
356             audiobooks.append(media)
357
358         projects = sorted(projects)
359         return audiobooks, projects
360
361     def wldocument(self, parse_dublincore=True, inherit=True):
362         from catalogue.import_utils import ORMDocProvider
363         from librarian.parser import WLDocument
364
365         if inherit and self.parent:
366             meta_fallbacks = self.parent.cover_info()
367         else:
368             meta_fallbacks = None
369
370         return WLDocument.from_file(
371             self.xml_file.path,
372             provider=ORMDocProvider(self),
373             parse_dublincore=parse_dublincore,
374             meta_fallbacks=meta_fallbacks)
375
376     @staticmethod
377     def zip_format(format_):
378         def pretty_file_name(book):
379             return "%s/%s.%s" % (
380                 book.extra_info['author'],
381                 book.slug,
382                 format_)
383
384         field_name = "%s_file" % format_
385         books = Book.objects.filter(parent=None).exclude(**{field_name: ""}).exclude(preview=True)
386         paths = [(pretty_file_name(b), getattr(b, field_name).path) for b in books.iterator()]
387         return create_zip(paths, app_settings.FORMAT_ZIPS[format_])
388
389     def zip_audiobooks(self, format_):
390         bm = BookMedia.objects.filter(book=self, type=format_)
391         paths = map(lambda bm: (None, bm.file.path), bm)
392         return create_zip(paths, "%s_%s" % (self.slug, format_))
393
394     def search_index(self, book_info=None, index=None, index_tags=True, commit=True):
395         if index is None:
396             from search.index import Index
397             index = Index()
398         try:
399             index.index_book(self, book_info)
400             if index_tags:
401                 index.index_tags()
402             if commit:
403                 index.index.commit()
404         except Exception as e:
405             index.index.rollback()
406             raise e
407
408     # will make problems in conjunction with paid previews
409     def download_pictures(self, remote_gallery_url):
410         gallery_path = self.gallery_path()
411         # delete previous files, so we don't include old files in ebooks
412         if os.path.isdir(gallery_path):
413             for filename in os.listdir(gallery_path):
414                 file_path = os.path.join(gallery_path, filename)
415                 os.unlink(file_path)
416         ilustr_elements = list(self.wldocument().edoc.findall('//ilustr'))
417         if ilustr_elements:
418             makedirs(gallery_path)
419             for ilustr in ilustr_elements:
420                 ilustr_src = ilustr.get('src')
421                 ilustr_path = os.path.join(gallery_path, ilustr_src)
422                 urllib.urlretrieve('%s/%s' % (remote_gallery_url, ilustr_src), ilustr_path)
423
424     def load_abstract(self):
425         abstract = self.wldocument(parse_dublincore=False).edoc.getroot().find('.//abstrakt')
426         if abstract is not None:
427             self.abstract = transform_abstrakt(abstract)
428         else:
429             self.abstract = ''
430
431     @classmethod
432     def from_xml_file(cls, xml_file, **kwargs):
433         from django.core.files import File
434         from librarian import dcparser
435
436         # use librarian to parse meta-data
437         book_info = dcparser.parse(xml_file)
438
439         if not isinstance(xml_file, File):
440             xml_file = File(open(xml_file))
441
442         try:
443             return cls.from_text_and_meta(xml_file, book_info, **kwargs)
444         finally:
445             xml_file.close()
446
447     @classmethod
448     def from_text_and_meta(cls, raw_file, book_info, overwrite=False, dont_build=None, search_index=True,
449                            search_index_tags=True, remote_gallery_url=None, days=0):
450         if dont_build is None:
451             dont_build = set()
452         dont_build = set.union(set(dont_build), set(app_settings.DONT_BUILD))
453
454         # check for parts before we do anything
455         children = []
456         if hasattr(book_info, 'parts'):
457             for part_url in book_info.parts:
458                 try:
459                     children.append(Book.objects.get(slug=part_url.slug))
460                 except Book.DoesNotExist:
461                     raise Book.DoesNotExist(_('Book "%s" does not exist.') % part_url.slug)
462
463         # Read book metadata
464         book_slug = book_info.url.slug
465         if re.search(r'[^a-z0-9-]', book_slug):
466             raise ValueError('Invalid characters in slug')
467         book, created = Book.objects.get_or_create(slug=book_slug)
468
469         if created:
470             book_shelves = []
471             old_cover = None
472             book.preview = bool(days)
473             if book.preview:
474                 book.preview_until = date.today() + timedelta(days)
475         else:
476             if not overwrite:
477                 raise Book.AlreadyExists(_('Book %s already exists') % book_slug)
478             # Save shelves for this book
479             book_shelves = list(book.tags.filter(category='set'))
480             old_cover = book.cover_info()
481
482         # Save XML file
483         book.xml_file.save('%s.xml' % book.slug, raw_file, save=False)
484         if book.preview:
485             book.xml_file.set_readable(False)
486
487         book.language = book_info.language
488         book.title = book_info.title
489         if book_info.variant_of:
490             book.common_slug = book_info.variant_of.slug
491         else:
492             book.common_slug = book.slug
493         book.extra_info = book_info.to_dict()
494         book.load_abstract()
495         book.save()
496
497         meta_tags = Tag.tags_from_info(book_info)
498
499         for tag in meta_tags:
500             if not tag.for_books:
501                 tag.for_books = True
502                 tag.save()
503
504         book.tags = set(meta_tags + book_shelves)
505
506         cover_changed = old_cover != book.cover_info()
507         obsolete_children = set(b for b in book.children.all()
508                                 if b not in children)
509         notify_cover_changed = []
510         for n, child_book in enumerate(children):
511             new_child = child_book.parent != book
512             child_book.parent = book
513             child_book.parent_number = n
514             child_book.save()
515             if new_child or cover_changed:
516                 notify_cover_changed.append(child_book)
517         # Disown unfaithful children and let them cope on their own.
518         for child in obsolete_children:
519             child.parent = None
520             child.parent_number = 0
521             child.save()
522             if old_cover:
523                 notify_cover_changed.append(child)
524
525         cls.repopulate_ancestors()
526         tasks.update_counters.delay()
527
528         if remote_gallery_url:
529             book.download_pictures(remote_gallery_url)
530
531         # No saves beyond this point.
532
533         # Build cover.
534         if 'cover' not in dont_build:
535             book.cover.build_delay()
536             book.cover_thumb.build_delay()
537             book.cover_api_thumb.build_delay()
538             book.simple_cover.build_delay()
539
540         # Build HTML and ebooks.
541         book.html_file.build_delay()
542         if not children:
543             for format_ in constants.EBOOK_FORMATS_WITHOUT_CHILDREN:
544                 if format_ not in dont_build:
545                     getattr(book, '%s_file' % format_).build_delay()
546         for format_ in constants.EBOOK_FORMATS_WITH_CHILDREN:
547             if format_ not in dont_build:
548                 getattr(book, '%s_file' % format_).build_delay()
549
550         if not settings.NO_SEARCH_INDEX and search_index:
551             tasks.index_book.delay(book.id, book_info=book_info, index_tags=search_index_tags)
552
553         for child in notify_cover_changed:
554             child.parent_cover_changed()
555
556         book.save()  # update sort_key_author
557         book.update_popularity()
558         cls.published.send(sender=cls, instance=book)
559         return book
560
561     @classmethod
562     @transaction.atomic
563     def repopulate_ancestors(cls):
564         """Fixes the ancestry cache."""
565         # TODO: table names
566         cursor = connection.cursor()
567         if connection.vendor == 'postgres':
568             cursor.execute("TRUNCATE catalogue_book_ancestor")
569             cursor.execute("""
570                 WITH RECURSIVE ancestry AS (
571                     SELECT book.id, book.parent_id
572                     FROM catalogue_book AS book
573                     WHERE book.parent_id IS NOT NULL
574                     UNION
575                     SELECT ancestor.id, book.parent_id
576                     FROM ancestry AS ancestor, catalogue_book AS book
577                     WHERE ancestor.parent_id = book.id
578                         AND book.parent_id IS NOT NULL
579                     )
580                 INSERT INTO catalogue_book_ancestor
581                     (from_book_id, to_book_id)
582                     SELECT id, parent_id
583                     FROM ancestry
584                     ORDER BY id;
585                 """)
586         else:
587             cursor.execute("DELETE FROM catalogue_book_ancestor")
588             for b in cls.objects.exclude(parent=None):
589                 parent = b.parent
590                 while parent is not None:
591                     b.ancestor.add(parent)
592                     parent = parent.parent
593
594     def flush_includes(self, languages=True):
595         if not languages:
596             return
597         if languages is True:
598             languages = [lc for (lc, _ln) in settings.LANGUAGES]
599         flush_ssi_includes([
600             template % (self.pk, lang)
601             for template in [
602                 '/katalog/b/%d/mini.%s.html',
603                 '/katalog/b/%d/mini_nolink.%s.html',
604                 '/katalog/b/%d/short.%s.html',
605                 '/katalog/b/%d/wide.%s.html',
606                 '/api/include/book/%d.%s.json',
607                 '/api/include/book/%d.%s.xml',
608                 ]
609             for lang in languages
610             ])
611
612     def cover_info(self, inherit=True):
613         """Returns a dictionary to serve as fallback for BookInfo.
614
615         For now, the only thing inherited is the cover image.
616         """
617         need = False
618         info = {}
619         for field in ('cover_url', 'cover_by', 'cover_source'):
620             val = self.extra_info.get(field)
621             if val:
622                 info[field] = val
623             else:
624                 need = True
625         if inherit and need and self.parent is not None:
626             parent_info = self.parent.cover_info()
627             parent_info.update(info)
628             info = parent_info
629         return info
630
631     def related_themes(self):
632         return Tag.objects.usage_for_queryset(
633             Fragment.objects.filter(models.Q(book=self) | models.Q(book__ancestor=self)),
634             counts=True).filter(category='theme')
635
636     def parent_cover_changed(self):
637         """Called when parent book's cover image is changed."""
638         if not self.cover_info(inherit=False):
639             if 'cover' not in app_settings.DONT_BUILD:
640                 self.cover.build_delay()
641                 self.cover_thumb.build_delay()
642                 self.cover_api_thumb.build_delay()
643                 self.simple_cover.build_delay()
644             for format_ in constants.EBOOK_FORMATS_WITH_COVERS:
645                 if format_ not in app_settings.DONT_BUILD:
646                     getattr(self, '%s_file' % format_).build_delay()
647             for child in self.children.all():
648                 child.parent_cover_changed()
649
650     def other_versions(self):
651         """Find other versions (i.e. in other languages) of the book."""
652         return type(self).objects.filter(common_slug=self.common_slug).exclude(pk=self.pk)
653
654     def parents(self):
655         books = []
656         parent = self.parent
657         while parent is not None:
658             books.insert(0, parent)
659             parent = parent.parent
660         return books
661
662     def pretty_title(self, html_links=False):
663         names = [(tag.name, tag.get_absolute_url()) for tag in self.authors().only('name', 'category', 'slug')]
664         books = self.parents() + [self]
665         names.extend([(b.title, b.get_absolute_url()) for b in books])
666
667         if html_links:
668             names = ['<a href="%s">%s</a>' % (tag[1], tag[0]) for tag in names]
669         else:
670             names = [tag[0] for tag in names]
671         return ', '.join(names)
672
673     def publisher(self):
674         publisher = self.extra_info['publisher']
675         if isinstance(publisher, str):
676             return publisher
677         elif isinstance(publisher, list):
678             return ', '.join(publisher)
679
680     @classmethod
681     def tagged_top_level(cls, tags):
682         """ Returns top-level books tagged with `tags`.
683
684         It only returns those books which don't have ancestors which are
685         also tagged with those tags.
686
687         """
688         objects = cls.tagged.with_all(tags)
689         return objects.exclude(ancestor__in=objects)
690
691     @classmethod
692     def book_list(cls, book_filter=None):
693         """Generates a hierarchical listing of all books.
694
695         Books are optionally filtered with a test function.
696
697         """
698
699         books_by_parent = {}
700         books = cls.objects.order_by('parent_number', 'sort_key').only('title', 'parent', 'slug', 'extra_info')
701         if book_filter:
702             books = books.filter(book_filter).distinct()
703
704             book_ids = set(b['pk'] for b in books.values("pk").iterator())
705             for book in books.iterator():
706                 parent = book.parent_id
707                 if parent not in book_ids:
708                     parent = None
709                 books_by_parent.setdefault(parent, []).append(book)
710         else:
711             for book in books.iterator():
712                 books_by_parent.setdefault(book.parent_id, []).append(book)
713
714         orphans = []
715         books_by_author = OrderedDict()
716         for tag in Tag.objects.filter(category='author').iterator():
717             books_by_author[tag] = []
718
719         for book in books_by_parent.get(None, ()):
720             authors = list(book.authors().only('pk'))
721             if authors:
722                 for author in authors:
723                     books_by_author[author].append(book)
724             else:
725                 orphans.append(book)
726
727         return books_by_author, orphans, books_by_parent
728
729     _audiences_pl = {
730         "SP": (1, u"szkoła podstawowa"),
731         "SP1": (1, u"szkoła podstawowa"),
732         "SP2": (1, u"szkoła podstawowa"),
733         "SP3": (1, u"szkoła podstawowa"),
734         "P": (1, u"szkoła podstawowa"),
735         "G": (2, u"gimnazjum"),
736         "L": (3, u"liceum"),
737         "LP": (3, u"liceum"),
738     }
739
740     def audiences_pl(self):
741         audiences = self.extra_info.get('audiences', [])
742         audiences = sorted(set([self._audiences_pl.get(a, (99, a)) for a in audiences]))
743         return [a[1] for a in audiences]
744
745     def stage_note(self):
746         stage = self.extra_info.get('stage')
747         if stage and stage < '0.4':
748             return (_('This work needs modernisation'),
749                     reverse('infopage', args=['wymagajace-uwspolczesnienia']))
750         else:
751             return None, None
752
753     def choose_fragment(self):
754         fragments = self.fragments.order_by()
755         fragments_count = fragments.count()
756         if not fragments_count and self.children.exists():
757             fragments = Fragment.objects.filter(book__ancestor=self).order_by()
758             fragments_count = fragments.count()
759         if fragments_count:
760             return fragments[randint(0, fragments_count - 1)]
761         elif self.parent:
762             return self.parent.choose_fragment()
763         else:
764             return None
765
766     def fragment_data(self):
767         fragment = self.choose_fragment()
768         if fragment:
769             return {
770                 'title': fragment.book.pretty_title(),
771                 'html': re.sub('</?blockquote[^>]*>', '', fragment.get_short_text()),
772             }
773         else:
774             return None
775
776     def update_popularity(self):
777         count = self.tags.filter(category='set').values('user').order_by('user').distinct().count()
778         try:
779             pop = self.popularity
780             pop.count = count
781             pop.save()
782         except BookPopularity.DoesNotExist:
783             BookPopularity.objects.create(book=self, count=count)
784
785     def ridero_link(self):
786         return 'https://ridero.eu/%s/books/wl_%s/' % (get_language(), self.slug.replace('-', '_'))
787
788     def like(self, user):
789         from social.utils import likes, get_set, set_sets
790         if not likes(user, self):
791             tag = get_set(user, '')
792             set_sets(user, self, [tag])
793
794     def unlike(self, user):
795         from social.utils import likes, set_sets
796         if likes(user, self):
797             set_sets(user, self, [])
798
799     def full_sort_key(self):
800         return self.SORT_KEY_SEP.join((self.sort_key_author, self.sort_key, str(self.id)))
801
802     def cover_color(self):
803         return WLCover.epoch_colors.get(self.extra_info.get('epoch'), '#000000')
804
805
806 def add_file_fields():
807     for format_ in Book.formats:
808         field_name = "%s_file" % format_
809         # This weird globals() assignment makes Django migrations comfortable.
810         _upload_to = _ebook_upload_to('book/%s/%%s.%s' % (format_, format_))
811         _upload_to.__name__ = '_%s_upload_to' % format_
812         globals()[_upload_to.__name__] = _upload_to
813
814         EbookField(
815             format_, _("%s file" % format_.upper()),
816             upload_to=_upload_to,
817             storage=bofh_storage,
818             max_length=255,
819             blank=True,
820             default=''
821         ).contribute_to_class(Book, field_name)
822
823
824 add_file_fields()
825
826
827 class BookPopularity(models.Model):
828     book = models.OneToOneField(Book, related_name='popularity')
829     count = models.IntegerField(default=0, db_index=True)