from django.db import models
from django.db.models import permalink, Q
+import django.dispatch
from django.core.cache import cache
from django.utils.translation import ugettext_lazy as _
from django.contrib.auth.models import User
from newtagging.models import TagBase, tags_updated
from newtagging import managers
from catalogue.fields import JSONField, OverwritingFileField
-from catalogue.utils import ExistingFile
+from catalogue.utils import ExistingFile, BookImportDocProvider, create_zip_task, remove_zip
from librarian import dcparser, html, epub, NoDublinCore
import mutagen
from mutagen import id3
from slughifi import slughifi
from sortify import sortify
-
+from os import unlink
TAG_CATEGORIES = (
('author', _('author')),
('daisy', _('DAISY file')),
)
+# not quite, but Django wants you to set a timeout
+CACHE_FOREVER = 2419200 # 28 days
+
+
class TagSubcategoryManager(models.Manager):
def __init__(self, subcategory):
super(TagSubcategoryManager, self).__init__()
if slughifi(self.name) != slughifi(old.name):
self.file.save(None, ExistingFile(self.file.path), save=False, leave=True)
+ # remove the zip package for book with modified media
+ remove_zip(self.book.slug)
+
super(BookMedia, self).save(*args, **kwargs)
extra_info = self.get_extra_info_value()
extra_info.update(self.read_meta())
class Book(models.Model):
title = models.CharField(_('title'), max_length=120)
- sort_key = models.CharField(_('sort_key'), max_length=120, db_index=True, editable=False)
+ sort_key = models.CharField(_('sort key'), max_length=120, db_index=True, editable=False)
slug = models.SlugField(_('slug'), max_length=120, unique=True, db_index=True)
description = models.TextField(_('description'), blank=True)
created_at = models.DateTimeField(_('creation date'), auto_now_add=True, db_index=True)
xml_file = models.FileField(_('XML file'), upload_to=book_upload_path('xml'), blank=True)
html_file = models.FileField(_('HTML file'), upload_to=book_upload_path('html'), blank=True)
pdf_file = models.FileField(_('PDF file'), upload_to=book_upload_path('pdf'), blank=True)
- epub_file = models.FileField(_('EPUB file'), upload_to=book_upload_path('epub'), blank=True)
- txt_file = models.FileField(_('TXT file'), upload_to=book_upload_path('txt'), blank=True)
-
+ epub_file = models.FileField(_('EPUB file'), upload_to=book_upload_path('epub'), blank=True)
+ txt_file = models.FileField(_('TXT file'), upload_to=book_upload_path('txt'), blank=True)
+
parent = models.ForeignKey('self', blank=True, null=True, related_name='children')
objects = models.Manager()
tagged = managers.ModelTaggedItemManager(Tag)
tags = managers.TagDescriptor(Tag)
+ html_built = django.dispatch.Signal()
+
class AlreadyExists(Exception):
pass
def save(self, force_insert=False, force_update=False, reset_short_html=True, **kwargs):
self.sort_key = sortify(self.title)
+ ret = super(Book, self).save(force_insert, force_update)
+
if reset_short_html:
self.reset_short_html()
- return super(Book, self).save(force_insert, force_update)
+ return ret
@permalink
def get_absolute_url(self):
return self.get_media("daisy")
def reset_short_html(self):
+ if self.id is None:
+ return
+
cache_key = "Book.short_html/%d/%s"
for lang, langname in settings.LANGUAGES:
cache.delete(cache_key % (self.id, lang))
fragm.reset_short_html()
def short_html(self):
- cache_key = "Book.short_html/%d/%s" % (self.id, get_language())
- short_html = cache.get(cache_key)
+ if self.id:
+ cache_key = "Book.short_html/%d/%s" % (self.id, get_language())
+ short_html = cache.get(cache_key)
+ else:
+ short_html = None
if short_html is not None:
return mark_safe(short_html)
short_html = unicode(render_to_string('catalogue/book_short.html',
{'book': self, 'tags': tags, 'formats': formats}))
- cache.set(cache_key, short_html)
+
+ if self.id:
+ cache.set(cache_key, short_html, CACHE_FOREVER)
return mark_safe(short_html)
@property
return bool(self.has_media("ogg"))
has_ogg_file.short_description = 'OGG'
has_ogg_file.boolean = True
-
+
def has_daisy_file(self):
return bool(self.has_media("daisy"))
has_daisy_file.short_description = 'DAISY'
- has_daisy_file.boolean = True
-
+ has_daisy_file.boolean = True
+
+ def build_pdf(self):
+ """ (Re)builds the pdf file.
+
+ """
+ from librarian import pdf
+ from tempfile import NamedTemporaryFile
+ import os
+
+ # remove zip with all pdf files
+ remove_zip(settings.ALL_PDF_ZIP)
+
+ path, fname = os.path.realpath(self.xml_file.path).rsplit('/', 1)
+ try:
+ pdf_file = NamedTemporaryFile(delete=False)
+ pdf.transform(BookImportDocProvider(self),
+ file_path=str(self.xml_file.path),
+ output_file=pdf_file,
+ )
+
+ self.pdf_file.save('%s.pdf' % self.slug, File(open(pdf_file.name)))
+ finally:
+ unlink(pdf_file.name)
+
def build_epub(self, remove_descendants=True):
""" (Re)builds the epub file.
If book has a parent, does nothing.
Unless remove_descendants is False, descendants' epubs are removed.
"""
-
from StringIO import StringIO
from hashlib import sha1
from django.core.files.base import ContentFile
- from librarian import DocProvider
-
- class BookImportDocProvider(DocProvider):
- """ used for joined EPUBs """
-
- def __init__(self, book):
- self.book = book
-
- def by_slug(self, slug):
- if slug == self.book.slug:
- return self.book.xml_file
- else:
- return Book.objects.get(slug=slug).xml_file
if self.parent:
# don't need an epub
return
+ # remove zip package with all epub files
+ remove_zip(settings.ALL_EPUB_ZIP)
+
epub_file = StringIO()
try:
epub.transform(BookImportDocProvider(self), self.slug, output_file=epub_file)
new_fragment.save()
new_fragment.tags = set(meta_tags + themes + [book_tag] + ancestor_tags)
self.save()
+ self.html_built.send(sender=self)
return True
return False
+ @staticmethod
+ def zip_epub():
+ books = Book.objects.all()
+
+ paths = filter(lambda x: x is not None,
+ map(lambda b: b.epub_file and b.epub_file.path or None, books))
+ if settings.USE_CELERY:
+ result = create_zip_task.delay(paths, settings.ALL_EPUB_ZIP)
+ return result.wait()
+ else:
+ result = create_zip_task(paths, settings.ALL_EPUB_ZIP)
+ return result
+
+ @staticmethod
+ def zip_pdf():
+ books = Book.objects.all()
+
+ paths = filter(lambda x: x is not None,
+ map(lambda b: b.pdf_file and b.pdf_file.path or None, books))
+ if settings.USE_CELERY:
+ result = create_zip_task.delay(paths, settings.ALL_PDF_ZIP)
+ return result.wait()
+ else:
+ result = create_zip_task(paths, settings.ALL_PDF_ZIP)
+ return result
+
+ def zip_audiobooks(self):
+ bm = BookMedia.objects.filter(book=self)
+ paths = map(lambda bm: bm.file.path, bm)
+ if settings.USE_CELERY:
+ result = create_zip_task.delay(paths, self.slug)
+ return result.wait()
+ else:
+ result = create_zip_task(paths, self.slug)
+ return result
+
@classmethod
def from_xml_file(cls, xml_file, **kwargs):
xml_file.close()
@classmethod
- def from_text_and_meta(cls, raw_file, book_info, overwrite=False, build_epub=True, build_txt=True):
+ def from_text_and_meta(cls, raw_file, book_info, overwrite=False, build_epub=True, build_txt=True, build_pdf=True):
import re
# check for parts before we do anything
if not settings.NO_BUILD_EPUB and build_epub:
book.root_ancestor.build_epub()
+ if not settings.NO_BUILD_PDF and build_pdf:
+ book.root_ancestor.build_pdf()
+
book_descendants = list(book.children.all())
# add l-tag to descendants and their fragments
# delete unnecessary EPUB files
fragment.tags = set(list(fragment.tags) + [book_tag])
book_descendants += list(child_book.children.all())
+ book.save()
+
# refresh cache
book.reset_tag_counter()
book.reset_theme_counter()
- book.save()
return book
def reset_tag_counter(self):
+ if self.id is None:
+ return
+
cache_key = "Book.tag_counter/%d" % self.id
cache.delete(cache_key)
if self.parent:
@property
def tag_counter(self):
- cache_key = "Book.tag_counter/%d" % self.id
- tags = cache.get(cache_key)
+ if self.id:
+ cache_key = "Book.tag_counter/%d" % self.id
+ tags = cache.get(cache_key)
+ else:
+ tags = None
+
if tags is None:
tags = {}
for child in self.children.all().order_by():
for tag in self.tags.exclude(category__in=('book', 'theme', 'set')).order_by():
tags[tag.pk] = 1
- cache.set(cache_key, tags)
+ if self.id:
+ cache.set(cache_key, tags, CACHE_FOREVER)
return tags
def reset_theme_counter(self):
+ if self.id is None:
+ return
+
cache_key = "Book.theme_counter/%d" % self.id
cache.delete(cache_key)
if self.parent:
@property
def theme_counter(self):
- cache_key = "Book.theme_counter/%d" % self.id
- tags = cache.get(cache_key)
+ if self.id:
+ cache_key = "Book.theme_counter/%d" % self.id
+ tags = cache.get(cache_key)
+ else:
+ tags = None
+
if tags is None:
tags = {}
for fragment in Fragment.tagged.with_any([self.book_tag()]).order_by():
for tag in fragment.tags.filter(category='theme').order_by():
tags[tag.pk] = tags.get(tag.pk, 0) + 1
- cache.set(cache_key, tags)
+ if self.id:
+ cache.set(cache_key, tags, CACHE_FOREVER)
return tags
def pretty_title(self, html_links=False):
return '%s#m%s' % (reverse('book_text', kwargs={'slug': self.book.slug}), self.anchor)
def reset_short_html(self):
+ if self.id is None:
+ return
+
cache_key = "Fragment.short_html/%d/%s"
for lang, langname in settings.LANGUAGES:
cache.delete(cache_key % (self.id, lang))
def short_html(self):
- cache_key = "Fragment.short_html/%d/%s" % (self.id, get_language())
- short_html = cache.get(cache_key)
+ if self.id:
+ cache_key = "Fragment.short_html/%d/%s" % (self.id, get_language())
+ short_html = cache.get(cache_key)
+ else:
+ short_html = None
if short_html is not None:
return mark_safe(short_html)
else:
short_html = unicode(render_to_string('catalogue/fragment_short.html',
{'fragment': self}))
- cache.set(cache_key, short_html)
+ if self.id:
+ cache.set(cache_key, short_html, CACHE_FOREVER)
return mark_safe(short_html)
fnp / wolnelektury.git / blobdiff