wbwriter 2.2.1__py2.py3-none-any.whl

wbwriter/models/article_type.py

@@ -0,0 +1,59 @@
+from django.db import models
+from slugify import slugify
+from wbcore.models import WBModel
+
+
+class ArticleType(WBModel):
+    """An arbitrary type for articles.
+
+    The type of an article helps filtering out undesired categories of
+    articles.
+    Furthermore, having the article type in a separate model allows adding,
+    removing, and changing types during runtime.
+
+    Attributes
+    ----------
+    label : models.CharField
+        The unique label for this type.
+        This is meant to be displayed to users.
+    slug : models.SlugField
+        A slugified version fo the label.
+        This is used for searching ArticleTypes.
+    parsers : models.ManyToManyField
+        One or more optional parsers. The parser are used to convert the
+        `content` of an article and its associated in-editor template(s)
+        to something that can be published.
+    """
+
+    label = models.CharField(max_length=255, unique=True)
+    slug = models.SlugField(max_length=255, null=True, blank=True, unique=True)
+    parsers = models.ManyToManyField("wbwriter.PublicationParser", related_name="publication_parsers", blank=True)
+    peer_reviewers = models.ManyToManyField("directory.Person", related_name="article_type_peer_reviewers")
+    qa_reviewers = models.ManyToManyField("directory.Person", related_name="article_type_qa_reviewers")
+
+    @classmethod
+    def get_endpoint_basename(self):
+        return "wbwriter:articletyperepresentation"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbwriter:articletyperepresentation-list"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{label}}"
+
+    def __str__(self):
+        return self.label
+
+    def save(self, *args, **kwargs):
+        self.slug = slugify(self.label)
+        super().save(*args, **kwargs)
+
+    class Meta:
+        verbose_name = "Article Type"
+        verbose_name_plural = "Article Types"

wbwriter/models/block.py

@@ -0,0 +1,24 @@
+from django.db import models
+from django.template import Context
+from django.template import Template as DjangoTemplate
+from slugify import slugify
+
+
+class Block(models.Model):
+    title = models.CharField(max_length=512)
+    key = models.CharField(max_length=512, null=True, blank=True)
+    html = models.TextField(default="")
+
+    def __str__(self):
+        return self.title
+
+    def save(self, *args, **kwargs):
+        self.key = slugify(self.title)
+        super().save(*args, **kwargs)
+
+    def parse_parameters(self, parameters):
+        for index, parameter in enumerate(self.parameters.all().order_by("order")):
+            yield parameter.title, parameter.parse_parameter(parameters[index])
+
+    def render(self, parameters):
+        return DjangoTemplate(self.html).render(Context(dict(self.parse_parameters(parameters))))

wbwriter/models/block_parameter.py

@@ -0,0 +1,19 @@
+import json
+
+from django.db import models
+
+
+class BlockParameter(models.Model):
+    block = models.ForeignKey(to="wbwriter.Block", related_name="parameters", on_delete=models.CASCADE)
+
+    order = models.PositiveIntegerField()
+    title = models.CharField(max_length=255)
+    many = models.BooleanField(default=False)
+
+    def __str__(self):
+        return f"{self.block.title}: {self.title}"
+
+    def parse_parameter(self, parameter):
+        if self.many:
+            return json.loads(parameter)
+        return parameter

wbwriter/models/in_editor_template.py

