wbwriter 2.2.1__py2.py3-none-any.whl

wbwriter/publication_parser.py

@@ -0,0 +1,258 @@
+import json
+import os
+from abc import ABC
+from datetime import date
+from io import BytesIO
+from typing import Iterable
+
+from django.conf import settings
+from django.core.files.base import ContentFile
+from django.template.loader import render_to_string
+from PIL import Image, ImageOps
+from slugify import slugify
+from wbcore.contrib.tags.models import Tag
+from wbwriter.pdf_generator import PdfGenerator
+
+from .typings import ArticleDTO
+
+
+class ParserValidationException(Exception):
+    def __init__(self, *args, errors=None, **kwargs):  # real signature unknown
+        self.errors = errors
+
+
+class PublicationParser(ABC):  # pragma: no cover
+    def __init__(self, article: ArticleDTO, published_date: date):
+        self.article = article
+        self.published_date = published_date
+
+    @property
+    def template_path(self) -> str:
+        if hasattr(self, "TEMPLATE_PATH"):
+            return self.TEMPLATE_PATH
+        raise ValueError(
+            f"The attribute TEMPLATE_PATH needs to be define in the parser {self.__class__.__name__} in order to generate file"
+        )
+
+    @property
+    def article_type(self) -> str:
+        if hasattr(self, "ARTICLE_TYPE"):
+            return self.ARTICLE_TYPE
+        raise ValueError(
+            f"The attribute ARTICLE_TYPE needs to be define in the parser {self.__class__.__name__} in order to generate content"
+        )
+
+    @property
+    def default_section(self) -> str:
+        if hasattr(self, "DEFAULT_SECTION"):
+            return self.DEFAULT_SECTION
+        raise ValueError(
+            f"The attribute DEFAULT_SECTION needs to be define in the parser {self.__class__.__name__} in order to generate content"
+        )
+
+    @property
+    def errors(self) -> list[str]:
+        if not hasattr(self, "_errors"):
+            raise AssertionError("You must call `.is_valid()` before accessing `.errors`.")
+        return self._errors
+
+    def _is_valid(self) -> bool:
+        return True
+
+    def is_valid(self, raise_exception: bool = True) -> bool:
+        self._errors = []
+        is_valid = self._is_valid()
+        if self.errors and raise_exception:
+            raise ParserValidationException(errors=self.errors)
+        return is_valid
+
+    def _get_additional_information(self) -> dict[str, any]:
+        additional_information = {"type": self.article_type, "is-private": self.article.is_private}
+
+        for meta_info in self.article.meta_information:
+            additional_information[meta_info["meta_information__key"]] = meta_info["boolean_value"]
+        return additional_information
+
+    def get_file(self, context: dict[str, any] | None = None) -> BytesIO | None:
+        """Parses the given object's data and returns the publications content
+        rendered as a PDF.
+
+        Parameters
+        ----------
+        context: The context data that should be used by the file. Optional. If not provided, it will be fetchted from get_file_context
+
+        Returns
+        -------
+        Either None or ByteIO. The latter representing the PDF representation of the content.
+        """
+        if not context:
+            context = self.get_file_context()
+        html = render_to_string(self.template_path, context)
+
+        if settings.DEBUG:
+            if not os.path.isdir("tmp"):
+                os.mkdir("tmp")
+            with open(f"tmp/{slugify(self.article.title)}.html", "w") as f:
+                f.write(html)
+
+        pdf_generator = PdfGenerator(
+            main_html=html,
+            custom_css=[],
+            side_margin=0,
+            extra_vertical_margin=0,
+        )
+
+        return pdf_generator.render_pdf()
+
+    def _get_images(self) -> tuple[None | tuple[str, ContentFile], None | tuple[str, ContentFile]]:
+        """Derives the teaser image and its thumbnail form the given object.
+
+        On the first position there is a tuple that contains the filename and
+        the ContentFile for the teaser image, if it is not None.
+
+        On the second position there is a tuple that contains the filename and
+        the ContentFile for the thumbnail of the teaser image, if it is not
+        None.
+
+        Parameters
+        ----------
+        article: The data that should be published.
+
+        Returns
+        -------
+        Returns a tuple that may contain the data for a teaser image and
+        its thumbnail.
+
+        On the first position there is a tuple that contains the filename and
+        the ContentFile for the teaser image, if it is not None.
+
+        On the second position there is a tuple that contains the filename and
+        the ContentFile for the thumbnail of the teaser image, if it is not
+        None.
+        """
+        teaser_image = self.article.teaser_image
+        if not teaser_image:
+            return (None, None)
+
+        basename_parts = os.path.basename(teaser_image.name).rsplit(".", 1)
+        if len(basename_parts) < 2:
+            teaser_image_basename = basename_parts[0]
+            teaser_image_extension = "png"
+        else:
+            teaser_image_basename = basename_parts[0]
+            teaser_image_extension = basename_parts[1]
+
+        if len(teaser_image_basename) > 100:
+            teaser_image_basename = teaser_image_basename.substring(0, 92)
+        if teaser_image_extension == "jpg":  # NOTE: Image doesn't understand "jpg"
+            teaser_image_extension = "jpeg"
+        pil_image_obj = Image.open(self.article.teaser_image)
+
+        pil_image_obj = ImageOps.exif_transpose(
+            pil_image_obj
+        )  # We need transpose the image accoording to the Exif data for mobile phone shots
+
+        pil_teaser_image_obj = pil_image_obj.copy()
+        pil_teaser_image_obj.thumbnail((1000, 1000))
+        teaser_image_tuple = None
+        f_teaser = BytesIO()
+        try:
+            pil_teaser_image_obj.save(f_teaser, format=teaser_image_extension)
+            teaser_image_tuple = (
+                f"{teaser_image_basename}.{teaser_image_extension}",
+                ContentFile(f_teaser.getvalue()),
+            )
+        finally:
+            f_teaser.close()
+
+        pil_thumbnail_image_obj = pil_image_obj.copy()
+        pil_thumbnail_image_obj.thumbnail((510, 510))
+        thumbnail_image_tuple = None
+        f_thumbnail = BytesIO()
+        try:
+            pil_thumbnail_image_obj.save(f_thumbnail, format=teaser_image_extension)
+            thumbnail_image_tuple = (
+                f"{teaser_image_basename}_thumbnail.{teaser_image_extension}",
+                ContentFile(f_thumbnail.getvalue()),
+            )
+        finally:
+            f_thumbnail.close()
+
+        if teaser_image_tuple and thumbnail_image_tuple:
+            return (teaser_image_tuple, thumbnail_image_tuple)
+        if teaser_image_tuple:
+            return (teaser_image_tuple, None)
+        if thumbnail_image_tuple:
+            return (None, thumbnail_image_tuple)
+        return (None, None)
+
+    def _get_tags(self) -> Iterable[tuple[str, str]]:
+        """Derives the necessary tags from the object data..
+
+        Parameters
+        ----------
+        article: The data that should be published.
+
+        Returns
+        -------
+        A list of key, label tag
+
+        """
+        for tag_id in self.article.tags:
+            tag = Tag.objects.get(id=tag_id)
+            yield (tag.slug, tag.title)
+
+    def _get_target(self) -> str:
+        """Returns a string that is unique for the publication target.
+
+        Example:
+
+            "website" if the publication goes to a companies own website.
+        """
+        return "website"
+
+    def get_publication_content(self) -> str:
+        return json.dumps({"content": self.article.content})
+
+    def get_file_context(self) -> dict[str, str]:
+        return self.article.to_dict()
+
+    def parse(self, publication) -> None:
+        """Parses the data given in `article` and changes (but doesn't save) the
+        given publication instance accordingly.
+
+        Parameters
+        ----------
+        publication: An instance of the Publication model. This instance will
+        be changed based on the given data in `article`. The instance is not saved! You need to call the save method
+        yourself.
+
+        article: The data that should be parsed into a publication.
+
+        published_date: The date that the publication should display as the
+        publication date.
+        """
+
+        if self.is_valid():
+            publication.additional_information = self._get_additional_information()
+
+            publication.content = self.get_publication_content()
+
+            file = self.get_file()
+            if file:
+                publication.content_file.save(f"{publication.slug}.pdf", BytesIO(file))
+
+            (teaser_image, thumbnail_image) = self._get_images()
+            if teaser_image and len(teaser_image) == 2:
+                publication.teaser_image.save(teaser_image[0], teaser_image[1])
+            if thumbnail_image and len(thumbnail_image) == 2:
+                publication.thumbnail_image.save(thumbnail_image[0], thumbnail_image[1])
+
+            publication.tags.clear()
+            for tag_key, tag_title in self._get_tags():
+                tag = Tag.objects.get_or_create(
+                    slug=slugify(tag_key), content_type=None, defaults={"title": tag_title}
+                )[0]
+                publication.tags.add(tag)
+
+            publication.target = self._get_target()

