wbwriter 2.2.1__py2.py3-none-any.whl

wbwriter/urls.py

@@ -0,0 +1,83 @@
+from django.urls import include, path
+from wbcore.routers import WBCoreRouter
+from wbwriter import viewsets
+
+router = WBCoreRouter()
+router.register(r"publication", viewsets.PublicationModelViewSet, basename="publication")
+router.register(
+    r"publicationrepresentation", viewsets.PublicationRepresentationViewSet, basename="publicationrepresentation"
+)
+router.register(
+    r"publicationparserrepresentation",
+    viewsets.PublicationParserRepresentationViewSet,
+    basename="publicationparserrepresentation",
+)
+router.register(
+    r"publicationparser",
+    viewsets.PublicationParserModelViewSet,
+    basename="publicationparser",
+)
+
+router.register(r"article", viewsets.ArticleModelViewSet, basename="article")
+router.register(r"articlerepresentation", viewsets.ArticleRepresentionViewSet, basename="articlerepresentation")
+# router.register(r"ddq", viewsets.DDQArticleModelViewSet, basename="ddq")
+router.register(r"review-article", viewsets.ReviewerArticleModelViewSet, basename="review-article")
+router.register(
+    r"articletyperepresentation",
+    viewsets.ArticleTypeRepresentationViewSet,
+    basename="articletyperepresentation",
+)
+router.register(
+    r"articletype",
+    viewsets.ArticleTypeModelViewSet,
+    basename="articletype",
+)
+router.register(
+    r"in-editor-template",
+    viewsets.InEditorTemplateModelViewSet,
+    basename="in-editor-template",
+)
+router.register(
+    r"in-editor-template-representation",
+    viewsets.InEditorTemplateRepresentationViewSet,
+    basename="in-editor-template-representation",
+)
+router.register(
+    r"metainformation",
+    viewsets.MetaInformationRepresentationViewSet,
+    basename="metainformation",
+)
+router.register(
+    r"metainformationinstance",
+    viewsets.MetaInformationInstanceModelViewSet,
+    basename="metainformationinstance",
+)
+router.register(
+    r"dependantarticle",
+    viewsets.DependantArticleModelViewSet,
+    basename="dependantarticle",
+)
+article_router = WBCoreRouter()
+article_router.register(
+    r"metainformationinstancearticle",
+    viewsets.MetaInformationInstanceModelViewSet,
+    basename="metainformationinstancearticle",
+)
+article_router.register(
+    r"dependantarticle",
+    viewsets.DependantArticleModelViewSet,
+    basename="dependantarticle-article",
+)
+
+used_article_router = WBCoreRouter()
+used_article_router.register(
+    r"usedarticle",
+    viewsets.DependantArticleModelViewSet,
+    basename="usedarticle-article",
+)
+
+urlpatterns = [
+    path("", include(router.urls)),
+    path("article/<int:article_id>/", include(article_router.urls)),
+    path("article/<int:used_article_id>/", include(used_article_router.urls)),
+]

wbwriter/viewsets/__init__.py

@@ -0,0 +1,22 @@
+from .article import (
+    ArticleModelViewSet,
+    ReviewerArticleModelViewSet,
+    DependantArticleModelViewSet,
+    ArticleRepresentionViewSet,
+)
+from .article_type import ArticleTypeModelViewSet, ArticleTypeRepresentationViewSet
+from .in_editor_template import (
+    InEditorTemplateModelViewSet,
+    InEditorTemplateRepresentationViewSet,
+)
+from .meta_information import MetaInformationRepresentationViewSet
+from .meta_information_instance import (
+    MetaInformationInstanceModelViewSet,
+    MetaInformationInstanceRepresentationViewSet,
+)
+from .publication import (
+    PublicationModelViewSet,
+    PublicationParserModelViewSet,
+    PublicationParserRepresentationViewSet,
+    PublicationRepresentationViewSet,
+)

wbwriter/viewsets/article.py