@@ -0,0 +1,102 @@
+from django.db import models
+from wbcore.models import WBModel
+
+
+class InEditorTemplate(WBModel):
+    """A template that the user can choose and configure in the context of
+    the WYSIWYG editor.
+
+    In-Editor templates define CSS styles that need to be applied in
+    combination with the HTML template, and a number of other
+    In-Editor templates that may be nested within the given In-Editor
+    template.
+
+    Note that templates can not allow themself to be nested inside them.
+
+    Attributes
+    ----------
+    uuid : models.CharField
+        A unique identifier. The `uuid` must pass as a valid CSS class and
+        must less than 256 characters long.
+
+        The regular expression for valid CSS classes: "-?[_a-zA-Z]+[_a-zA-Z0-9-]*"
+
+        See section 4.1.3, second paragraph on
+        https://www.w3.org/TR/CSS21/syndata.html#characters
+    title : models.CharField
+        A human readable title.
+    description : models.TextField
+        A descriptive text that outlines the use case and possible
+        configurations of the template.
+    style : models.TextField, optional
+        The CSS that is required to properly display the HTML template.
+    template : models.TextField
+        The HTML that makes up the template.
+
+        TODO: WRITE ABOUT SCHEMA AND CONFIGURATION OPTIONS.
+    is_stand_alone_template : models.BooleanField, default=True
+        Signifies whether this template can be used without a surrounding
+        template (i.e. as root node of the article).
+    """
+
+    uuid = models.CharField(max_length=255, unique=True)
+    title = models.CharField(
+        verbose_name="Title",
+        max_length=255,
+        help_text="The title should be unique but doesn't need to be.",
+    )
+    description = models.TextField(
+        verbose_name="Description",
+        default="",
+        help_text="A brief text that describes the use case for this template.",
+    )
+    style = models.TextField(
+        verbose_name="Template CSS",
+        default="",
+        blank=True,
+        null=True,
+        help_text="The CSS that styles the templates HTML.",
+    )
+    template = models.TextField(
+        verbose_name="Template HTML",
+        default="",
+        help_text="The HTML code of the template.",
+    )
+    # configuration_field_definitions = models.JSONField(
+    #     verbose_name="Configuration Field Definitions",
+    #     help_text="Maps configuration IDs to field definitions for rendering a form.",
+    #     blank=True,
+    #     null=True,
+    # )
+    # configuration_form_layout = models.JSONField(
+    #     verbose_name="Configuration Form Layout",
+    #     help_text="The field layout of the configuration form.",
+    #     blank=True,
+    #     null=True,
+    # )
+    modified = models.DateTimeField(
+        verbose_name="Last modification date and time",
+        auto_now=True,
+        help_text="The last time this template has been edited.",
+    )
+
+    is_stand_alone_template = models.BooleanField(default=True)
+
+    def __str__(self):
+        return self.title
+
+    @classmethod
+    def get_endpoint_basename(self):
+        return "wbwriter:in-editor-template"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbwriter:in-editor-template-list"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{ title }}"

wbwriter/models/meta_information.py

@@ -0,0 +1,87 @@
+from django.db import models
+from django.dispatch import receiver
+from wbcore.models import WBModel
+
+
+class MetaInformation(WBModel):
+    class MetaInformationType(models.TextChoices):
+        # NOTE: This is just one value for now. However, this structure allows us to add more data type in the future.
+        BOOLEAN = "BOOLEAN", "Boolean"
+
+    article_type = models.ManyToManyField(to="wbwriter.ArticleType", related_name="meta_information")
+    name = models.CharField(max_length=255, null=False, blank=False, unique=True)
+    key = models.CharField(max_length=255, null=False, blank=False, unique=True)
+    meta_information_type = models.CharField(
+        max_length=24, choices=MetaInformationType.choices, default=MetaInformationType.BOOLEAN
+    )
+    boolean_default = models.BooleanField(null=True, blank=True)
+
+    def __str__(self) -> str:
+        return f"{self.name} ({self.key})"
+
+    class Meta:
+        verbose_name = "Meta Information"
+        verbose_name_plural = "Meta Information"
+
+    @classmethod
+    def get_endpoint_basename(self):
+        return "wbwriter:metainformation"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbwriter:metainformation-list"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{name}} ({{key}})"
+
+
+class MetaInformationInstance(WBModel):
+    article = models.ForeignKey(to="wbwriter.Article", related_name="meta_information", on_delete=models.CASCADE)
+
+    meta_information = models.ForeignKey(
+        to="wbwriter.MetaInformation", related_name="instances", on_delete=models.CASCADE
+    )
+    boolean_value = models.BooleanField(null=True, blank=True)
+
+    def __str__(self) -> str:
+        return f"{self.meta_information} / {self.article}: {self.boolean_value}"
+
+    class Meta:
+        verbose_name = "Meta Information Instance"
+        verbose_name_plural = "Meta Information Instances"
+
+        constraints = [
+            models.UniqueConstraint(fields=["meta_information", "article"], name="unique_meta_information_article")
+        ]
+
+    @classmethod
+    def get_endpoint_basename(self):
+        return "wbwriter:metainformationinstance"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbwriter:metainformationinstance-list"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{meta_information.name}}"
+
+
+@receiver(models.signals.post_save, sender="wbwriter.Article")
+def create_meta_information_instances(sender, instance, created, **kwargs):
+    if created and instance.type:
+        for meta_information in instance.type.meta_information.all():
+            MetaInformationInstance.objects.get_or_create(
+                meta_information=meta_information,
+                article=instance,
+                defaults={"boolean_value": meta_information.boolean_default},
+            )

