X-Git-Url: https://git.mdrn.pl/redakcja.git/blobdiff_plain/1dfd391b507447d7f4a66863e4f6003979777426..bdabaaf2da173e1778667f69f125925dcb9149df:/apps/wiki/models.py?ds=sidebyside diff --git a/apps/wiki/models.py b/apps/wiki/models.py index 438ec5d3..4dc70173 100644 --- a/apps/wiki/models.py +++ b/apps/wiki/models.py @@ -3,147 +3,205 @@ # This file is part of FNP-Redakcja, licensed under GNU Affero GPLv3 or later. # Copyright © Fundacja Nowoczesna Polska. See NOTICE for more information. # -from django.db import models +import itertools import re -import os -import vstorage -from vstorage import DocumentNotFound -from wiki import settings, constants + +from django.core.urlresolvers import reverse +from django.db import models +from django.utils.safestring import mark_safe from django.utils.translation import ugettext_lazy as _ +from django.template.loader import render_to_string -from django.http import Http404 +from dvcs import models as dvcs_models +from wiki.xml_tools import compile_text import logging logger = logging.getLogger("fnp.wiki") -# _PCHARS_DICT = dict(zip((ord(x) for x in u"ĄĆĘŁŃÓŚŻŹąćęłńóśżź "), u"ACELNOSZZacelnoszz_")) -_PCHARS_DICT = dict(zip((ord(x) for x in u" "), u"_")) - -# I know this is barbaric, but I didn't find a better solution ;( -def split_name(name): - parts = name.translate(_PCHARS_DICT).split('__') - return parts - -def join_name(*parts, **kwargs): - name = u'__'.join(p.translate(_PCHARS_DICT) for p in parts) - logger.info("JOIN %r -> %r", parts, name) - return name - -def normalize_name(name): - """ - >>> normalize_name("gąska".decode('utf-8')) - u'g\u0105ska' - """ - return unicode(name).translate(_PCHARS_DICT).lower() - -STAGE_TAGS_RE = re.compile(r'^#stage-finished: (.*)$', re.MULTILINE) - - -class DocumentStorage(object): - def __init__(self, path): - self.vstorage = vstorage.VersionedStorage(path) - - def get(self, name, revision=None): - text, rev = self.vstorage.page_text(name, revision) - return Document(self, name=name, text=text, revision=rev) - - def get_by_tag(self, name, tag): - text, rev = self.vstorage.page_text_by_tag(name, tag) - return Document(self, name=name, text=text, revision=rev) - - def revert(self, name, revision): - text, rev = self.vstorage.revert(name, revision) - return Document(self, name=name, text=text, revision=rev) - - def get_or_404(self, *args, **kwargs): - try: - return self.get(*args, **kwargs) - except DocumentNotFound: - raise Http404 +class Book(models.Model): + """ A document edited on the wiki """ - def put(self, document, author, comment, parent=None): - self.vstorage.save_text( - title=document.name, - text=document.text, - author=author, - comment=comment, - parent=parent) + title = models.CharField(_('title'), max_length=255) + slug = models.SlugField(_('slug'), max_length=128, unique=True) + gallery = models.CharField(_('scan gallery name'), max_length=255, blank=True) - return document + parent = models.ForeignKey('self', null=True, blank=True, verbose_name=_('parent'), related_name="children") + parent_number = models.IntegerField(_('parent number'), null=True, blank=True, db_index=True) - def create_document(self, text, name): - title = u', '.join(p.title() for p in split_name(name)) + _list_html = models.TextField(editable=False, null=True) - if text is None: - text = u'' + class NoTextError(BaseException): + pass - document = Document(self, name=name, text=text, title=title) - return self.put(document, u"", u"Document created.") - - def delete(self, name, author, comment): - self.vstorage.delete_page(name, author, comment) - - def all(self): - return list(self.vstorage.all_pages()) - - def history(self, title): - def stage_desc(match): - stage = match.group(1) - return _("Finished stage: %s") % constants.DOCUMENT_STAGES_DICT[stage] - - for changeset in self.vstorage.page_history(title): - changeset['description'] = STAGE_TAGS_RE.sub(stage_desc, changeset['description']) - yield changeset - - - -class Document(object): - META_REGEX = re.compile(r'\s*', re.DOTALL | re.MULTILINE) + class Meta: + ordering = ['parent_number', 'title'] + verbose_name = _('book') + verbose_name_plural = _('books') - def __init__(self, storage, **kwargs): - self.storage = storage - for attr, value in kwargs.iteritems(): - setattr(self, attr, value) + def __unicode__(self): + return self.title + + def get_absolute_url(self): + return reverse("wiki_book", args=[self.slug]) + + def save(self, reset_list_html=True, *args, **kwargs): + if reset_list_html: + self._list_html = None + return super(Book, self).save(*args, **kwargs) + + @classmethod + def create(cls, creator=None, text=u'', *args, **kwargs): + """ + >>> Book.create(slug='x', text='abc').materialize() + 'abc' + """ + instance = cls(*args, **kwargs) + instance.save() + instance[0].commit(author=creator, text=text) + return instance + + def __iter__(self): + return iter(self.chunk_set.all()) + + def __getitem__(self, chunk): + return self.chunk_set.all()[chunk] + + def __len__(self): + return self.chunk_set.count() + + def list_html(self): + if self._list_html is None: + print 'rendering', self.title + self._list_html = render_to_string('wiki/document_list_item.html', + {'book': self}) + self.save(reset_list_html=False) + return mark_safe(self._list_html) + + @staticmethod + def publish_tag(): + return dvcs_models.Tag.get('publish') + + def materialize(self, tag=None): + """ + Get full text of the document compiled from chunks. + Takes the current versions of all texts + or versions most recently tagged by a given tag. + """ + if tag: + changes = [chunk.last_tagged(tag) for chunk in self] + else: + changes = [chunk.head for chunk in self] + if None in changes: + raise self.NoTextError('Some chunks have no available text.') + return compile_text(change.materialize() for change in changes) + + def publishable(self): + if not len(self): + return False + for chunk in self: + if not chunk.publishable(): + return False + return True + + def make_chunk_slug(self, proposed): + """ + Finds a chunk slug not yet used in the book. + """ + slugs = set(c.slug for c in self) + i = 1 + new_slug = proposed + while new_slug in slugs: + new_slug = "%s-%d" % (proposed, i) + i += 1 + return new_slug + + def append(self, other): + number = self[len(self) - 1].number + 1 + single = len(other) == 1 + for chunk in other: + # move chunk to new book + chunk.book = self + chunk.number = number + + # try some title guessing + if other.title.startswith(self.title): + other_title_part = other.title[len(self.title):].lstrip(' /') + else: + other_title_part = other.title + + if single: + # special treatment for appending one-parters: + # just use the guessed title and original book slug + chunk.comment = other_title_part + if other.slug.startswith(self.slug): + chunk_slug = other.slug[len(self.slug):].lstrip('-_') + else: + chunk_slug = other.slug + chunk.slug = self.make_chunk_slug(chunk_slug) + else: + chunk.comment = "%s, %s" % (other_title_part, chunk.comment) + chunk.slug = self.make_chunk_slug(chunk.slug) + chunk.save() + number += 1 + other.delete() + + @staticmethod + def listener_create(sender, instance, created, **kwargs): + if created: + instance.chunk_set.create(number=1, slug='1') + +models.signals.post_save.connect(Book.listener_create, sender=Book) + + +class Chunk(dvcs_models.Document): + """ An editable chunk of text. Every Book text is divided into chunks. """ + + book = models.ForeignKey(Book, editable=False) + number = models.IntegerField() + slug = models.SlugField() + comment = models.CharField(max_length=255) - def add_tag(self, tag, revision, author): - """ Add document specific tag """ - logger.debug("Adding tag %s to doc %s version %d", tag, self.name, revision) - self.storage.vstorage.add_page_tag(self.name, revision, tag, user=author) + class Meta: + unique_together = [['book', 'number'], ['book', 'slug']] + ordering = ['number'] - @property - def plain_text(self): - return re.sub(self.META_REGEX, '', self.text, 1) + def __unicode__(self): + return "%d-%d: %s" % (self.book_id, self.number, self.comment) - def meta(self): - result = {} + def get_absolute_url(self): + return reverse("wiki_editor", args=[self.book.slug, self.slug]) - m = re.match(self.META_REGEX, self.text) - if m: - for line in m.group(1).split('\n'): - try: - k, v = line.split(':', 1) - result[k.strip()] = v.strip() - except ValueError: - continue + @classmethod + def get(cls, slug, chunk=None): + if chunk is None: + return cls.objects.get(book__slug=slug, number=1) + else: + return cls.objects.get(book__slug=slug, slug=chunk) - gallery = result.get('gallery', self.name.replace(' ', '_')) + def pretty_name(self): + return "%s, %s (%d/%d)" % (self.book.title, self.comment, + self.number, len(self.book)) - if gallery.startswith('/'): - gallery = os.path.basename(gallery) + def publishable(self): + return self.last_tagged(Book.publish_tag()) - result['gallery'] = gallery - return result + def split(self, slug, comment='', creator=None): + """ Create an empty chunk after this one """ + self.book.chunk_set.filter(number__gt=self.number).update( + number=models.F('number')+1) + new_chunk = self.book.chunk_set.create(number=self.number+1, + creator=creator, slug=slug, comment=comment) + return new_chunk - def info(self): - return self.storage.vstorage.page_meta(self.name, self.revision) + @staticmethod + def listener_saved(sender, instance, created, **kwargs): + if instance.book: + # save book so that its _list_html is reset + instance.book.save() -def getstorage(): - return DocumentStorage(settings.REPOSITORY_PATH) +models.signals.post_save.connect(Chunk.listener_saved, sender=Chunk) -# -# Django models -# class Theme(models.Model): name = models.CharField(_('name'), max_length=50, unique=True)