@@ -0,0 +1,270 @@
+from django.contrib.contenttypes.models import ContentType
+from django.db.models import Q, QuerySet
+from django.shortcuts import get_object_or_404
+from django.utils.functional import cached_property
+from rest_framework import status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from reversion.views import RevisionMixin
+from wbcore.contrib.authentication.authentication import JWTCookieAuthentication
+from wbcore.contrib.directory.models import Person
+from wbcore.utils.views import CloneMixin
+from wbcore.viewsets import ModelViewSet, RepresentationViewSet
+from wbwriter.filters.article import ArticleFilter
+from wbwriter.models import Article, can_access_article
+from wbwriter.models.article import (
+    DependantArticle,
+    can_administrate_article,
+    can_edit_article_author,
+    can_edit_article_content,
+    can_edit_article_meta_data,
+    can_edit_article_type,
+    generate_pdf_as_task,
+)
+from wbwriter.serializers import (
+    ArticleFullModelSerializer,
+    ArticleRepresentionSerializer,
+    DependantArticleModelSerializer,
+)
+
+from .buttons import ArticleModelButtonConfig
+from .display import ArticleDisplayConfig, DependantArticleDisplayConfig
+from .endpoints import (
+    DependantArticleEndpointViewConfig,
+    ReviewerArticleModelEndpointConfig,
+)
+from .titles import ReviewerArticleTitleConfig
+
+
+class ArticleRepresentionViewSet(RepresentationViewSet):
+    queryset = Article.objects.all()
+    serializer_class = ArticleRepresentionSerializer
+
+
+class DependantArticleModelViewSet(ModelViewSet):
+    queryset = DependantArticle.objects.all()
+    serializer_class = DependantArticleModelSerializer
+    display_config_class = DependantArticleDisplayConfig
+    endpoint_config_class = DependantArticleEndpointViewConfig
+
+    def get_queryset(self) -> QuerySet[DependantArticle]:
+        queryset = super().get_queryset()
+        if article_id := self.kwargs.get("article_id", None):
+            queryset = queryset.filter(article_id=article_id)
+
+        if used_article_id := self.kwargs.get("used_article_id", None):
+            queryset = queryset.filter(dependant_article_id=used_article_id)
+
+        return queryset.select_related("article", "dependant_article")
+
+
+class ArticleInstancePermissionMixin:
+    @cached_property
+    def profile(self):
+        user = self.request.user
+        return user.profile
+
+    @cached_property
+    def instance(self) -> Article | None:
+        if "pk" in self.kwargs:
+            return self.get_object()
+
+    @cached_property
+    def can_edit_article_author(self) -> bool:
+        if self.instance:
+            return can_edit_article_author(self.instance, self.request.user)
+        return False
+
+    @cached_property
+    def can_edit_article_meta_data(self) -> bool:
+        if self.instance:
+            return can_edit_article_meta_data(self.instance, self.request.user)
+        return False
+
+    @cached_property
+    def can_edit_article_type(self) -> bool:
+        return can_edit_article_type(self.instance, self.request.user)
+
+    @cached_property
+    def can_edit_article_content(self) -> bool:
+        if self.instance:
+            return can_edit_article_content(self.instance, self.request.user)
+        return False
+
+    @cached_property
+    def can_administrate_article(self) -> bool:
+        if self.instance:
+            return can_administrate_article(self.instance, self.request.user)
+        return False
+
+
+class ArticleModelViewSet(ArticleInstancePermissionMixin, CloneMixin, RevisionMixin, ModelViewSet):
+    # LIST_DOCUMENTATION = "wbwriter/viewsets/documentation/article.md"
+
+    serializer_class = ArticleFullModelSerializer
+    queryset = Article.objects.all()
+
+    button_config_class = ArticleModelButtonConfig
+    display_config_class = ArticleDisplayConfig
+    filterset_class = ArticleFilter
+
+    search_fields = (
+        "tags__title",
+        "type__label",
+        "type__slug",
+        "content",
+        "title",
+        "name",
+    )
+    ordering = ("-modified",)
+    ordering_fields = (
+        "title",
+        "status",
+        "type",
+        "created",
+        "modified",
+        "id",
+        "author",
+        "reviewer",
+        "peer_reviewer",
+        "qa_reviewer",
+    )
+
+    @cached_property
+    def content_type(self):
+        return ContentType.objects.get(app_label="wbwriter", model="article")
+
+    def get_queryset(self):
+        if self.request.user.has_perm("wbwriter.administrate_article") or self.profile.is_internal:
+            qs = Article.objects.all()
+        else:
+            qs = Article.objects.filter(is_private=False)
+        return qs.select_related(
+            "type", "feedback_contact", "reviewer", "peer_reviewer", "qa_reviewer", "author"
+        ).prefetch_related("tags")
+
+    @action(detail=True, methods=["POST"], authentication_classes=[JWTCookieAuthentication])
+    def generate_pdf(self, request, pk):
+        """
+        NOTE: JWTCookieAuthentication only works, if the frontend is served under the same URL as the backend due to
+              the cookie.
+        """
+        article = get_object_or_404(Article, pk=pk)
+
+        if not can_access_article(article, request.user):
+            return Response({}, status=status.HTTP_403_FORBIDDEN)
+
+        generate_pdf_as_task.delay(pk, user_id=request.user.id)
+        return Response(
+            {"__notification": {"title": "PDF is going to be created"}},
+            status=status.HTTP_200_OK,
+        )
+
+    @action(detail=True, methods=["POST"], authentication_classes=[JWTCookieAuthentication])
+    def edit(self, request, pk):
+        """Sets the current user to be the author of the specified article."""
+        article = get_object_or_404(Article, pk=pk)
+        article.author = request.user.profile
+        article.save()
+        return Response(
+            {"__notification": {"title": f'You are now author of "{article.title}".'}},
+            status=status.HTTP_200_OK,
+        )
+
+    @action(detail=True, methods=["POST"], authentication_classes=[JWTCookieAuthentication])
+    def reroll_peer(self, request, pk):
+        """Rolls for a new peer reviewer."""
+        article = get_object_or_404(Article, pk=pk)
+        article.reroll_peer()
+        article.save()
+        return Response(
+            {"__notification": {"title": f'The new peer reviewer is "{article.peer_reviewer}".'}},
+            status=status.HTTP_200_OK,
+        )
+
+    @action(detail=True, methods=["POST"], authentication_classes=[JWTCookieAuthentication])
+    def reroll_qa(self, request, pk):
+        """Rolls for a new QA reviewer."""
+        article = get_object_or_404(Article, pk=pk)
+        article.reroll_qa()
+        article.save()
+        return Response(
+            {"__notification": {"title": f'The new QA reviewer is "{article.qa_reviewer}".'}},
+            status=status.HTTP_200_OK,
+        )
+
+    @action(detail=True, methods=["POST"], authentication_classes=[JWTCookieAuthentication])
+    def reroll_peer_and_qa(self, request, pk):
+        """Rolls for a new peer and a new QA reviewer."""
+        article = get_object_or_404(Article, pk=pk)
+        article.reroll_peer_and_qa()
+        article.save()
+        return Response(
+            {"__notification": {"title": f'You are now author of "{article.title}".'}},
+            status=status.HTTP_200_OK,
+        )
+
+    @action(detail=True, methods=["POST"], authentication_classes=[JWTCookieAuthentication])
+    def assign_new_author(self, request, pk):
+        """Assigns a new author."""
+        article = get_object_or_404(Article, pk=pk)
+        author_id = request.POST.get("author")
+        author = get_object_or_404(Person, pk=author_id)
+        article.author = author
+        article.save()
+        return Response(
+            {"__notification": {"title": f"The new author is {author}."}},
+            status=status.HTTP_200_OK,
+        )
+
+
+class ReviewerArticleModelViewSet(ArticleModelViewSet):
+    # LIST_DOCUMENTATION = "wbwriter/viewsets/documentation/article.md"
+
+    # serializer_class = ArticleModelSerializer
+    queryset = Article.objects.all()
+    title_config_class = ReviewerArticleTitleConfig
+
+    button_config_class = ArticleModelButtonConfig
+    display_config_class = ArticleDisplayConfig
+    endpoint_config_class = ReviewerArticleModelEndpointConfig
+
+    search_fields = (
+        "tags__title",
+        "type__label",
+        "type__slug",
+        "content",
+        "title",
+        "name",
+    )
+    filter_fields = {
+        "title": ["icontains"],
+        "status": ["exact"],
+        "tags": ["exact"],
+        "type": ["exact", "icontains"],
+        "author": ["exact"],
+        "reviewer": ["exact"],
+        "peer_reviewer": ["exact"],
+        "qa_reviewer": ["exact"],
+        "created": ["exact", "lt", "lte", "gt", "gte"],
+        "modified": ["exact", "lt", "lte", "gt", "gte"],
+    }
+    ordering = ("-modified",)
+    ordering_fields = ("title", "status", "type", "created", "modified")
+
+    def get_queryset(self):
+        return Article.objects.filter(
+            Q(reviewer=self.profile, status=Article.Status.FEEDBACK)
+            | Q(peer_reviewer=self.profile, status=Article.Status.PEER_REVIEW)
+            | Q(qa_reviewer=self.profile, status=Article.Status.QA_REVIEW)
+            | Q(author=self.profile, status=Article.Status.AUTHOR_APPROVAL)
+        )
+
+    def get_serializer_class(self):
+        # TODO: Create a unique endpoint for creating instances so that we
+        #       can assign a "new instance" to have better control over what
+        #       serializer we want to use.
+        # if self.kwargs.get("pk"):
+        #     return ArticleFullModelSerializer
+        # return ArticleModelSerializer
+        return ArticleFullModelSerializer