wbwriter/models/mixins.py

@@ -0,0 +1,9 @@
+from django.db import models
+
+
+class PublishableMixin(models.Model):
+    def get_publication_metadata(self) -> dict[str, str]:
+        raise NotImplementedError("You must implement get_publication_metadata")
+
+    class Meta:
+        abstract = True

wbwriter/models/publication_models.py

@@ -0,0 +1,170 @@
+import datetime
+from importlib import import_module
+
+from django.contrib.contenttypes.fields import GenericForeignKey
+from django.contrib.contenttypes.models import ContentType
+from django.db import models
+from django.utils.functional import cached_property
+from rest_framework.reverse import reverse
+from slugify import slugify
+from wbcore.contrib.tags.models import TagModelMixin
+
+
+class Publication(TagModelMixin, models.Model):
+    """A publication of anything.
+
+    A publication stores content prepared for a specific platform or use
+    case. For instance, it stores an HTML string for publishing something on
+    web.
+    """
+
+    class Meta:
+        verbose_name = "Publication"
+        verbose_name_plural = "Publications"
+
+    title = models.CharField(max_length=1024)
+
+    slug = models.CharField(max_length=1024, blank=True)
+
+    target = models.CharField(max_length=256)
+
+    teaser_image = models.ImageField(blank=True, null=True, upload_to="writer/publication/teasers")
+    thumbnail_image = models.ImageField(blank=True, null=True, upload_to="writer/publication/thumbnails")
+
+    author = models.ForeignKey(
+        "directory.Person",
+        related_name="publication",
+        on_delete=models.PROTECT,
+        blank=True,
+        null=True,
+    )
+
+    created = models.DateField(
+        verbose_name="Creation Date",
+        auto_now_add=True,
+        help_text="The date on which this has been created.",
+    )
+
+    modified = models.DateTimeField(
+        verbose_name="Last Modification Datetime",
+        auto_now=True,
+        help_text="The date and time on which this has been modified last.",
+    )
+
+    description = models.TextField(default="", blank=True)
+
+    content = models.TextField(default="")
+
+    content_file = models.FileField(
+        max_length=256,
+        upload_to="writer/publication/content_files",
+        blank=True,
+        null=True,
+    )
+
+    parser = models.ForeignKey(
+        "wbwriter.PublicationParser",
+        related_name="parsed_publication",
+        on_delete=models.PROTECT,
+    )
+
+    additional_information = models.JSONField(default=dict, null=True, blank=True)
+
+    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
+    object_id = models.PositiveIntegerField()
+    content_object = GenericForeignKey("content_type", "object_id")
+
+    @classmethod
+    def create_or_update_from_parser_and_object(cls, parser, generic_object):
+        if hasattr(generic_object, "_build_dto") and callable(generic_object._build_dto):
+            ctype = ContentType.objects.get_for_model(generic_object)
+            pub, created = cls.objects.get_or_create(parser=parser, content_type=ctype, object_id=generic_object.id)
+            publ_metadata = generic_object.get_publication_metadata()
+            for k, v in publ_metadata.items():
+                setattr(pub, k, v)
+            pub.parser.parser_class(
+                generic_object._build_dto(), datetime.date.today() if created else pub.created
+            ).parse(pub)
+            pub.save()
+
+    @classmethod
+    def get_endpoint_basename(self):
+        return "wbwriter:publication"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbwriter:publicationrepresentation-list"
+
+    def save(self, *args, **kwargs):
+        self.slug = slugify(self.title)
+        super().save(*args, **kwargs)
+
+    def get_tag_detail_endpoint(self):
+        return reverse("wbwriter:publication-detail", [self.id])
+
+    def get_tag_representation(self):
+        return self.title
+
+
+class PublicationParser(models.Model):
+    """A parser meant to be used to parse something into a publication.
+
+    Attributes
+    ----------
+    title : models.CharField
+        The unique title for this parser.
+
+    parser_path : models.CharField
+        A dotted path to the parser file relatoive to the projects root
+        (ROOT/projects/).
+
+    created : models.DateField
+        The date on which this publication has been created.
+
+    content : models.TextField
+        The content of this publication in text form.
+
+    content_file : models.FileField
+        An optional file attachment, that represents the publications content.
+    """
+
+    class Meta:
+        verbose_name = "PublicationParser"
+        verbose_name_plural = "PublicationParsers"
+
+    title = models.CharField(
+        max_length=1024,
+        unique=True,
+    )
+    slug = models.CharField(max_length=1024, blank=True)
+    parser_path = models.CharField(
+        max_length=1024,
+        unique=True,
+    )
+
+    @cached_property
+    def parser_class(self):
+        return import_module(self.parser_path).Parser
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbwriter:publicationparser"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbwriter:publicationparserrepresentation-list"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{title}}"
+
+    def save(self, *args, **kwargs):
+        self.slug = slugify(self.title)
+        super().save(*args, **kwargs)
+
+    def __str__(self):
+        return f"{self.title}"