wbwriter/serializers/__init__.py

@@ -0,0 +1,28 @@
+from .article import (
+    ArticleFullModelSerializer,
+    ArticleModelSerializer,
+    _get_plugin_configs,
+    can_administrate_article,
+    DependantArticleModelSerializer,
+    ArticleRepresentionSerializer,
+)
+from .article_type import (
+    ArticleTypeModelSerializer,
+    ArticleTypeRepresentationSerializer,
+)
+from .in_editor_template import (
+    InEditorTemplateModelSerializer,
+    InEditorTemplateRepresentationSerializer,
+)
+from .meta_information import (
+    MetaInformationInstanceModelSerializer,
+    MetaInformationInstanceRepresentationSerializer,
+    MetaInformationModelSerializer,
+    MetaInformationRepresentationSerializer,
+)
+from .publication import (
+    PublicationModelSerializer,
+    PublicationParserRepresentationSerializer,
+    PublicationParserSerializer,
+    PublicationRepresentationSerializer,
+)

wbwriter/serializers/article.py

@@ -0,0 +1,359 @@
+import wbcore.serializers as wb_serializers
+from rest_framework import serializers
+from rest_framework.exceptions import ValidationError
+from rest_framework.reverse import reverse, reverse_lazy
+from wbcore.contrib.directory.models import Person
+from wbcore.contrib.directory.serializers import (
+    InternalUserProfileRepresentationSerializer,
+)
+from wbcore.contrib.documents.models import Document
+from wbcore.contrib.tags.serializers import TagSerializerMixin
+from wbcore.serializers import (
+    HyperlinkField,
+    ModelSerializer,
+    PrimaryKeyRelatedField,
+    RepresentationSerializer,
+    TemplatedJSONTextEditor,
+    register_only_instance_resource,
+    register_resource,
+)
+from wbwriter.models import (
+    Article,
+    ArticleType,
+    DependantArticle,
+    can_administrate_article,
+)
+
+from .article_type import ArticleTypeRepresentationSerializer
+
+
+class ArticleRepresentionSerializer(RepresentationSerializer):
+    class Meta:
+        model = Article
+        fields = (
+            "id",
+            "title",
+        )
+
+
+class DependantArticleModelSerializer(ModelSerializer):
+    _article = ArticleRepresentionSerializer(source="article")
+    article_url = HyperlinkField(reverse_name="wbwriter:article-detail", id_field_name="article_id")
+    _dependant_article = ArticleRepresentionSerializer(source="dependant_article")
+    dependant_article_url = HyperlinkField(
+        reverse_name="wbwriter:article-detail", id_field_name="dependant_article_id"
+    )
+
+    class Meta:
+        model = DependantArticle
+        fields = (
+            "id",
+            "article",
+            "_article",
+            "article_url",
+            "dependant_article",
+            "_dependant_article",
+            "dependant_article_url",
+        )
+
+
+class ArticleModelSerializer(TagSerializerMixin, ModelSerializer):
+    """Serializes a subset of the fields of of the Article model to minimize
+    workload on serializing lists of instances.
+    """
+
+    author = PrimaryKeyRelatedField(
+        many=False, label="Author", queryset=lambda: Person.objects.filter_only_internal()
+    )  # we lazy load queryset to know evaluate them at runtime
+    _author = InternalUserProfileRepresentationSerializer(source="author")
+    _qa_reviewer = InternalUserProfileRepresentationSerializer(source="qa_reviewer", many=False)
+
+    _type = ArticleTypeRepresentationSerializer(source="type")
+
+    @register_resource()
+    def generate(self, instance, request, user):
+        return {
+            "generate_pdf": reverse("wbwriter:article-generate-pdf", args=[instance.id], request=request),
+            "edit": reverse("wbwriter:article-edit", args=[instance.id], request=request),
+        }
+
+    @register_resource()
+    def metainformationinstance(self, instance, request, user):
+        return {
+            "metainformationinstance": f'{reverse("wbwriter:metainformationinstancearticle-list", args=[instance.id], request=request)}',
+        }
+
+    @register_resource()
+    def dependencies(self, instance, request, user):
+        return {
+            "dependantarticle-article": reverse(
+                viewname="wbwriter:dependantarticle-article-list", args=[instance.id], request=request
+            ),
+            "usedarticle-article": reverse(
+                viewname="wbwriter:usedarticle-article-list", args=[instance.id], request=request
+            ),
+        }
+
+    @register_only_instance_resource()
+    def preview(self, instance, request, user, **kwargs):
+        if document := Document.get_for_object(instance).filter(system_key=instance.system_key).first():
+            return {"preview": document.file.url}
+        return dict()
+
+    @register_only_instance_resource()
+    def reroll_reviewers(self, instance, request, user, **kwargs):
+        if can_administrate_article(instance, user):
+            return {
+                "reroll_peer": reverse("wbwriter:article-reroll-peer", args=[instance.id], request=request),
+                "reroll_qa": reverse("wbwriter:article-reroll-qa", args=[instance.id], request=request),
+                "reroll_peer_and_qa": reverse(
+                    "wbwriter:article-reroll-peer-and-qa", args=[instance.id], request=request
+                ),
+                "assign_new_author": reverse(
+                    "wbwriter:article-assign-new-author", args=[instance.id], request=request
+                ),
+            }
+        else:
+            return {}
+
+    @register_only_instance_resource()
+    def publications(self, instance, request, user, view=None, **kwargs):
+        if view and instance.publications.exists():
+            return {
+                "publications": f"{reverse('wbwriter:publication-list', request=request)}?content_type={view.content_type.id}&object_id={instance.id}"
+            }
+        return {}
+
+    def create(self, validated_data):
+        if request := self.context.get("request"):
+            validated_data["author"] = request.user.profile
+        return super().create(validated_data)
+
+    def validate(self, data):
+        articles = Article.objects.filter(name=data.get("name"))
+        if self.instance is not None:
+            articles = articles.exclude(id=self.instance.id)
+            if data.get("title") in ["", None] and self.instance.title is None:
+                data["title"] = data.get("name")
+
+        if articles.exists():
+            raise ValidationError({"name": ["Name already exists."]})
+
+        return data
+
+    class Meta:
+        model = Article
+        fields = (
+            "id",
+            "name",
+            "title",
+            "slug",
+            "type",
+            "_type",
+            "status",
+            "teaser_image",
+            "created",
+            "modified",
+            "author",
+            "_author",
+            "qa_reviewer",
+            "_qa_reviewer",
+            "tags",
+            "_tags",
+            "_additional_resources",
+        )
+
+
+def _get_plugin_configs(request):
+    return {
+        "plugins": " ".join(
+            [
+                "advlist autolink lists link image charmap print preview anchor",
+                "searchreplace visualblocks fullscreen noneditable template",
+                "insertdatetime table advtable help wordcount code",
+                "pagebreak hr imagetools powerpaste lance flite",
+            ]
+        ),
+        "toolbar": " ".join(
+            [
+                "undo redo | formatselect | bold italic underline strikethrough backcolor | ",
+                "alignleft aligncenter alignright alignjustify | ",
+                "bullist numlist outdent indent | pastetext removeformat | help | code fullscreen | lance | ",
+                "flite-toggletracking flite-toggleshow | flite-acceptone flite-rejectone | flite-acceptall flite-rejectall",
+            ]
+        ),
+        "menu": {
+            "file": {
+                "title": "File",
+                "items": "newdocument restoredraft | preview | print",
+            },
+            "edit": {
+                "title": "Edit",
+                "items": "undo redo | cut copy paste | selectall | searchreplace",
+            },
+            "view": {
+                "title": "View",
+                "items": "visualaid visualchars visualblocks | spellchecker | preview fullscreen",
+            },
+            "insert": {
+                "title": "Insert",
+                "items": " | ".join(
+                    [
+                        "image link template codesample inserttable",
+                        "charmap emoticons hr",
+                        "pagebreak nonbreaking anchor toc",
+                        "insertdatetime",
+                    ]
+                ),
+            },
+            "format": {
+                "title": "Format",
+                "items": "bold italic underline strikethrough superscript subscript codeformat | formats blockformats"
+                + " fontformats fontsizes align lineheight | forecolor backcolor | removeformat",
+            },
+            "tools": {
+                "title": "Tools",
+                "items": "code | spellchecker spellcheckerlanguage | wordcount",
+            },
+            "table": {
+                "title": "Table",
+                "items": "inserttable | cell row column | tableprops deletetable",
+            },
+            # "tc": {"title": "Comments", "items": "addcomment showcomments deleteallconversations"},
+            "help": {"title": "Help", "items": "help"},
+        },
+        "paste_as_text": True,
+        "powerpaste_word_import": "clean",
+        "powerpaste_googledocs_import": "clean",
+        "powerpaste_html_import": "clean",
+        "browser_spellcheck": True,
+        "atp": {
+            "templates": reverse_lazy("wbwriter:in-editor-template-list", request=request),
+        },
+        "content_style": "body{margin:0px 12px;}",
+        "deprecation_warnings": False,
+    }
+
+
+class ArticleFullModelSerializer(ArticleModelSerializer):
+    """Serializes the full set of the fields of of the Article model."""
+
+    author = wb_serializers.PrimaryKeyRelatedField(
+        many=False,
+        label="Author",
+        read_only=lambda view: view.instance
+        and (view.can_edit_article_author and view.instance.status == Article.Status.APPROVED),
+        queryset=lambda: Person.objects.filter_only_internal(),
+        default=wb_serializers.CurrentUserDefault("profile"),
+    )
+    name = wb_serializers.CharField(
+        max_length=1024,
+        label="Name",
+        help_text="A unique name to reference this article.",
+        read_only=lambda view: view.instance
+        and (view.can_edit_article_meta_data and view.instance.status == Article.Status.APPROVED),
+    )
+    title = wb_serializers.CharField(
+        max_length=1024,
+        label="Title",
+        required=False,
+        help_text="The title of the article that is going to be used when imported into other articles. "
+        + "Defaults to the name of the article when not set.",
+        read_only=lambda view: view.instance
+        and (view.can_edit_article_meta_data and view.instance.status == Article.Status.APPROVED),
+    )
+
+    teaser_image = wb_serializers.ImageField(
+        label="Teaser image",
+        required=False,
+        read_only=lambda view: view.instance
+        and (view.can_edit_article_content and view.instance.status == Article.Status.APPROVED),
+    )
+
+    content = TemplatedJSONTextEditor(
+        templates="wbwriter:in-editor-template-list",
+        default_editor_config=_get_plugin_configs,
+        default="",
+        label="Content",
+        read_only=lambda view: view.instance
+        and (view.can_edit_article_content and view.instance.status == Article.Status.APPROVED),
+    )
+
+    type = wb_serializers.PrimaryKeyRelatedField(
+        label="Type",
+        many=False,
+        queryset=ArticleType.objects.all(),
+        read_only=lambda view: view.instance
+        and (view.can_edit_article_type and view.instance.status == Article.Status.APPROVED),
+    )
+    _type = ArticleTypeRepresentationSerializer(source="type", many=False)
+    feedback_contact = wb_serializers.PrimaryKeyRelatedField(
+        label="Feedback Contact",
+        many=False,
+        required=False,
+        default=wb_serializers.DefaultAttributeFromObject(source="author.id"),
+        queryset=lambda: Person.objects.filter_only_internal(),  # TODO: Filter out the people from the qa reviewer person group
+    )
+    _feedback_contact = InternalUserProfileRepresentationSerializer(source="feedback_contact", many=False)
+    reviewer = PrimaryKeyRelatedField(many=False, label="Reviewer", read_only=True)
+    _reviewer = InternalUserProfileRepresentationSerializer(source="reviewer", many=False)
+
+    peer_reviewer = PrimaryKeyRelatedField(
+        many=False,
+        label="Peer Reviewers",
+        read_only=lambda view: not view.can_administrate_article or not view.new_mode,
+    )
+    _peer_reviewer = InternalUserProfileRepresentationSerializer(source="peer_reviewer", many=False)
+
+    qa_reviewer = PrimaryKeyRelatedField(
+        many=False, label="QA Reviewer", read_only=lambda view: not view.can_administrate_article or not view.new_mode
+    )
+    _qa_reviewer = InternalUserProfileRepresentationSerializer(source="qa_reviewer", many=False)
+
+    def validate(self, data):
+        data = super().validate(data)
+        if "type" in data:
+            if (
+                self.instance
+                and data.get("type")
+                and data.get("type").slug != "ddq"
+                and (
+                    ("author" in data and not data.get("author"))
+                    or ("author" not in data and self.instance.author is None)
+                )
+            ):
+                raise serializers.ValidationError(
+                    {"type": 'This must be set to "DDQ" as long as no author has been assigned!'}
+                )
+
+        return data
+
+    class Meta:
+        model = Article
+        fields = (
+            "id",
+            "name",
+            "title",
+            "slug",
+            "type",
+            "_type",
+            "created",
+            "modified",
+            "teaser_image",
+            "content",
+            "status",
+            "author",
+            "_author",
+            "feedback_contact",
+            "_feedback_contact",
+            "reviewer",
+            "_reviewer",
+            "peer_reviewer",
+            "_peer_reviewer",
+            "qa_reviewer",
+            "_qa_reviewer",
+            "is_private",
+            "tags",
+            "_tags",
+            "_additional_resources",
+        )

