068bae899799f7cf20da69213d39d32938176ded
[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 __unicode__(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 = unicode(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     @staticmethod
211     @permalink
212     def create_url(slug):
213         return 'book_detail', [slug]
214
215     def gallery_path(self):
216         return gallery_path(self.slug)
217
218     def gallery_url(self):
219         return gallery_url(self.slug)
220
221     @property
222     def name(self):
223         return self.title
224
225     def language_code(self):
226         return constants.LANGUAGES_3TO2.get(self.language, self.language)
227
228     def language_name(self):
229         return dict(settings.LANGUAGES).get(self.language_code(), "")
230
231     def is_foreign(self):
232         return self.language_code() != settings.LANGUAGE_CODE
233
234     def set_audio_length(self):
235         length = self.get_audio_length()
236         if length > 0:
237             self.audio_length = self.format_audio_length(length)
238             self.save()
239
240     @staticmethod
241     def format_audio_length(seconds):
242         if seconds < 60*60:
243             minutes = seconds // 60
244             seconds = seconds % 60
245             return '%d:%02d' % (minutes, seconds)
246         else:
247             hours = seconds // 3600
248             minutes = seconds % 3600 // 60
249             seconds = seconds % 60
250             return '%d:%02d:%02d' % (hours, minutes, seconds)
251
252     def get_audio_length(self):
253         total = 0
254         for media in self.get_mp3() or ():
255             total += app_settings.GET_MP3_LENGTH(media.file.path)
256         return int(total)
257
258     def has_media(self, type_):
259         if type_ in Book.formats:
260             return bool(getattr(self, "%s_file" % type_))
261         else:
262             return self.media.filter(type=type_).exists()
263
264     def has_audio(self):
265         return self.has_media('mp3')
266
267     def get_media(self, type_):
268         if self.has_media(type_):
269             if type_ in Book.formats:
270                 return getattr(self, "%s_file" % type_)
271             else:
272                 return self.media.filter(type=type_)
273         else:
274             return None
275
276     def get_mp3(self):
277         return self.get_media("mp3")
278
279     def get_odt(self):
280         return self.get_media("odt")
281
282     def get_ogg(self):
283         return self.get_media("ogg")
284
285     def get_daisy(self):
286         return self.get_media("daisy")
287
288     def media_url(self, format_):
289         media = self.get_media(format_)
290         if media:
291             if self.preview:
292                 return reverse('embargo_link', kwargs={'slug': self.slug, 'format_': format_})
293             else:
294                 return media.url
295         else:
296             return None
297
298     def html_url(self):
299         return self.media_url('html')
300
301     def pdf_url(self):
302         return self.media_url('pdf')
303
304     def epub_url(self):
305         return self.media_url('epub')
306
307     def mobi_url(self):
308         return self.media_url('mobi')
309
310     def txt_url(self):
311         return self.media_url('txt')
312
313     def fb2_url(self):
314         return self.media_url('fb2')
315
316     def xml_url(self):
317         return self.media_url('xml')
318
319     def has_description(self):
320         return len(self.description) > 0
321     has_description.short_description = _('description')
322     has_description.boolean = True
323
324     def has_mp3_file(self):
325         return self.has_media("mp3")
326     has_mp3_file.short_description = 'MP3'
327     has_mp3_file.boolean = True
328
329     def has_ogg_file(self):
330         return self.has_media("ogg")
331     has_ogg_file.short_description = 'OGG'
332     has_ogg_file.boolean = True
333
334     def has_daisy_file(self):
335         return self.has_media("daisy")
336     has_daisy_file.short_description = 'DAISY'
337     has_daisy_file.boolean = True
338
339     def get_audiobooks(self):
340         ogg_files = {}
341         for m in self.media.filter(type='ogg').order_by().iterator():
342             ogg_files[m.name] = m
343
344         audiobooks = []
345         projects = set()
346         for mp3 in self.media.filter(type='mp3').iterator():
347             # ogg files are always from the same project
348             meta = mp3.extra_info
349             project = meta.get('project')
350             if not project:
351                 # temporary fallback
352                 project = u'CzytamySłuchając'
353
354             projects.add((project, meta.get('funded_by', '')))
355
356             media = {'mp3': mp3}
357
358             ogg = ogg_files.get(mp3.name)
359             if ogg:
360                 media['ogg'] = ogg
361             audiobooks.append(media)
362
363         projects = sorted(projects)
364         return audiobooks, projects
365
366     def wldocument(self, parse_dublincore=True, inherit=True):
367         from catalogue.import_utils import ORMDocProvider
368         from librarian.parser import WLDocument
369
370         if inherit and self.parent:
371             meta_fallbacks = self.parent.cover_info()
372         else:
373             meta_fallbacks = None
374
375         return WLDocument.from_file(
376             self.xml_file.path,
377             provider=ORMDocProvider(self),
378             parse_dublincore=parse_dublincore,
379             meta_fallbacks=meta_fallbacks)
380
381     @staticmethod
382     def zip_format(format_):
383         def pretty_file_name(book):
384             return "%s/%s.%s" % (
385                 book.extra_info['author'],
386                 book.slug,
387                 format_)
388
389         field_name = "%s_file" % format_
390         books = Book.objects.filter(parent=None).exclude(**{field_name: ""}).exclude(preview=True)
391         paths = [(pretty_file_name(b), getattr(b, field_name).path) for b in books.iterator()]
392         return create_zip(paths, app_settings.FORMAT_ZIPS[format_])
393
394     def zip_audiobooks(self, format_):
395         bm = BookMedia.objects.filter(book=self, type=format_)
396         paths = map(lambda bm: (None, bm.file.path), bm)
397         return create_zip(paths, "%s_%s" % (self.slug, format_))
398
399     def search_index(self, book_info=None, index=None, index_tags=True, commit=True):
400         if index is None:
401             from search.index import Index
402             index = Index()
403         try:
404             index.index_book(self, book_info)
405             if index_tags:
406                 index.index_tags()
407             if commit:
408                 index.index.commit()
409         except Exception, e:
410             index.index.rollback()
411             raise e
412
413     # will make problems in conjunction with paid previews
414     def download_pictures(self, remote_gallery_url):
415         gallery_path = self.gallery_path()
416         # delete previous files, so we don't include old files in ebooks
417         if os.path.isdir(gallery_path):
418             for filename in os.listdir(gallery_path):
419                 file_path = os.path.join(gallery_path, filename)
420                 os.unlink(file_path)
421         ilustr_elements = list(self.wldocument().edoc.findall('//ilustr'))
422         if ilustr_elements:
423             makedirs(gallery_path)
424             for ilustr in ilustr_elements:
425                 ilustr_src = ilustr.get('src')
426                 ilustr_path = os.path.join(gallery_path, ilustr_src)
427                 urllib.urlretrieve('%s/%s' % (remote_gallery_url, ilustr_src), ilustr_path)
428
429     def load_abstract(self):
430         abstract = self.wldocument(parse_dublincore=False).edoc.getroot().find('.//abstrakt')
431         if abstract is not None:
432             self.abstract = transform_abstrakt(abstract)
433         else:
434             self.abstract = ''
435
436     @classmethod
437     def from_xml_file(cls, xml_file, **kwargs):
438         from django.core.files import File
439         from librarian import dcparser
440
441         # use librarian to parse meta-data
442         book_info = dcparser.parse(xml_file)
443
444         if not isinstance(xml_file, File):
445             xml_file = File(open(xml_file))
446
447         try:
448             return cls.from_text_and_meta(xml_file, book_info, **kwargs)
449         finally:
450             xml_file.close()
451
452     @classmethod
453     def from_text_and_meta(cls, raw_file, book_info, overwrite=False, dont_build=None, search_index=True,
454                            search_index_tags=True, remote_gallery_url=None, days=0):
455         if dont_build is None:
456             dont_build = set()
457         dont_build = set.union(set(dont_build), set(app_settings.DONT_BUILD))
458
459         # check for parts before we do anything
460         children = []
461         if hasattr(book_info, 'parts'):
462             for part_url in book_info.parts:
463                 try:
464                     children.append(Book.objects.get(slug=part_url.slug))
465                 except Book.DoesNotExist:
466                     raise Book.DoesNotExist(_('Book "%s" does not exist.') % part_url.slug)
467
468         # Read book metadata
469         book_slug = book_info.url.slug
470         if re.search(r'[^a-z0-9-]', book_slug):
471             raise ValueError('Invalid characters in slug')
472         book, created = Book.objects.get_or_create(slug=book_slug)
473
474         if created:
475             book_shelves = []
476             old_cover = None
477             book.preview = bool(days)
478             if book.preview:
479                 book.preview_until = date.today() + timedelta(days)
480         else:
481             if not overwrite:
482                 raise Book.AlreadyExists(_('Book %s already exists') % book_slug)
483             # Save shelves for this book
484             book_shelves = list(book.tags.filter(category='set'))
485             old_cover = book.cover_info()
486
487         # Save XML file
488         book.xml_file.save('%s.xml' % book.slug, raw_file, save=False)
489         if book.preview:
490             book.xml_file.set_readable(False)
491
492         book.language = book_info.language
493         book.title = book_info.title
494         if book_info.variant_of:
495             book.common_slug = book_info.variant_of.slug
496         else:
497             book.common_slug = book.slug
498         book.extra_info = book_info.to_dict()
499         book.load_abstract()
500         book.save()
501
502         meta_tags = Tag.tags_from_info(book_info)
503
504         for tag in meta_tags:
505             if not tag.for_books:
506                 tag.for_books = True
507                 tag.save()
508
509         book.tags = set(meta_tags + book_shelves)
510
511         cover_changed = old_cover != book.cover_info()
512         obsolete_children = set(b for b in book.children.all()
513                                 if b not in children)
514         notify_cover_changed = []
515         for n, child_book in enumerate(children):
516             new_child = child_book.parent != book
517             child_book.parent = book
518             child_book.parent_number = n
519             child_book.save()
520             if new_child or cover_changed:
521                 notify_cover_changed.append(child_book)
522         # Disown unfaithful children and let them cope on their own.
523         for child in obsolete_children:
524             child.parent = None
525             child.parent_number = 0
526             child.save()
527             if old_cover:
528                 notify_cover_changed.append(child)
529
530         cls.repopulate_ancestors()
531         tasks.update_counters.delay()
532
533         if remote_gallery_url:
534             book.download_pictures(remote_gallery_url)
535
536         # No saves beyond this point.
537
538         # Build cover.
539         if 'cover' not in dont_build:
540             book.cover.build_delay()
541             book.cover_thumb.build_delay()
542             book.cover_api_thumb.build_delay()
543             book.simple_cover.build_delay()
544
545         # Build HTML and ebooks.
546         book.html_file.build_delay()
547         if not children:
548             for format_ in constants.EBOOK_FORMATS_WITHOUT_CHILDREN:
549                 if format_ not in dont_build:
550                     getattr(book, '%s_file' % format_).build_delay()
551         for format_ in constants.EBOOK_FORMATS_WITH_CHILDREN:
552             if format_ not in dont_build:
553                 getattr(book, '%s_file' % format_).build_delay()
554
555         if not settings.NO_SEARCH_INDEX and search_index:
556             tasks.index_book.delay(book.id, book_info=book_info, index_tags=search_index_tags)
557
558         for child in notify_cover_changed:
559             child.parent_cover_changed()
560
561         book.save()  # update sort_key_author
562         book.update_popularity()
563         cls.published.send(sender=cls, instance=book)
564         return book
565
566     @classmethod
567     @transaction.atomic
568     def repopulate_ancestors(cls):
569         """Fixes the ancestry cache."""
570         # TODO: table names
571         cursor = connection.cursor()
572         if connection.vendor == 'postgres':
573             cursor.execute("TRUNCATE catalogue_book_ancestor")
574             cursor.execute("""
575                 WITH RECURSIVE ancestry AS (
576                     SELECT book.id, book.parent_id
577                     FROM catalogue_book AS book
578                     WHERE book.parent_id IS NOT NULL
579                     UNION
580                     SELECT ancestor.id, book.parent_id
581                     FROM ancestry AS ancestor, catalogue_book AS book
582                     WHERE ancestor.parent_id = book.id
583                         AND book.parent_id IS NOT NULL
584                     )
585                 INSERT INTO catalogue_book_ancestor
586                     (from_book_id, to_book_id)
587                     SELECT id, parent_id
588                     FROM ancestry
589                     ORDER BY id;
590                 """)
591         else:
592             cursor.execute("DELETE FROM catalogue_book_ancestor")
593             for b in cls.objects.exclude(parent=None):
594                 parent = b.parent
595                 while parent is not None:
596                     b.ancestor.add(parent)
597                     parent = parent.parent
598
599     def flush_includes(self, languages=True):
600         if not languages:
601             return
602         if languages is True:
603             languages = [lc for (lc, _ln) in settings.LANGUAGES]
604         flush_ssi_includes([
605             template % (self.pk, lang)
606             for template in [
607                 '/katalog/b/%d/mini.%s.html',
608                 '/katalog/b/%d/mini_nolink.%s.html',
609                 '/katalog/b/%d/short.%s.html',
610                 '/katalog/b/%d/wide.%s.html',
611                 '/api/include/book/%d.%s.json',
612                 '/api/include/book/%d.%s.xml',
613                 ]
614             for lang in languages
615             ])
616
617     def cover_info(self, inherit=True):
618         """Returns a dictionary to serve as fallback for BookInfo.
619
620         For now, the only thing inherited is the cover image.
621         """
622         need = False
623         info = {}
624         for field in ('cover_url', 'cover_by', 'cover_source'):
625             val = self.extra_info.get(field)
626             if val:
627                 info[field] = val
628             else:
629                 need = True
630         if inherit and need and self.parent is not None:
631             parent_info = self.parent.cover_info()
632             parent_info.update(info)
633             info = parent_info
634         return info
635
636     def related_themes(self):
637         return Tag.objects.usage_for_queryset(
638             Fragment.objects.filter(models.Q(book=self) | models.Q(book__ancestor=self)),
639             counts=True).filter(category='theme')
640
641     def parent_cover_changed(self):
642         """Called when parent book's cover image is changed."""
643         if not self.cover_info(inherit=False):
644             if 'cover' not in app_settings.DONT_BUILD:
645                 self.cover.build_delay()
646                 self.cover_thumb.build_delay()
647                 self.cover_api_thumb.build_delay()
648                 self.simple_cover.build_delay()
649             for format_ in constants.EBOOK_FORMATS_WITH_COVERS:
650                 if format_ not in app_settings.DONT_BUILD:
651                     getattr(self, '%s_file' % format_).build_delay()
652             for child in self.children.all():
653                 child.parent_cover_changed()
654
655     def other_versions(self):
656         """Find other versions (i.e. in other languages) of the book."""
657         return type(self).objects.filter(common_slug=self.common_slug).exclude(pk=self.pk)
658
659     def parents(self):
660         books = []
661         parent = self.parent
662         while parent is not None:
663             books.insert(0, parent)
664             parent = parent.parent
665         return books
666
667     def pretty_title(self, html_links=False):
668         names = [(tag.name, tag.get_absolute_url()) for tag in self.authors().only('name', 'category', 'slug')]
669         books = self.parents() + [self]
670         names.extend([(b.title, b.get_absolute_url()) for b in books])
671
672         if html_links:
673             names = ['<a href="%s">%s</a>' % (tag[1], tag[0]) for tag in names]
674         else:
675             names = [tag[0] for tag in names]
676         return ', '.join(names)
677
678     def publisher(self):
679         publisher = self.extra_info['publisher']
680         if isinstance(publisher, basestring):
681             return publisher
682         elif isinstance(publisher, list):
683             return ', '.join(publisher)
684
685     @classmethod
686     def tagged_top_level(cls, tags):
687         """ Returns top-level books tagged with `tags`.
688
689         It only returns those books which don't have ancestors which are
690         also tagged with those tags.
691
692         """
693         objects = cls.tagged.with_all(tags)
694         return objects.exclude(ancestor__in=objects)
695
696     @classmethod
697     def book_list(cls, book_filter=None):
698         """Generates a hierarchical listing of all books.
699
700         Books are optionally filtered with a test function.
701
702         """
703
704         books_by_parent = {}
705         books = cls.objects.order_by('parent_number', 'sort_key').only('title', 'parent', 'slug')
706         if book_filter:
707             books = books.filter(book_filter).distinct()
708
709             book_ids = set(b['pk'] for b in books.values("pk").iterator())
710             for book in books.iterator():
711                 parent = book.parent_id
712                 if parent not in book_ids:
713                     parent = None
714                 books_by_parent.setdefault(parent, []).append(book)
715         else:
716             for book in books.iterator():
717                 books_by_parent.setdefault(book.parent_id, []).append(book)
718
719         orphans = []
720         books_by_author = OrderedDict()
721         for tag in Tag.objects.filter(category='author').iterator():
722             books_by_author[tag] = []
723
724         for book in books_by_parent.get(None, ()):
725             authors = list(book.authors().only('pk'))
726             if authors:
727                 for author in authors:
728                     books_by_author[author].append(book)
729             else:
730                 orphans.append(book)
731
732         return books_by_author, orphans, books_by_parent
733
734     _audiences_pl = {
735         "SP": (1, u"szkoła podstawowa"),
736         "SP1": (1, u"szkoła podstawowa"),
737         "SP2": (1, u"szkoła podstawowa"),
738         "SP3": (1, u"szkoła podstawowa"),
739         "P": (1, u"szkoła podstawowa"),
740         "G": (2, u"gimnazjum"),
741         "L": (3, u"liceum"),
742         "LP": (3, u"liceum"),
743     }
744
745     def audiences_pl(self):
746         audiences = self.extra_info.get('audiences', [])
747         audiences = sorted(set([self._audiences_pl.get(a, (99, a)) for a in audiences]))
748         return [a[1] for a in audiences]
749
750     def stage_note(self):
751         stage = self.extra_info.get('stage')
752         if stage and stage < '0.4':
753             return (_('This work needs modernisation'),
754                     reverse('infopage', args=['wymagajace-uwspolczesnienia']))
755         else:
756             return None, None
757
758     def choose_fragment(self):
759         fragments = self.fragments.order_by()
760         fragments_count = fragments.count()
761         if not fragments_count and self.children.exists():
762             fragments = Fragment.objects.filter(book__ancestor=self).order_by()
763             fragments_count = fragments.count()
764         if fragments_count:
765             return fragments[randint(0, fragments_count - 1)]
766         elif self.parent:
767             return self.parent.choose_fragment()
768         else:
769             return None
770
771     def fragment_data(self):
772         fragment = self.choose_fragment()
773         if fragment:
774             return {
775                 'title': fragment.book.pretty_title(),
776                 'html': re.sub('</?blockquote[^>]*>', '', fragment.get_short_text()),
777             }
778         else:
779             return None
780
781     def update_popularity(self):
782         count = self.tags.filter(category='set').values('user').order_by('user').distinct().count()
783         try:
784             pop = self.popularity
785             pop.count = count
786             pop.save()
787         except BookPopularity.DoesNotExist:
788             BookPopularity.objects.create(book=self, count=count)
789
790     def ridero_link(self):
791         return 'https://ridero.eu/%s/books/wl_%s/' % (get_language(), self.slug.replace('-', '_'))
792
793     def like(self, user):
794         from social.utils import likes, get_set, set_sets
795         if not likes(user, self):
796             tag = get_set(user, '')
797             set_sets(user, self, [tag])
798
799     def unlike(self, user):
800         from social.utils import likes, set_sets
801         if likes(user, self):
802             set_sets(user, self, [])
803
804     def full_sort_key(self):
805         return self.SORT_KEY_SEP.join((self.sort_key_author, self.sort_key, str(self.id)))
806
807     def cover_color(self):
808         return WLCover.epoch_colors.get(self.extra_info.get('epoch'), '#000000')
809
810
811 def add_file_fields():
812     for format_ in Book.formats:
813         field_name = "%s_file" % format_
814         # This weird globals() assignment makes Django migrations comfortable.
815         _upload_to = _ebook_upload_to('book/%s/%%s.%s' % (format_, format_))
816         _upload_to.__name__ = '_%s_upload_to' % format_
817         globals()[_upload_to.__name__] = _upload_to
818
819         EbookField(
820             format_, _("%s file" % format_.upper()),
821             upload_to=_upload_to,
822             storage=bofh_storage,
823             max_length=255,
824             blank=True,
825             default=''
826         ).contribute_to_class(Book, field_name)
827
828
829 add_file_fields()
830
831
832 class BookPopularity(models.Model):
833     book = models.OneToOneField(Book, related_name='popularity')
834     count = models.IntegerField(default=0, db_index=True)