wbwriter 2.2.1__py2.py3-none-any.whl

wbwriter/serializers/meta_information.py

@@ -0,0 +1,67 @@
+from wbcore.serializers import ModelSerializer, RepresentationSerializer
+from wbwriter.models import MetaInformation, MetaInformationInstance
+
+from .article_type import ArticleTypeRepresentationSerializer
+
+
+class MetaInformationModelSerializer(ModelSerializer):
+    """Serializes all fields of the MetaInformation model."""
+
+    _article_type = ArticleTypeRepresentationSerializer(source="article_type", many=True)
+
+    class Meta:
+        model = MetaInformation
+        fields = (
+            "id",
+            "article_type",
+            "_article_type",
+            "name",
+            "key",
+            "meta_information_type",
+            "boolean_default",
+        )
+
+
+class MetaInformationRepresentationSerializer(RepresentationSerializer):
+    """Serializes the name and the key of the MetaInformation model."""
+
+    class Meta:
+        model = MetaInformation
+        fields = ("id", "name", "key")
+
+
+class MetaInformationInstanceModelSerializer(ModelSerializer):
+    # from wbwriter.serializers import ArticleFullModelSerializer
+
+    # _article = ArticleFullModelSerializer(source="article")
+    _meta_information = MetaInformationRepresentationSerializer(source="meta_information")
+
+    class Meta:
+        model = MetaInformationInstance
+        read_only_fields = ("meta_information",)
+        fields = (
+            "id",
+            "meta_information",
+            "_meta_information",
+            # "article",
+            # "_article",
+            "boolean_value",
+        )
+
+
+class MetaInformationInstanceRepresentationSerializer(RepresentationSerializer):
+    # from wbwriter.serializers import ArticleFullModelSerializer
+
+    # _article = ArticleFullModelSerializer(source="article")
+    _meta_information = MetaInformationRepresentationSerializer(source="meta_information")
+
+    class Meta:
+        model = MetaInformationInstance
+        fields = (
+            "id",
+            "meta_information",
+            "_meta_information",
+            # "article",
+            # "_article",
+            "boolean_value",
+        )

wbwriter/serializers/publication.py

@@ -0,0 +1,82 @@
+from contextlib import suppress
+
+from wbcore.contrib.directory.serializers import PersonRepresentationSerializer
+from wbcore.contrib.tags.serializers import TagSerializerMixin
+from wbcore.serializers import (
+    CharField,
+    HyperlinkField,
+    ModelSerializer,
+    RepresentationSerializer,
+    TextAreaField,
+    register_resource,
+)
+from wbwriter.models import Publication, PublicationParser
+
+
+class PublicationParserRepresentationSerializer(RepresentationSerializer):
+    """Serializes the ID and the title of the Publication Parser model."""
+
+    _detail = HyperlinkField(reverse_name="wbwriter:publicationparser-detail")
+
+    class Meta:
+        model = PublicationParser
+        fields = ("id", "title", "_detail")
+
+
+class PublicationModelSerializer(TagSerializerMixin, ModelSerializer):
+    """Serializes the all fields of the Publication model except for the slug field."""
+
+    description = TextAreaField()
+    title = CharField(read_only=True)
+    _author = PersonRepresentationSerializer(source="author")
+    author = CharField(read_only=True)
+    _parser = PublicationParserRepresentationSerializer(source="parser")
+
+    @register_resource()
+    def pdf_file(self, instance, request, user):
+        with suppress(ValueError):
+            if instance.content_file:
+                return {"pdf_file": instance.content_file.url}
+        return {}
+
+    class Meta:
+        model = Publication
+        fields = (
+            "id",
+            "title",
+            "target",
+            "author",
+            "_author",
+            "created",
+            "modified",
+            "content",
+            "description",
+            "teaser_image",
+            "thumbnail_image",
+            "tags",
+            "_tags",
+            "additional_information",
+            "_additional_resources",
+            "parser",
+            "_parser",
+            "content_type",
+            "object_id",
+        )
+        ordering = ("-modified", "title", "target")
+
+
+class PublicationRepresentationSerializer(RepresentationSerializer):
+    """Serializes the ID and the title of the Publication model."""
+
+    _detail = HyperlinkField(reverse_name="wbwriter:publication-detail")
+
+    class Meta:
+        model = Publication
+        fields = ("id", "title", "target", "modified", "_detail")
+        ordering = ("-modified", "title", "target")
+
+
+class PublicationParserSerializer(ModelSerializer):
+    class Meta:
+        model = PublicationParser
+        fields = ("id", "title", "slug", "parser_path")

