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