wbwriter/models/style.py

@@ -0,0 +1,13 @@
+from django.db import models
+
+
+class Style(models.Model):
+    """
+    A style is a valid CSS construct.
+    """
+
+    title = models.CharField(max_length=255, unique=True)
+    style = models.TextField(default="")
+
+    def __str__(self):
+        return self.title

wbwriter/models/template.py

@@ -0,0 +1,34 @@
+from django.db import models
+
+
+class Template(models.Model):
+    """
+    A template consists of n styles and a template which holds a {{content}} templatetag where the content is rendered
+    into.
+    """
+
+    title = models.CharField(max_length=255, unique=True)
+    template = models.TextField(default="")
+
+    header_template = models.ForeignKey(
+        "Template",
+        null=True,
+        blank=True,
+        related_name="header_templates",
+        on_delete=models.SET_NULL,
+    )
+    footer_template = models.ForeignKey(
+        "Template",
+        null=True,
+        blank=True,
+        related_name="footer_templates",
+        on_delete=models.SET_NULL,
+    )
+
+    styles = models.ManyToManyField(to="wbwriter.Style", related_name="templates", blank=True)
+
+    side_margin = models.FloatField(default=2.5)
+    extra_vertical_margin = models.FloatField(default=10)
+
+    def __str__(self):
+        return self.title

wbwriter/pdf_generator.py