wbwriter/templatetags/writer.py

@@ -0,0 +1,72 @@
+from django import template
+from django.core.exceptions import ValidationError
+from django.shortcuts import get_object_or_404
+from django.template import Context, Template
+from slugify import slugify
+from wbcore.markdown.template import load_registered_templatetags
+from wbwriter.models import Article
+
+register = template.Library()
+
+
+@register.inclusion_tag("wbwriter/templatetags/table_of_contents.html", takes_context=True)
+def table_of_contents(context, title="Table of contents", custom_enumeration=True):
+    if "article" in context and context.get("article"):
+        article = context.get("article")
+        article_toc = article.get_article_structure()
+        return {"title": title, "custom_enumeration": custom_enumeration, **article_toc}
+
+    return {"not_working": "<i>Table of content is only rendered in the exported PDF Version.</i>"}
+
+
+@register.simple_tag(takes_context=True)
+def load_article(context, article_id, with_title=True, include_in_toc=True, enumeration_from_toc=True):
+    prefix = ""
+    level = 1
+
+    article = get_object_or_404(Article, id=article_id)
+    # Render the content
+    template = ""
+    for section in article.content["sectionOrder"]:
+        template = article.content["sections"][section]["content"]["content"]
+
+    loaded_template_tags = load_registered_templatetags()
+    if with_title:
+        if main_article := context.get("article"):
+            if structure := main_article.article_structure.get(str(article_id)):
+                prefix = structure.get("enumerator", "")
+                level = structure.get("level", 1)
+
+        anchor = "<a name='" + slugify(article.name) + "'></a>"
+        template = f"<h1 class='header-{level}'>{prefix} {article.title}{anchor}</h1>\n" + template
+    return Template(loaded_template_tags + template).render(Context(context))
+
+
+@register.inclusion_tag("wbwriter/templatetags/cite_article.html", takes_context=True)
+def cite_article(context, article_id, text="(see {e} {t})"):
+    if "article" in context and context.get("article"):
+        main_article = context.get("article")
+        prefix = ""
+        if structure := main_article.article_structure.get(str(article_id)):
+            prefix = structure.get("enumerator", "")
+            structure.get("level", 1)
+        article = get_object_or_404(Article, id=article_id)
+        return {"anchor": slugify(article.name), "text": text.format(e=prefix, t=article.title)}
+
+    return {"not_working": "(article citations only work in a rendered pdf.)"}
+
+
+def block_templatetag(block):
+    def templatetag(context, *args):
+        parameters = block.parameters.all().count()
+        if parameters != len(args):
+            raise ValidationError({"non_field_errors": "Not all fields were send to the server."})
+        return block.render(args)
+
+    return templatetag
+
+
+# TODO do we need the following three lines of code? (13.07.2022 / CL)
+# with suppress(ProgrammingError):
+#     for block in Block.objects.all():
+#         register.simple_tag(takes_context=True, name=block.key)(block_templatetag(block))

wbwriter/tests/conftest.py

@@ -0,0 +1,32 @@
+from django.apps import apps
+from django.db import connection
+from django.db.models.signals import pre_migrate
+from pytest_factoryboy import register
+from wbcore.contrib.authentication.factories import UserFactory
+from wbcore.contrib.directory.factories import PersonFactory
+from wbcore.contrib.geography.tests.signals import app_pre_migration
+from wbwriter.factories import (
+    ArticleFactory,
+    ArticleTypeFactory,
+    BlockFactory,
+    InEditorTemplateFactory,
+    MetaInformationFactory,
+    MetaInformationInstanceFactory,
+    PublicationParserFactory,
+    TemplateFactory,
+)
+
+register(UserFactory)
+register(ArticleFactory)
+register(ArticleTypeFactory)
+register(BlockFactory)
+register(InEditorTemplateFactory)
+register(PersonFactory)
+register(PublicationParserFactory)
+register(TemplateFactory)
+register(MetaInformationFactory)
+register(MetaInformationInstanceFactory)
+
+from .signals import *
+
+pre_migrate.connect(app_pre_migration, sender=apps.get_app_config("wbwriter"))