wbwriter/serializers/article_type.py

@@ -0,0 +1,14 @@
+from wbcore.serializers import ModelSerializer, RepresentationSerializer
+from wbwriter.models import ArticleType
+
+
+class ArticleTypeModelSerializer(ModelSerializer):
+    class Meta:
+        model = ArticleType
+        fields = ("id", "label", "peer_reviewers", "qa_reviewers")
+
+
+class ArticleTypeRepresentationSerializer(RepresentationSerializer):
+    class Meta:
+        model = ArticleType
+        fields = ("id", "label")

wbwriter/serializers/in_editor_template.py

@@ -0,0 +1,37 @@
+from wbcore.serializers import HyperlinkField, ModelSerializer, RepresentationSerializer
+from wbwriter.models import InEditorTemplate
+
+
+class InEditorTemplateModelSerializer(ModelSerializer):
+    """Serializes the complete InEditorTemplate model."""
+
+    class Meta:
+        model = InEditorTemplate
+        fields = (
+            "id",
+            "uuid",
+            "title",
+            "description",
+            "style",
+            "template",
+            "modified",
+            "is_stand_alone_template",
+        )
+
+
+class InEditorTemplateRepresentationSerializer(RepresentationSerializer):
+    """Serializes the minimum number of fields of the InEditorTemplate model
+    that are needed to identify a template."""
+
+    _detail = HyperlinkField(reverse_name="wbwriter:in-editor-template-detail")
+
+    class Meta:
+        model = InEditorTemplate
+        fields = (
+            "id",
+            "uuid",
+            "title",
+            "description",
+            "is_stand_alone_template",
+            "_detail",
+        )