wbwriter/viewsets/article_type.py

@@ -0,0 +1,49 @@
+from wbcore.viewsets import ModelViewSet, RepresentationViewSet
+from wbwriter.models import ArticleType
+from wbwriter.serializers import (
+    ArticleTypeModelSerializer,
+    ArticleTypeRepresentationSerializer,
+)
+
+from .display import ArticleTypeDisplayConfig
+
+
+class ArticleTypeModelViewSet(ModelViewSet):
+    ENDPOINT = "wbwriter:article-type-list"
+
+    serializer_class = ArticleTypeModelSerializer
+    # queryset = ArticleType.objects.all()
+
+    display_config_class = ArticleTypeDisplayConfig
+
+    search_fields = ("label", "slug")
+    filter_fields = {"label": ["icontains", "exact"], "slug": ["icontains", "exact"]}
+    ordering_fields = ("label",)
+
+    def get_queryset(self):
+        request = self.request
+        user = request.user
+        profile = user.profile
+
+        if user.is_superuser or profile.is_internal:
+            return ArticleType.objects.all()
+        # TODO: What to do with customers?
+
+
+class ArticleTypeRepresentationViewSet(RepresentationViewSet):
+    serializer_class = ArticleTypeRepresentationSerializer
+    queryset = ArticleType.objects.all()
+
+    search_fields = ("label", "slug")
+    filter_fields = {"label": ["icontains", "exact"], "slug": ["icontains", "exact"]}
+    ordering_fields = ("label",)
+
+    def get_queryset(self):
+        request = self.request
+        user = request.user
+        profile = user.profile
+
+        if user.is_superuser or profile.is_internal:
+            return ArticleType.objects.all()
+
+        return ArticleType.objects.none()

