Removed unneeded dispatcher import from catalogue.fields module.
[wolnelektury.git] / apps / catalogue / models.py
1 # -*- coding: utf-8 -*-
2 from django.db import models
3 from django.db.models import permalink, Q
4 from django.utils.translation import ugettext_lazy as _
5 from django.contrib.auth.models import User
6 from django.core.files import File
7 from django.template.loader import render_to_string
8 from django.utils.safestring import mark_safe
9 from django.core.urlresolvers import reverse
10
11 from newtagging.models import TagBase
12 from newtagging import managers
13 from catalogue.fields import JSONField
14
15 from librarian import html, dcparser
16
17
18 TAG_CATEGORIES = (
19     ('author', _('author')),
20     ('epoch', _('epoch')),
21     ('kind', _('kind')),
22     ('genre', _('genre')),
23     ('theme', _('theme')),
24     ('set', _('set')),
25 )
26
27
28 class TagSubcategoryManager(models.Manager):
29     def __init__(self, subcategory):
30         super(TagSubcategoryManager, self).__init__()
31         self.subcategory = subcategory
32         
33     def get_query_set(self):
34         return super(TagSubcategoryManager, self).get_query_set().filter(category=self.subcategory)
35
36
37 class Tag(TagBase):
38     name = models.CharField(_('name'), max_length=50, db_index=True)
39     slug = models.SlugField(_('slug'), max_length=120, unique=True, db_index=True)
40     sort_key = models.SlugField(_('sort key'), max_length=120, db_index=True)
41     category = models.CharField(_('category'), max_length=50, blank=False, null=False, 
42         db_index=True, choices=TAG_CATEGORIES)
43     description = models.TextField(_('description'), blank=True)
44     main_page = models.BooleanField(_('main page'), default=False, db_index=True, help_text=_('Show tag on main page'))
45     
46     user = models.ForeignKey(User, blank=True, null=True)
47     book_count = models.IntegerField(_('book count'), default=0, blank=False, null=False)
48     
49     def has_description(self):
50         return len(self.description) > 0
51     has_description.short_description = _('description')
52     has_description.boolean = True
53
54     @permalink
55     def get_absolute_url(self):
56         return ('catalogue.views.tagged_object_list', [self.slug])
57     
58     class Meta:
59         ordering = ('sort_key',)
60         verbose_name = _('tag')
61         verbose_name_plural = _('tags')
62     
63     def __unicode__(self):
64         return self.name
65
66     @staticmethod
67     def get_tag_list(tags):
68         if isinstance(tags, basestring):
69             tag_slugs = tags.split('/')
70             return [Tag.objects.get(slug=slug) for slug in tag_slugs]
71         else:
72             return TagBase.get_tag_list(tags)
73
74
75 def book_upload_path(ext):
76     def get_dynamic_path(book, filename):
77         return 'lektura/%s.%s' % (book.slug, ext)
78     return get_dynamic_path
79
80
81 class Book(models.Model):
82     title = models.CharField(_('title'), max_length=120)
83     slug = models.SlugField(_('slug'), max_length=120, unique=True, db_index=True)
84     description = models.TextField(_('description'), blank=True)
85     created_at = models.DateTimeField(_('creation date'), auto_now=True)
86     _short_html = models.TextField(_('short HTML'), editable=False)
87     parent_number = models.IntegerField(_('parent number'), default=0)
88     extra_info = JSONField(_('extra information'))
89     
90     # Formats
91     xml_file = models.FileField(_('XML file'), upload_to=book_upload_path('xml'), blank=True)
92     html_file = models.FileField(_('HTML file'), upload_to=book_upload_path('html'), blank=True)
93     pdf_file = models.FileField(_('PDF file'), upload_to=book_upload_path('pdf'), blank=True)
94     odt_file = models.FileField(_('ODT file'), upload_to=book_upload_path('odt'), blank=True)
95     txt_file = models.FileField(_('TXT file'), upload_to=book_upload_path('txt'), blank=True)
96     
97     parent = models.ForeignKey('self', blank=True, null=True, related_name='children')
98     
99     objects = models.Manager()
100     tagged = managers.ModelTaggedItemManager(Tag)
101     tags = managers.TagDescriptor(Tag)
102
103     
104     @property
105     def name(self):
106         return self.title
107     
108     def short_html(self):
109         if len(self._short_html):
110             return mark_safe(self._short_html)
111         else:
112             tags = self.tags.filter(~Q(category__in=('set', 'theme')))
113             tags = [u'<a href="%s">%s</a>' % (tag.get_absolute_url(), tag.name) for tag in tags]
114
115             formats = []
116             if self.html_file:
117                 formats.append(u'<a href="%s">Czytaj online</a>' % reverse('book_text', kwargs={'slug': self.slug}))
118             if self.pdf_file:
119                 formats.append(u'<a href="%s">Plik PDF</a>' % self.pdf_file.url)
120             if self.odt_file:
121                 formats.append(u'<a href="%s">Plik ODT</a>' % self.odt_file.url)
122             if self.txt_file:
123                 formats.append(u'<a href="%s">Plik TXT</a>' % self.txt_file.url)
124             
125             self._short_html = unicode(render_to_string('catalogue/book_short.html',
126                 {'book': self, 'tags': tags, 'formats': formats}))
127             self.save()
128             return mark_safe(self._short_html)
129     
130     def has_description(self):
131         return len(self.description) > 0
132     has_description.short_description = _('description')
133     has_description.boolean = True
134     
135     def has_pdf_file(self):
136         return bool(self.pdf_file)
137     has_pdf_file.short_description = 'PDF'
138     has_pdf_file.boolean = True
139     
140     def has_odt_file(self):
141         return bool(self.odt_file)
142     has_odt_file.short_description = 'ODT'
143     has_odt_file.boolean = True
144     
145     def has_html_file(self):
146         return bool(self.html_file)
147     has_html_file.short_description = 'HTML'
148     has_html_file.boolean = True
149
150     class AlreadyExists(Exception):
151         pass
152     
153     @staticmethod
154     def from_xml_file(xml_file, overwrite=False):
155         from tempfile import NamedTemporaryFile
156         from slughifi import slughifi
157         from markupstring import MarkupString
158         
159         # Read book metadata
160         book_info = dcparser.parse(xml_file)
161         book_base, book_slug = book_info.url.rsplit('/', 1)
162         book, created = Book.objects.get_or_create(slug=book_slug)
163         
164         if created:
165             book_shelves = []
166         else:
167             if not overwrite:
168                 raise Book.AlreadyExists('Book %s already exists' % book_slug)
169             # Save shelves for this book
170             book_shelves = list(book.tags.filter(category='set'))
171         
172         book.title = book_info.title
173         book._short_html = ''
174         book.save()
175         
176         book_tags = []
177         for category in ('kind', 'genre', 'author', 'epoch'):    
178             tag_name = getattr(book_info, category)
179             tag_sort_key = tag_name
180             if category == 'author':
181                 tag_sort_key = tag_name.last_name
182                 tag_name = ' '.join(tag_name.first_names) + ' ' + tag_name.last_name
183             tag, created = Tag.objects.get_or_create(slug=slughifi(tag_name))
184             if created:
185                 tag.name = tag_name
186                 tag.sort_key = slughifi(tag_sort_key)
187                 tag.category = category
188                 tag.save()
189             book_tags.append(tag)
190         book.tags = book_tags
191         
192         if hasattr(book_info, 'parts'):
193             for n, part_url in enumerate(book_info.parts):
194                 base, slug = part_url.rsplit('/', 1)
195                 child_book = Book.objects.get(slug=slug)
196                 child_book.parent = book
197                 child_book.parent_number = n
198                 child_book.save()
199         
200         # Save XML and HTML files
201         book.xml_file.save('%s.xml' % book.slug, File(file(xml_file)), save=False)
202         
203         html_file = NamedTemporaryFile()
204         if html.transform(book.xml_file.path, html_file):
205             book.html_file.save('%s.html' % book.slug, File(html_file), save=False)
206             
207             # Extract fragments
208             closed_fragments, open_fragments = html.extract_fragments(book.html_file.path)
209             book_themes = []
210             for fragment in closed_fragments.values():
211                 text = fragment.to_string()
212                 short_text = ''
213                 if (len(MarkupString(text)) > 240):
214                     short_text = unicode(MarkupString(text)[:160])
215                 new_fragment, created = Fragment.objects.get_or_create(anchor=fragment.id, book=book, 
216                     defaults={'text': text, 'short_text': short_text})
217                 
218                 try:
219                     theme_names = [s.strip() for s in fragment.themes.split(',')]
220                 except AttributeError:
221                     continue
222                 themes = []
223                 for theme_name in theme_names:
224                     tag, created = Tag.objects.get_or_create(slug=slughifi(theme_name))
225                     if created:
226                         tag.name = theme_name
227                         tag.sort_key = slughifi(theme_name)
228                         tag.category = 'theme'
229                         tag.save()
230                     themes.append(tag)
231                 new_fragment.save()
232                 new_fragment.tags = list(book.tags) + themes
233                 book_themes += themes
234             
235             book_themes = set(book_themes)
236             book.tags = list(book.tags) + list(book_themes) + book_shelves
237         
238         book.save()
239         return book
240     
241     @permalink
242     def get_absolute_url(self):
243         return ('catalogue.views.book_detail', [self.slug])
244         
245     class Meta:
246         ordering = ('title',)
247         verbose_name = _('book')
248         verbose_name_plural = _('books')
249
250     def __unicode__(self):
251         return self.title
252
253
254 class Fragment(models.Model):
255     text = models.TextField()
256     short_text = models.TextField(editable=False)
257     _short_html = models.TextField(editable=False)
258     anchor = models.CharField(max_length=120)
259     book = models.ForeignKey(Book, related_name='fragments')
260
261     objects = models.Manager()
262     tagged = managers.ModelTaggedItemManager(Tag)
263     tags = managers.TagDescriptor(Tag)
264     
265     def short_html(self):
266         if len(self._short_html):
267             return mark_safe(self._short_html)
268         else:
269             book_authors = [u'<a href="%s">%s</a>' % (tag.get_absolute_url(), tag.name) 
270                 for tag in self.book.tags if tag.category == 'author']
271             
272             self._short_html = unicode(render_to_string('catalogue/fragment_short.html',
273                 {'fragment': self, 'book': self.book, 'book_authors': book_authors}))
274             self.save()
275             return mark_safe(self._short_html)
276     
277     def get_absolute_url(self):
278         return '%s#m%s' % (reverse('book_text', kwargs={'slug': self.book.slug}), self.anchor)
279     
280     class Meta:
281         ordering = ('book', 'anchor',)
282         verbose_name = _('fragment')
283         verbose_name_plural = _('fragments')
284