apps/catalogue/models.py

   1 # -*- coding: utf-8 -*-
   2 # This file is part of Wolnelektury, licensed under GNU Affero GPLv3 or later.
   3 # Copyright © Fundacja Nowoczesna Polska. See NOTICE for more information.
   4 #
   5 from django.db import models
   6 from django.db.models import permalink, Q
   7 from django.utils.translation import ugettext_lazy as _
   8 from django.contrib.auth.models import User
   9 from django.core.files import File
  10 from django.template.loader import render_to_string
  11 from django.utils.safestring import mark_safe
  12 from django.core.urlresolvers import reverse
  13 from datetime import datetime
  14
  15 from newtagging.models import TagBase
  16 from newtagging import managers
  17 from catalogue.fields import JSONField
  18
  19 from librarian import html, dcparser
  20 from mutagen import id3
  21
  22
  23 TAG_CATEGORIES = (
  24     ('author', _('author')),
  25     ('epoch', _('epoch')),
  26     ('kind', _('kind')),
  27     ('genre', _('genre')),
  28     ('theme', _('theme')),
  29     ('set', _('set')),
  30     ('book', _('book')),
  31 )
  32
  33
  34 class TagSubcategoryManager(models.Manager):
  35     def __init__(self, subcategory):
  36         super(TagSubcategoryManager, self).__init__()
  37         self.subcategory = subcategory
  38
  39     def get_query_set(self):
  40         return super(TagSubcategoryManager, self).get_query_set().filter(category=self.subcategory)
  41
  42
  43 class Tag(TagBase):
  44     name = models.CharField(_('name'), max_length=50, db_index=True)
  45     slug = models.SlugField(_('slug'), max_length=120, unique=True, db_index=True)
  46     sort_key = models.SlugField(_('sort key'), max_length=120, db_index=True)
  47     category = models.CharField(_('category'), max_length=50, blank=False, null=False,
  48         db_index=True, choices=TAG_CATEGORIES)
  49     description = models.TextField(_('description'), blank=True)
  50     main_page = models.BooleanField(_('main page'), default=False, db_index=True, help_text=_('Show tag on main page'))
  51
  52     user = models.ForeignKey(User, blank=True, null=True)
  53     book_count = models.IntegerField(_('book count'), default=0, blank=False, null=False)
  54     death = models.IntegerField(_(u'year of death'), blank=True, null=True)
  55     gazeta_link = models.CharField(blank=True,  max_length=240)
  56     wiki_link = models.CharField(blank=True,  max_length=240)
  57
  58     def has_description(self):
  59         return len(self.description) > 0
  60     has_description.short_description = _('description')
  61     has_description.boolean = True
  62
  63     def alive(self):
  64         return self.death is None
  65
  66     def in_pd(self):
  67         """ tests whether an author is in public domain """
  68         return self.death is not None and self.goes_to_pd() <= datetime.now().year
  69
  70     def goes_to_pd(self):
  71         """ calculates the year of public domain entry for an author """
  72         return self.death + 71 if self.death is not None else None
  73
  74     @permalink
  75     def get_absolute_url(self):
  76         return ('catalogue.views.tagged_object_list', [self.slug])
  77
  78     class Meta:
  79         ordering = ('sort_key',)
  80         verbose_name = _('tag')
  81         verbose_name_plural = _('tags')
  82
  83     def __unicode__(self):
  84         return self.name
  85
  86     @staticmethod
  87     def get_tag_list(tags):
  88         if isinstance(tags, basestring):
  89             tag_slugs = tags.split('/')
  90             return [Tag.objects.get(slug=slug) for slug in tag_slugs]
  91         else:
  92             return TagBase.get_tag_list(tags)
  93
  94
  95 def book_upload_path(ext):
  96     def get_dynamic_path(book, filename):
  97         return 'lektura/%s.%s' % (book.slug, ext)
  98     return get_dynamic_path
  99
 100
 101 class Book(models.Model):
 102     title = models.CharField(_('title'), max_length=120)
 103     slug = models.SlugField(_('slug'), max_length=120, unique=True, db_index=True)
 104     description = models.TextField(_('description'), blank=True)
 105     created_at = models.DateTimeField(_('creation date'), auto_now=True)
 106     _short_html = models.TextField(_('short HTML'), editable=False)
 107     parent_number = models.IntegerField(_('parent number'), default=0)
 108     extra_info = JSONField(_('extra information'))
 109     gazeta_link = models.CharField(blank=True,  max_length=240)
 110     wiki_link = models.CharField(blank=True,  max_length=240)
 111
 112
 113     # Formats
 114     xml_file = models.FileField(_('XML file'), upload_to=book_upload_path('xml'), blank=True)
 115     html_file = models.FileField(_('HTML file'), upload_to=book_upload_path('html'), blank=True)
 116     pdf_file = models.FileField(_('PDF file'), upload_to=book_upload_path('pdf'), blank=True)
 117     odt_file = models.FileField(_('ODT file'), upload_to=book_upload_path('odt'), blank=True)
 118     txt_file = models.FileField(_('TXT file'), upload_to=book_upload_path('txt'), blank=True)
 119     mp3_file = models.FileField(_('MP3 file'), upload_to=book_upload_path('mp3'), blank=True)
 120     ogg_file = models.FileField(_('OGG file'), upload_to=book_upload_path('ogg'), blank=True)
 121
 122     parent = models.ForeignKey('self', blank=True, null=True, related_name='children')
 123
 124     objects = models.Manager()
 125     tagged = managers.ModelTaggedItemManager(Tag)
 126     tags = managers.TagDescriptor(Tag)
 127
 128     @property
 129     def name(self):
 130         return self.title
 131
 132     def short_html(self):
 133         if len(self._short_html):
 134             return mark_safe(self._short_html)
 135         else:
 136             tags = self.tags.filter(~Q(category__in=('set', 'theme', 'book')))
 137             tags = [mark_safe(u'<a href="%s">%s</a>' % (tag.get_absolute_url(), tag.name)) for tag in tags]
 138
 139             formats = []
 140             if self.html_file:
 141                 formats.append(u'<a href="%s">Czytaj online</a>' % reverse('book_text', kwargs={'slug': self.slug}))
 142             if self.pdf_file:
 143                 formats.append(u'<a href="%s">PDF</a>' % self.pdf_file.url)
 144             if self.odt_file:
 145                 formats.append(u'<a href="%s">ODT</a>' % self.odt_file.url)
 146             if self.txt_file:
 147                 formats.append(u'<a href="%s">TXT</a>' % self.txt_file.url)
 148             if self.mp3_file:
 149                 formats.append(u'<a href="%s">MP3</a>' % self.mp3_file.url)
 150             if self.ogg_file:
 151                 formats.append(u'<a href="%s">OGG</a>' % self.ogg_file.url)
 152
 153             formats = [mark_safe(format) for format in formats]
 154
 155             self._short_html = unicode(render_to_string('catalogue/book_short.html',
 156                 {'book': self, 'tags': tags, 'formats': formats}))
 157             self.save(reset_short_html=False)
 158             return mark_safe(self._short_html)
 159
 160     def save(self, force_insert=False, force_update=False, reset_short_html=True):
 161         if reset_short_html:
 162             # Reset _short_html during save
 163             self._short_html = ''
 164
 165         book = super(Book, self).save(force_insert, force_update)
 166
 167         if self.mp3_file:
 168             print self.mp3_file, self.mp3_file.path
 169             extra_info = self.get_extra_info_value()
 170             extra_info.update(self.get_mp3_info())
 171             self.set_extra_info_value(extra_info)
 172             book = super(Book, self).save(force_insert, force_update)
 173
 174         return book
 175
 176     def get_mp3_info(self):
 177         """Retrieves artist and director names from audio ID3 tags."""
 178         audio = id3.ID3(self.mp3_file.path)
 179         artist_name = ', '.join(', '.join(tag.text) for tag in audio.getall('TPE1'))
 180         director_name = ', '.join(', '.join(tag.text) for tag in audio.getall('TPE3'))
 181         return {'artist_name': artist_name, 'director_name': director_name}
 182
 183     def has_description(self):
 184         return len(self.description) > 0
 185     has_description.short_description = _('description')
 186     has_description.boolean = True
 187
 188     def has_pdf_file(self):
 189         return bool(self.pdf_file)
 190     has_pdf_file.short_description = 'PDF'
 191     has_pdf_file.boolean = True
 192
 193     def has_odt_file(self):
 194         return bool(self.odt_file)
 195     has_odt_file.short_description = 'ODT'
 196     has_odt_file.boolean = True
 197
 198     def has_html_file(self):
 199         return bool(self.html_file)
 200     has_html_file.short_description = 'HTML'
 201     has_html_file.boolean = True
 202
 203     class AlreadyExists(Exception):
 204         pass
 205
 206     @staticmethod
 207     def from_xml_file(xml_file, overwrite=False):
 208         from tempfile import NamedTemporaryFile
 209         from slughifi import slughifi
 210         from markupstring import MarkupString
 211
 212         # Read book metadata
 213         book_info = dcparser.parse(xml_file)
 214         book_base, book_slug = book_info.url.rsplit('/', 1)
 215         book, created = Book.objects.get_or_create(slug=book_slug)
 216
 217         if created:
 218             book_shelves = []
 219         else:
 220             if not overwrite:
 221                 raise Book.AlreadyExists('Book %s already exists' % book_slug)
 222             # Save shelves for this book
 223             book_shelves = list(book.tags.filter(category='set'))
 224
 225         book.title = book_info.title
 226         book.set_extra_info_value(book_info.to_dict())
 227         book._short_html = ''
 228         book.save()
 229
 230         book_tags = []
 231         for category in ('kind', 'genre', 'author', 'epoch'):
 232             tag_name = getattr(book_info, category)
 233             tag_sort_key = tag_name
 234             if category == 'author':
 235                 tag_sort_key = tag_name.last_name
 236                 tag_name = ' '.join(tag_name.first_names) + ' ' + tag_name.last_name
 237             tag, created = Tag.objects.get_or_create(slug=slughifi(tag_name))
 238             if created:
 239                 tag.name = tag_name
 240                 tag.sort_key = slughifi(tag_sort_key)
 241                 tag.category = category
 242                 tag.save()
 243             book_tags.append(tag)
 244
 245         book_tag, created = Tag.objects.get_or_create(slug=('l-' + book.slug)[:120])
 246         if created:
 247             book_tag.name = book.title[:50]
 248             book_tag.sort_key = ('l-' + book.slug)[:120]
 249             book_tag.category = 'book'
 250             book_tag.save()
 251         book_tags.append(book_tag)
 252
 253         book.tags = book_tags
 254
 255         if hasattr(book_info, 'parts'):
 256             for n, part_url in enumerate(book_info.parts):
 257                 base, slug = part_url.rsplit('/', 1)
 258                 try:
 259                     child_book = Book.objects.get(slug=slug)
 260                     child_book.parent = book
 261                     child_book.parent_number = n
 262                     child_book.save()
 263                 except Book.DoesNotExist, e:
 264                     raise Book.DoesNotExist(u'Book with slug = "%s" does not exist.' % slug)
 265
 266         book_descendants = list(book.children.all())
 267         while len(book_descendants) > 0:
 268             child_book = book_descendants.pop(0)
 269             for fragment in child_book.fragments.all():
 270                 fragment.tags = set(list(fragment.tags) + [book_tag])
 271             book_descendants += list(child_book.children.all())
 272
 273         # Save XML and HTML files
 274         if not isinstance(xml_file, File):
 275             xml_file = File(file(xml_file))
 276         book.xml_file.save('%s.xml' % book.slug, xml_file, save=False)
 277
 278         html_file = NamedTemporaryFile()
 279         if html.transform(book.xml_file.path, html_file):
 280             book.html_file.save('%s.html' % book.slug, File(html_file), save=False)
 281
 282             # Extract fragments
 283             closed_fragments, open_fragments = html.extract_fragments(book.html_file.path)
 284             book_themes = []
 285             for fragment in closed_fragments.values():
 286                 text = fragment.to_string()
 287                 short_text = ''
 288                 if (len(MarkupString(text)) > 240):
 289                     short_text = unicode(MarkupString(text)[:160])
 290                 new_fragment, created = Fragment.objects.get_or_create(anchor=fragment.id, book=book,
 291                     defaults={'text': text, 'short_text': short_text})
 292
 293                 try:
 294                     theme_names = [s.strip() for s in fragment.themes.split(',')]
 295                 except AttributeError:
 296                     continue
 297                 themes = []
 298                 for theme_name in theme_names:
 299                     tag, created = Tag.objects.get_or_create(slug=slughifi(theme_name))
 300                     if created:
 301                         tag.name = theme_name
 302                         tag.sort_key = slughifi(theme_name)
 303                         tag.category = 'theme'
 304                         tag.save()
 305                     themes.append(tag)
 306                 new_fragment.save()
 307                 new_fragment.tags = set(list(book.tags) + themes + [book_tag])
 308                 book_themes += themes
 309
 310             book_themes = set(book_themes)
 311             book.tags = list(book.tags) + list(book_themes) + book_shelves
 312
 313         book.save()
 314         return book
 315
 316     @permalink
 317     def get_absolute_url(self):
 318         return ('catalogue.views.book_detail', [self.slug])
 319
 320     class Meta:
 321         ordering = ('title',)
 322         verbose_name = _('book')
 323         verbose_name_plural = _('books')
 324
 325     def __unicode__(self):
 326         return self.title
 327
 328
 329 class Fragment(models.Model):
 330     text = models.TextField()
 331     short_text = models.TextField(editable=False)
 332     _short_html = models.TextField(editable=False)
 333     anchor = models.CharField(max_length=120)
 334     book = models.ForeignKey(Book, related_name='fragments')
 335
 336     objects = models.Manager()
 337     tagged = managers.ModelTaggedItemManager(Tag)
 338     tags = managers.TagDescriptor(Tag)
 339
 340     def short_html(self):
 341         if len(self._short_html):
 342             return mark_safe(self._short_html)
 343         else:
 344             book_authors = [mark_safe(u'<a href="%s">%s</a>' % (tag.get_absolute_url(), tag.name))
 345                 for tag in self.book.tags if tag.category == 'author']
 346
 347             self._short_html = unicode(render_to_string('catalogue/fragment_short.html',
 348                 {'fragment': self, 'book': self.book, 'book_authors': book_authors}))
 349             self.save()
 350             return mark_safe(self._short_html)
 351
 352     def get_absolute_url(self):
 353         return '%s#m%s' % (reverse('book_text', kwargs={'slug': self.book.slug}), self.anchor)
 354
 355     class Meta:
 356         ordering = ('book', 'anchor',)
 357         verbose_name = _('fragment')
 358         verbose_name_plural = _('fragments')
 359
 360
 361 class BookStub(models.Model):
 362     title = models.CharField(_('title'), max_length=120)
 363     author = models.CharField(_('author'), max_length=120)
 364     pd = models.IntegerField(_('goes to public domain'), null=True, blank=True)
 365     slug = models.SlugField(_('slug'), max_length=120, unique=True, db_index=True)
 366     translator = models.TextField(_('translator'), blank=True)
 367     translator_death = models.TextField(_('year of translator\'s death'), blank=True)
 368
 369     def in_pd(self):
 370         return self.pd is not None and self.pd <= datetime.now().year
 371
 372     @property
 373     def name(self):
 374         return self.title
 375
 376     @permalink
 377     def get_absolute_url(self):
 378         return ('catalogue.views.book_detail', [self.slug])
 379
 380     def __unicode__(self):
 381         return self.title
 382
 383     class Meta:
 384         ordering = ('title',)
 385         verbose_name = _('book stub')
 386         verbose_name_plural = _('book stubs')
 387