wbwriter/viewsets/buttons.py

@@ -0,0 +1,61 @@
+from wbcore import serializers
+from wbcore.contrib.directory.models import Person
+from wbcore.contrib.directory.serializers import (
+    InternalUserProfileRepresentationSerializer,
+)
+from wbcore.contrib.icons import WBIcon
+from wbcore.metadata.configs import buttons as bt
+from wbcore.metadata.configs.buttons.view_config import ButtonViewConfig
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    create_simple_display,
+)
+from wbwriter.models.article import Article
+
+
+class ArticleModelButtonConfig(ButtonViewConfig):
+    def get_custom_list_instance_buttons(self) -> set:
+        return {bt.HyperlinkButton(key="preview", label="Preview PDF", icon=WBIcon.VIEW.icon)}
+
+    def get_custom_instance_buttons(self):
+        class AssignAuthorSerializer(serializers.Serializer):
+            author = serializers.PrimaryKeyRelatedField(queryset=Person.objects.filter_only_internal())
+            _author = InternalUserProfileRepresentationSerializer(source="author")
+
+        custom_instance_buttons = {
+            bt.ActionButton(key="generate_pdf", label="Generate PDF", icon=WBIcon.DOCUMENT.icon),
+            list(self.get_custom_list_instance_buttons())[0],
+            bt.WidgetButton(key="publications", label="Publications", icon=WBIcon.NOTEBOOK.icon),
+            bt.ActionButton(key="reroll_peer", label="Assign new peer reviewer", icon=WBIcon.REFRESH.icon),
+            bt.ActionButton(key="reroll_qa", label="Assign new QA reviewer", icon=WBIcon.REFRESH.icon),
+            bt.ActionButton(
+                key="reroll_peer_and_qa", label="Assign new peer and QA reviewers", icon=WBIcon.REFRESH.icon
+            ),
+            bt.ActionButton(
+                key="assign_new_author",
+                label="Assign another author",
+                icon=WBIcon.PEOPLE.icon,
+                serializer=AssignAuthorSerializer,
+                instance_display=create_simple_display([["author"]]),
+            ),
+        }
+        # Make sure that the "Edit" button only shows up on Status "draft" and
+        # only if the article has no author assigned, and is of Type "DDQ".
+        if self.view.kwargs.get("pk", None):
+            instance = self.view.get_object()
+            if (
+                instance.status == Article.Status.DRAFT
+                and instance.type
+                and instance.type.slug == "ddq"
+                and not instance.author
+            ):
+                custom_instance_buttons.add(bt.ActionButton(key="edit", label="Edit", icon=WBIcon.EDIT.icon))
+
+        return custom_instance_buttons
+
+
+class PublicationButtonConfig(ButtonViewConfig):
+    def get_custom_instance_buttons(self):
+        return {bt.HyperlinkButton(key="pdf_file", label="PDF", icon=WBIcon.NOTEBOOK.icon)}
+
+    def get_custom_list_instance_buttons(self):
+        return self.get_custom_instance_buttons()

wbwriter/viewsets/display/__init__.py

@@ -0,0 +1,6 @@
+from .article import ArticleDisplayConfig, DependantArticleDisplayConfig
+from .article_type import ArticleTypeDisplayConfig
+from .in_editor_template import InEditorTemplateDisplayConfig
+from .meta_information import MetaInformationDisplayConfig
+from .meta_information_instance import MetaInformationInstanceDisplayConfig
+from .publication import PublicationDisplayConfig, PublicationParserDisplayConfig