f96865474cbe1c0b10952c2e338fd0f40056c6f0
[redakcja.git] / apps / catalogue / models.py
1 # -*- coding: utf-8 -*-
2 #
3 # This file is part of FNP-Redakcja, licensed under GNU Affero GPLv3 or later.
4 # Copyright © Fundacja Nowoczesna Polska. See NOTICE for more information.
5 #
6 from django.contrib.auth.models import User
7 from django.core.urlresolvers import reverse
8 from django.db import models
9 from django.utils.translation import ugettext_lazy as _
10
11 from dvcs import models as dvcs_models
12 from catalogue.xml_tools import compile_text
13
14 import logging
15 logger = logging.getLogger("fnp.catalogue")
16
17
18 class Book(models.Model):
19     """ A document edited on the wiki """
20
21     title = models.CharField(_('title'), max_length=255, db_index=True)
22     slug = models.SlugField(_('slug'), max_length=128, unique=True, db_index=True)
23     gallery = models.CharField(_('scan gallery name'), max_length=255, blank=True)
24
25     parent = models.ForeignKey('self', null=True, blank=True, verbose_name=_('parent'), related_name="children")
26     parent_number = models.IntegerField(_('parent number'), null=True, blank=True, db_index=True)
27
28     class NoTextError(BaseException):
29         pass
30
31     class Meta:
32         ordering = ['parent_number', 'title']
33         verbose_name = _('book')
34         verbose_name_plural = _('books')
35         permissions = [('can_pubmark', 'Can mark for publishing')]
36
37     def __unicode__(self):
38         return self.title
39
40     def get_absolute_url(self):
41         return reverse("catalogue_book", args=[self.slug])
42
43     @classmethod
44     def create(cls, creator=None, text=u'', *args, **kwargs):
45         """
46             >>> Book.create(slug='x', text='abc').materialize()
47             'abc'
48         """
49         instance = cls(*args, **kwargs)
50         instance.save()
51         instance[0].commit(author=creator, text=text)
52         return instance
53
54     def __iter__(self):
55         return iter(self.chunk_set.all())
56
57     def __getitem__(self, chunk):
58         return self.chunk_set.all()[chunk]
59
60     def __len__(self):
61         return self.chunk_set.count()
62
63     def __nonzero__(self):
64         """
65             Necessary so that __len__ isn't used for bool evaluation.
66         """
67         return True
68
69     def get_current_changes(self, publishable=True):
70         """
71             Returns a list containing one Change for every Chunk in the Book.
72             Takes the most recent revision (publishable, if set).
73             Throws an error, if a proper revision is unavailable for a Chunk.
74         """
75         if publishable:
76             changes = [chunk.publishable() for chunk in self]
77         else:
78             changes = [chunk.head for chunk in self]
79         if None in changes:
80             raise self.NoTextError('Some chunks have no available text.')
81         return changes
82
83     def materialize(self, publishable=False, changes=None):
84         """ 
85             Get full text of the document compiled from chunks.
86             Takes the current versions of all texts
87             or versions most recently tagged for publishing,
88             or a specified iterable changes.
89         """
90         if changes is None:
91             changes = self.get_current_changes(publishable)
92         return compile_text(change.materialize() for change in changes)
93
94     def publishable(self):
95         if not self.chunk_set.exists():
96             return False
97         for chunk in self:
98             if not chunk.publishable():
99                 return False
100         return True
101
102     def publish(self, user):
103         """
104             Publishes a book on behalf of a (local) user.
105         """
106         from apiclient import api_call
107
108         changes = self.get_current_changes(publishable=True)
109         book_xml = book.materialize(changes=changes)
110         #api_call(user, "books", {"book_xml": book_xml})
111         # record the publish
112         br = BookPublishRecord.objects.create(book=self, user=user)
113         for c in changes:
114             ChunkPublishRecord.objects.create(book_record=br, change=c)
115
116     def make_chunk_slug(self, proposed):
117         """ 
118             Finds a chunk slug not yet used in the book.
119         """
120         slugs = set(c.slug for c in self)
121         i = 1
122         new_slug = proposed
123         while new_slug in slugs:
124             new_slug = "%s-%d" % (proposed, i)
125             i += 1
126         return new_slug
127
128     def append(self, other):
129         number = self[len(self) - 1].number + 1
130         single = len(other) == 1
131         for chunk in other:
132             # move chunk to new book
133             chunk.book = self
134             chunk.number = number
135
136             # try some title guessing
137             if other.title.startswith(self.title):
138                 other_title_part = other.title[len(self.title):].lstrip(' /')
139             else:
140                 other_title_part = other.title
141
142             if single:
143                 # special treatment for appending one-parters:
144                 # just use the guessed title and original book slug
145                 chunk.comment = other_title_part
146                 if other.slug.startswith(self.slug):
147                     chunk_slug = other.slug[len(self.slug):].lstrip('-_')
148                 else:
149                     chunk_slug = other.slug
150                 chunk.slug = self.make_chunk_slug(chunk_slug)
151             else:
152                 chunk.comment = "%s, %s" % (other_title_part, chunk.comment)
153                 chunk.slug = self.make_chunk_slug(chunk.slug)
154             chunk.save()
155             number += 1
156         other.delete()
157
158     @staticmethod
159     def listener_create(sender, instance, created, **kwargs):
160         if created:
161             instance.chunk_set.create(number=1, slug='1')
162
163 models.signals.post_save.connect(Book.listener_create, sender=Book)
164
165
166 class Chunk(dvcs_models.Document):
167     """ An editable chunk of text. Every Book text is divided into chunks. """
168
169     book = models.ForeignKey(Book, editable=False)
170     number = models.IntegerField()
171     slug = models.SlugField()
172     comment = models.CharField(max_length=255, blank=True)
173
174     class Meta:
175         unique_together = [['book', 'number'], ['book', 'slug']]
176         ordering = ['number']
177
178     def __unicode__(self):
179         return "%d-%d: %s" % (self.book_id, self.number, self.comment)
180
181     def get_absolute_url(self):
182         return reverse("wiki_editor", args=[self.book.slug, self.slug])
183
184     @classmethod
185     def get(cls, slug, chunk=None):
186         if chunk is None:
187             return cls.objects.get(book__slug=slug, number=1)
188         else:
189             return cls.objects.get(book__slug=slug, slug=chunk)
190
191     def pretty_name(self, book_length=None):
192         title = self.book.title
193         if self.comment:
194             title += ", %s" % self.comment
195         if book_length > 1:
196             title += " (%d/%d)" % (self.number, book_length)
197         return title
198
199     def split(self, slug, comment='', creator=None):
200         """ Create an empty chunk after this one """
201         self.book.chunk_set.filter(number__gt=self.number).update(
202                 number=models.F('number')+1)
203         new_chunk = self.book.chunk_set.create(number=self.number+1,
204                 creator=creator, slug=slug, comment=comment)
205         return new_chunk
206
207     @staticmethod
208     def listener_saved(sender, instance, created, **kwargs):
209         if instance.book:
210             # save book so that its _list_html is reset
211             instance.book.save()
212
213 models.signals.post_save.connect(Chunk.listener_saved, sender=Chunk)
214
215
216 class BookPublishRecord(models.Model):
217     """
218         A record left after publishing a Book.
219     """
220
221     book = models.ForeignKey(Book)
222     timestamp = models.DateTimeField(auto_now_add=True)
223     user = models.ForeignKey(User)
224
225     class Meta:
226         ordering = ['-timestamp']
227
228
229 class ChunkPublishRecord(models.Model):
230     """
231         BookPublishRecord details for each Chunk.
232     """
233
234     book_record = models.ForeignKey(BookPublishRecord)
235     change = models.ForeignKey(Chunk.change_model)