1 # This file is part of FNP-Redakcja, licensed under GNU Affero GPLv3 or later.
2 # Copyright © Fundacja Nowoczesna Polska. See NOTICE for more information.
4 from django.apps import apps
5 from django.core.files.base import ContentFile
6 from django.contrib.sites.models import Site
7 from django.db import connection, models, transaction
8 from django.template.loader import render_to_string
9 from django.urls import reverse
10 from django.utils.translation import gettext_lazy as _
11 from django.conf import settings
12 from slugify import slugify
13 from librarian.cover import make_cover
14 from librarian.dcparser import BookInfo
17 from documents.helpers import cached_in_field, GalleryMerger
18 from documents.models import BookPublishRecord, ChunkPublishRecord, Project
19 from documents.signals import post_publish
20 from documents.xml_tools import compile_text, split_xml
21 from cover.models import Image
22 from io import BytesIO
26 from urllib.parse import urljoin
29 class Book(models.Model):
30 """ A document edited on the wiki """
32 title = models.CharField(_('title'), max_length=255, db_index=True)
33 slug = models.SlugField(_('slug'), max_length=128, unique=True, db_index=True)
34 public = models.BooleanField(_('public'), default=True, db_index=True)
35 gallery = models.CharField(_('scan gallery name'), max_length=255, blank=True)
36 project = models.ForeignKey(Project, models.SET_NULL, null=True, blank=True)
38 parent = models.ForeignKey('self', models.SET_NULL, null=True, blank=True, verbose_name=_('parent'), related_name="children", editable=False)
39 parent_number = models.IntegerField(_('parent number'), null=True, blank=True, db_index=True, editable=False)
42 _single = models.BooleanField(editable=False, null=True, db_index=True)
43 _new_publishable = models.BooleanField(editable=False, null=True)
44 _published = models.BooleanField(editable=False, null=True)
45 _on_track = models.IntegerField(null=True, blank=True, db_index=True, editable=False)
46 dc_cover_image = models.ForeignKey(Image, blank=True, null=True,
47 db_index=True, on_delete=models.SET_NULL, editable=False)
48 dc = models.JSONField(null=True, editable=False)
49 cover = models.FileField(blank=True, upload_to='documents/cover')
50 catalogue_book = models.ForeignKey(
54 null=True, blank=True,
56 editable=False, db_index=True,
57 related_name='document_books',
58 related_query_name='document_book',
61 class NoTextError(BaseException):
65 app_label = 'documents'
66 ordering = ['title', 'slug']
67 verbose_name = _('book')
68 verbose_name_plural = _('books')
71 def get_visible_for(cls, user):
72 qs = cls.objects.all()
73 if not user.is_authenticated:
74 qs = qs.filter(public=True)
78 def q_dc(field, field_plural, value, prefix=''):
79 if connection.features.supports_json_field_contains:
80 return models.Q(**{f'{prefix}dc__{field_plural}__contains': value})
82 return models.Q(**{f'{prefix}dc__{field}': value})
89 return iter(self.chunk_set.all())
91 def __getitem__(self, chunk):
92 return self.chunk_set.all()[chunk]
95 return self.chunk_set.count()
99 Necessary so that __len__ isn't used for bool evaluation.
106 def get_absolute_url(self):
107 return reverse("documents_book", args=[self.slug])
109 def correct_about(self):
110 return "http://%s%s" % (
111 Site.objects.get_current().domain,
112 self.get_absolute_url()
115 def gallery_path(self):
116 return os.path.join(settings.MEDIA_ROOT, settings.IMAGE_DIR, self.gallery)
118 def gallery_url(self):
119 return '%s%s%s/' % (settings.MEDIA_URL, settings.IMAGE_DIR, self.gallery)
121 # Creating & manipulating
122 # =======================
124 def accessible(self, request):
125 return self.public or request.user.is_authenticated
129 def create(cls, creator, text, *args, **kwargs):
130 b = cls.objects.create(*args, **kwargs)
131 b.chunk_set.all().update(creator=creator)
132 b[0].commit(text, author=creator)
135 def add(self, *args, **kwargs):
136 """Add a new chunk at the end."""
137 return self.chunk_set.reverse()[0].split(*args, **kwargs)
141 def import_xml_text(cls, text=u'', previous_book=None,
142 commit_args=None, **kwargs):
143 """Imports a book from XML, splitting it into chunks as necessary."""
144 texts = split_xml(text)
146 instance = previous_book
148 instance = cls(**kwargs)
151 # if there are more parts, set the rest to empty strings
152 book_len = len(instance)
153 for i in range(book_len - len(texts)):
154 texts.append((u'pusta część %d' % (i + 1), u''))
157 for i, (title, text) in enumerate(texts):
159 title = u'część %d' % (i + 1)
161 slug = slugify(title)
165 chunk.slug = slug[:50]
166 chunk.title = title[:255]
169 chunk = instance.add(slug, title)
171 chunk.commit(text, **commit_args)
175 def make_chunk_slug(self, proposed):
177 Finds a chunk slug not yet used in the book.
179 slugs = set(c.slug for c in self)
181 new_slug = proposed[:50]
182 while new_slug in slugs:
183 new_slug = "%s_%d" % (proposed[:45], i)
188 def append(self, other, slugs=None, titles=None):
189 """Add all chunks of another book to self."""
192 number = self[len(self) - 1].number + 1
193 len_other = len(other)
194 single = len_other == 1
196 if slugs is not None:
197 assert len(slugs) == len_other
198 if titles is not None:
199 assert len(titles) == len_other
201 slugs = [slugify(t) for t in titles]
203 for i, chunk in enumerate(other):
204 # move chunk to new book
206 chunk.number = number
209 # try some title guessing
210 if other.title.startswith(self.title):
211 other_title_part = other.title[len(self.title):].lstrip(' /')
213 other_title_part = other.title
216 # special treatment for appending one-parters:
217 # just use the guessed title and original book slug
218 chunk.title = other_title_part
219 if other.slug.startswith(self.slug):
220 chunk.slug = other.slug[len(self.slug):].lstrip('-_')
222 chunk.slug = other.slug
224 chunk.title = ("%s, %s" % (other_title_part, chunk.title))[:255]
226 chunk.slug = slugs[i]
227 chunk.title = titles[i]
229 chunk.slug = self.make_chunk_slug(chunk.slug)
232 assert not other.chunk_set.exists()
234 gm = GalleryMerger(self.gallery, other.gallery)
235 self.gallery = gm.merge()
237 # and move the gallery starts
239 for chunk in self[len(self) - len_other:]:
240 old_start = chunk.gallery_start or 1
241 chunk.gallery_start = old_start + gm.dest_size - gm.num_deleted
248 def prepend_history(self, other):
249 """Prepend history from all the other book's chunks to own."""
252 for i in range(len(self), len(other)):
253 title = u"pusta część %d" % i
254 chunk = self.add(slugify(title), title)
257 for i in range(len(other)):
258 self[i].prepend_history(other[0])
260 assert not other.chunk_set.exists()
264 """Splits all the chunks into separate books."""
267 book = Book.objects.create(title=chunk.title, slug=chunk.slug,
268 public=self.public, gallery=self.gallery)
273 assert not self.chunk_set.exists()
279 def last_published(self):
281 return self.publish_log.all()[0].timestamp
285 def assert_publishable(self):
286 assert self.chunk_set.exists(), _('No chunks in the book.')
288 changes = self.get_current_changes(publishable=True)
289 except self.NoTextError:
290 raise AssertionError(_('Not all chunks have approved revisions.'))
292 from librarian import NoDublinCore, ParseError, ValidationError
295 bi = self.wldocument(changes=changes, strict=True).book_info
296 except ParseError as e:
297 raise AssertionError(_('Invalid XML') + ': ' + str(e))
299 raise AssertionError(_('No Dublin Core found.'))
300 except ValidationError as e:
301 raise AssertionError(_('Invalid Dublin Core') + ': ' + str(e))
303 valid_about = self.correct_about()
304 assert bi.about == valid_about, _("rdf:about is not") + " " + valid_about
306 def publishable_error(self):
308 return self.assert_publishable()
309 except AssertionError as e:
315 return self.slug.startswith('.')
317 def is_new_publishable(self):
318 """Checks if book is ready for publishing.
320 Returns True if there is a publishable version newer than the one
324 new_publishable = False
325 if not self.chunk_set.exists():
328 change = chunk.publishable()
331 if not new_publishable and not change.publish_log.exists():
332 new_publishable = True
333 return new_publishable
334 new_publishable = cached_in_field('_new_publishable')(is_new_publishable)
336 def is_published(self):
337 return self.publish_log.exists()
338 published = cached_in_field('_published')(is_published)
340 def get_on_track(self):
343 stages = [ch.stage.ordering if ch.stage is not None else 0
348 on_track = cached_in_field('_on_track')(get_on_track)
351 return len(self) == 1
352 single = cached_in_field('_single')(is_single)
354 def book_info(self, publishable=True):
356 book_xml = self.materialize(publishable=publishable)
357 except self.NoTextError:
360 from librarian.dcparser import BookInfo
361 from librarian import NoDublinCore, ParseError, ValidationError
363 return BookInfo.from_bytes(book_xml.encode('utf-8'))
364 except (self.NoTextError, ParseError, NoDublinCore, ValidationError):
367 def refresh_dc_cache(self):
369 'catalogue_book_id': None,
370 'dc_cover_image': None,
373 info = self.book_info()
375 update['catalogue_book_id'] = info.url.slug
376 if info.cover_source:
378 image = Image.objects.get(pk=int(info.cover_source.rstrip('/').rsplit('/', 1)[-1]))
382 if info.cover_source.rstrip('/') == image.get_full_url().rstrip('/'):
383 update['dc_cover_image'] = image
384 update['dc'] = info.to_dict()
385 Book.objects.filter(pk=self.pk).update(**update)
389 "_new_publishable": self.is_new_publishable(),
390 "_published": self.is_published(),
391 "_single": self.is_single(),
392 "_on_track": self.get_on_track(),
394 Book.objects.filter(pk=self.pk).update(**update)
395 self.refresh_dc_cache()
398 def build_cover(self):
399 width, height = 212, 300
401 xml = self.materialize(publishable=True).encode('utf-8')
402 info = BookInfo.from_bytes(xml)
404 if self.project is not None:
405 if self.project.logo_mono or self.project.logo:
406 kwargs['cover_logo'] = (self.project.logo_mono or self.project.logo).path
407 cover = make_cover(info, width=width, height=height, **kwargs)
411 self.cover.save(f'{self.slug}.{ext}', out, save=False)
412 type(self).objects.filter(pk=self.pk).update(cover=self.cover)
414 type(self).objects.filter(pk=self.pk).update(cover='')
416 # Materializing & publishing
417 # ==========================
419 def get_current_changes(self, publishable=True):
421 Returns a list containing one Change for every Chunk in the Book.
422 Takes the most recent revision (publishable, if set).
423 Throws an error, if a proper revision is unavailable for a Chunk.
426 changes = [chunk.publishable() for chunk in self]
428 changes = [chunk.head for chunk in self if chunk.head is not None]
430 raise self.NoTextError('Some chunks have no available text.')
433 def materialize(self, publishable=False, changes=None):
435 Get full text of the document compiled from chunks.
436 Takes the current versions of all texts
437 or versions most recently tagged for publishing,
438 or a specified iterable changes.
441 changes = self.get_current_changes(publishable)
442 return compile_text(change.materialize() for change in changes)
444 def wldocument(self, publishable=True, changes=None,
445 parse_dublincore=True, strict=False, librarian2=False):
446 from documents.ebook_utils import RedakcjaDocProvider
447 from librarian.parser import WLDocument
448 from librarian.document import WLDocument as WLDocument2
450 provider = RedakcjaDocProvider(publishable=publishable)
451 xml = self.materialize(publishable=publishable, changes=changes).encode('utf-8')
457 return WLDocument.from_bytes(
460 parse_dublincore=parse_dublincore,
463 def publish(self, user, fake=False, host=None, days=0, beta=False, hidden=False):
465 Publishes a book on behalf of a (local) user.
467 self.assert_publishable()
468 changes = self.get_current_changes(publishable=True)
470 book_xml = self.materialize(changes=changes)
471 data = {"book_xml": book_xml, "days": days, "hidden": hidden}
472 if self.project is not None:
473 if self.project.logo:
474 data['logo'] = urljoin(
475 'https://' + Site.objects.get_current().domain,
476 self.project.logo.url,
478 if self.project.logo_mono:
479 data['logo_mono'] = urljoin(
480 'https://' + Site.objects.get_current().domain,
481 self.project.logo_mono.url,
483 if self.project.logo_alt:
484 data['logo_alt'] = self.project.logo_alt
486 data['gallery_url'] = host + self.gallery_url()
487 apiclient.api_call(user, "books/", data, beta=beta)
490 br = BookPublishRecord.objects.create(book=self, user=user)
492 ChunkPublishRecord.objects.create(book_record=br, change=c)
493 if not self.public and days == 0:
496 if self.public and days > 0:
499 post_publish.send(sender=br)
502 doc = self.wldocument()
503 return doc.latex_dir(cover=True, ilustr_path=self.gallery_path())