wbwriter/tests/signals.py

@@ -0,0 +1,23 @@
+from django.dispatch import receiver
+from dynamic_preferences.registries import global_preferences_registry
+from wbcore.test.signals import custom_update_kwargs
+from wbwriter.models import Article
+from wbwriter.viewsets import ArticleModelViewSet, ReviewerArticleModelViewSet
+
+
+@receiver(custom_update_kwargs, sender=ReviewerArticleModelViewSet)
+def receive_kwargs_reviewer_article(sender, *args, **kwargs):
+    if (obj := kwargs.get("obj_factory")) and (user := kwargs.get("user")):
+        obj.reviewer = user.profile
+        obj.status = Article.Status.FEEDBACK
+        obj.author.employers.set({global_preferences_registry.manager()["directory__main_company"]})
+        obj.save()
+    return {}
+
+
+@receiver(custom_update_kwargs, sender=ArticleModelViewSet)
+def receive_kwargs_article(sender, *args, **kwargs):
+    if obj := kwargs.get("obj_factory"):
+        obj.author.employers.set({global_preferences_registry.manager()["directory__main_company"]})
+        obj.save()
+    return {}

wbwriter/tests/test_filter.py

@@ -0,0 +1,58 @@
+import pytest
+from rest_framework.test import APIRequestFactory
+from wbcore.contrib.authentication.factories import InternalUserFactory
+from wbwriter.factories import ArticleFactory, MetaInformationInstanceFactory
+from wbwriter.filters import MetaInformationInstanceFilter
+from wbwriter.models import MetaInformationInstance
+from wbwriter.viewsets import ArticleModelViewSet
+
+
+@pytest.mark.django_db
+class TestArticleFilters:
+    def test_get_my_articles_true(self):
+        employee_a = InternalUserFactory().profile
+        employee_b = InternalUserFactory().profile
+        user_a = employee_a.user_account
+        ArticleFactory(author=user_a.profile)
+        ArticleFactory(author=employee_b)
+        ArticleFactory(author=employee_b, reviewer=user_a.profile)
+
+        request = APIRequestFactory().get("")
+        request.user = user_a
+        mvs = ArticleModelViewSet(kwargs={})
+        qs = mvs.get_serializer_class().Meta.model.objects.all()
+        filtered_qs = mvs.filterset_class(request=request).get_my_articles(qs, "", True)
+        assert filtered_qs.count() == 2
+        assert filtered_qs.count() < qs.count()
+
+    def test_get_my_articles_false(self):
+        employee_a = InternalUserFactory.create().profile
+        employee_b = InternalUserFactory.create().profile
+        user_a = employee_a.user_account
+        ArticleFactory(author=user_a.profile)
+        ArticleFactory(author=employee_b)
+        ArticleFactory(author=employee_b, reviewer=user_a.profile)
+
+        request = APIRequestFactory().get("")
+        request.user = user_a
+        mvs = ArticleModelViewSet(kwargs={})
+        qs = mvs.get_serializer_class().Meta.model.objects.all()
+        filtered_qs = mvs.filterset_class(request=request).get_my_articles(qs, "", False)
+        assert filtered_qs.count() == qs.count()
+
+    def test_filter_for_article_with_id(self):
+        article = ArticleFactory()
+        MetaInformationInstanceFactory(article=article)
+        MetaInformationInstanceFactory.create_batch(4)
+        qs = MetaInformationInstance.objects.all()
+        filtered_qs = MetaInformationInstanceFilter.filter_for_article(self, queryset=qs, name="", value=article.id)
+        assert filtered_qs.count() == 1
+        assert filtered_qs.count() < qs.count()
+
+    def test_filter_for_article_no_id(self):
+        article = ArticleFactory()
+        MetaInformationInstanceFactory(article=article)
+        MetaInformationInstanceFactory.create_batch(4)
+        qs = MetaInformationInstance.objects.all()
+        filtered_qs = MetaInformationInstanceFilter.filter_for_article(self, queryset=qs, name="", value=None)
+        assert filtered_qs.count() == qs.count()