@@ -0,0 +1,172 @@
+import base64
+
+from weasyprint import CSS, HTML
+from weasyprint.text.fonts import FontConfiguration
+
+
+class PdfGenerator:
+    """
+    Generate a PDF out of a rendered template, with the possibility to integrate nicely
+    a header and a footer if provided.
+
+    Notes:
+    ------
+    - When Weasyprint renders an html into a PDF, it goes though several intermediate steps.
+      Here, in this class, we deal mostly with a box representation: 1 `Document` have 1 `Page`
+      or more, each `Page` 1 `Box` or more. Each box can contain other box. Hence the recursive
+      method `get_element` for example.
+      For more, see:
+      https://weasyprint.readthedocs.io/en/stable/hacking.html#dive-into-the-source
+      https://weasyprint.readthedocs.io/en/stable/hacking.html#formatting-structure
+    - Warning: the logic of this class relies heavily on the internal Weasyprint API. This
+      snippet was written at the time of the release 47, it might break in the future.
+    - This generator draws its inspiration and, also a bit of its implementation, from this
+      discussion in the library github issues: https://github.com/Kozea/WeasyPrint/issues/92
+    """
+
+    OVERLAY_LAYOUT = "@page {size: A4 portrait; margin: 0;}"
+
+    def __init__(
+        self,
+        main_html,
+        header_html=None,
+        footer_html=None,
+        custom_css=[],
+        base_url=None,
+        side_margin=2,
+        extra_vertical_margin=30,
+    ):
+        """
+        Parameters
+        ----------
+        main_html: str
+            An HTML file (most of the time a template rendered into a string) which represents
+            the core of the PDF to generate.
+        header_html: str
+            An optional header html.
+        footer_html: str
+            An optional footer html.
+        custom_css: list
+            An optional list of css objects. (see weasyprint.CSS)
+        base_url: str
+            An absolute url to the page which serves as a reference to Weasyprint to fetch assets,
+            required to get our media.
+        side_margin: int, interpreted in cm, by default 2cm
+            The margin to apply on the core of the rendered PDF (i.e. main_html).
+        extra_vertical_margin: int, interpreted in pixel, by default 30 pixels
+            An extra margin to apply between the main content and header and the footer.
+            The goal is to avoid having the content of `main_html` touching the header or the
+            footer.
+        """
+        self.main_html = main_html
+        self.header_html = header_html
+        self.footer_html = footer_html
+        self.custom_css = custom_css
+        self.base_url = base_url
+        self.side_margin = side_margin
+        self.extra_vertical_margin = extra_vertical_margin
+
+    def _compute_overlay_element(self, element: str):
+        """
+        Parameters
+        ----------
+        element: str
+            Either 'header' or 'footer'
+
+        Returns
+        -------
+        element_body: BlockBox
+            A Weasyprint pre-rendered representation of an html element
+        element_height: float
+            The height of this element, which will be then translated in a html height
+        """
+        html = HTML(
+            string=getattr(self, f"{element}_html"),
+            base_url=self.base_url,
+        )
+        element_doc = html.render(stylesheets=[CSS(string=self.OVERLAY_LAYOUT)] + self.custom_css)
+        element_page = element_doc.pages[0]
+        element_body = PdfGenerator.get_element(element_page._page_box.all_children(), "body")
+        element_body = element_body.copy_with_children(element_body.all_children())
+        element_html = PdfGenerator.get_element(element_page._page_box.all_children(), element)
+
+        if element == "header":
+            element_height = element_html.height
+        if element == "footer":
+            element_height = element_page.height - element_html.position_y
+
+        return element_body, element_height
+
+    def _apply_overlay_on_main(self, main_doc, header_body=None, footer_body=None):
+        """
+        Insert the header and the footer in the main document.
+
+        Parameters
+        ----------
+        main_doc: Document
+            The top level representation for a PDF page in Weasyprint.
+        header_body: BlockBox
+            A representation for an html element in Weasyprint.
+        footer_body: BlockBox
+            A representation for an html element in Weasyprint.
+        """
+        for page in main_doc.pages:
+            page_body = PdfGenerator.get_element(page._page_box.all_children(), "body")
+
+            if header_body:
+                page_body.children += header_body.all_children()
+            if footer_body:
+                page_body.children += footer_body.all_children()
+
+    def render_pdf(self):
+        """
+        Returns
+        -------
+        pdf: a bytes sequence
+            The rendered PDF.
+        """
+        if self.header_html:
+            header_body, header_height = self._compute_overlay_element("header")
+        else:
+            header_body, header_height = None, 0
+        if self.footer_html:
+            footer_body, footer_height = self._compute_overlay_element("footer")
+        else:
+            footer_body, footer_height = None, 0
+
+        margins = "{header_size}px {side_margin} {footer_size}px {side_margin}".format(
+            header_size=header_height + self.extra_vertical_margin,
+            footer_size=footer_height + self.extra_vertical_margin,
+            side_margin=f"{self.side_margin}cm",
+        )
+        content_print_layout = "@page {size: A4 portrait; margin: %s;}" % margins
+
+        html = HTML(
+            string=self.main_html,
+            base_url=self.base_url,
+        )
+        font_config = FontConfiguration()
+        main_doc = html.render(
+            stylesheets=[CSS(string=content_print_layout)] + self.custom_css,
+            font_config=font_config,
+        )
+
+        if self.header_html or self.footer_html:
+            self._apply_overlay_on_main(main_doc, header_body, footer_body)
+        pdf = main_doc.write_pdf()
+        encoded = base64.b64encode(pdf)
+        encoded = encoded.decode("utf-8")
+        return pdf
+
+    @staticmethod
+    def get_element(boxes, element):
+        """
+        Given a set of boxes representing the elements of a PDF page in a DOM-like way, find the
+        box which is named `element`.
+
+        Look at the notes of the class for more details on Weasyprint insides.
+        """
+        for box in boxes:
+            if box.element_tag == element:
+                return box
+            return PdfGenerator.get_element(box.all_children(), element)