wbwriter 2.2.1__py2.py3-none-any.whl

wbwriter/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

wbwriter/admin.py

@@ -0,0 +1,142 @@
+from django.contrib import admin
+from reversion_compare.admin import CompareVersionAdmin
+from wbwriter.models import (
+    Article,
+    ArticleType,
+    Block,
+    BlockParameter,
+    DependantArticle,
+    InEditorTemplate,
+    MetaInformation,
+    MetaInformationInstance,
+    Publication,
+    PublicationParser,
+    Style,
+    Template,
+)
+
+
+class UsesArticleInline(admin.TabularInline):
+    verbose_name = "Uses Article"
+    fields = ["dependant_article"]
+    model = DependantArticle
+    fk_name = "article"
+    extra = 0
+
+
+class UsedArticleInline(admin.TabularInline):
+    verbose_name = "Used in Article"
+    fields = ["article"]
+    model = DependantArticle
+    fk_name = "dependant_article"
+    extra = 0
+
+
+@admin.register(MetaInformation)
+class MetaInformationModelAdmin(admin.ModelAdmin):
+    pass
+
+
+@admin.register(MetaInformationInstance)
+class MetaInformationInstanceModelAdmin(admin.ModelAdmin):
+    pass
+
+
+class MetaInformationInstanceInline(admin.TabularInline):
+    model = MetaInformationInstance
+    extra = 0
+    list_display = ("meta_information", "boolean_value")
+
+
+@admin.register(ArticleType)
+class ArticleTypeModelAdmin(admin.ModelAdmin):
+    list_display = ("id", "label", "slug")
+
+    ordering = ["slug"]
+    search_fields = ["id", "label", "slug"]
+
+    autocomplete_fields = [
+        "peer_reviewers",
+        "qa_reviewers",
+    ]
+
+    # prepopulated_fields = {"slug": ("label",)}
+
+
+@admin.register(Article)
+class ArticleModelAdmin(CompareVersionAdmin, admin.ModelAdmin):
+    list_display = ("id", "title", "slug")
+
+    autocomplete_fields = [
+        "author",
+        "reviewer",
+        "peer_reviewer",
+        "qa_reviewer",
+    ]
+
+    inlines = [UsesArticleInline, UsedArticleInline, MetaInformationInstanceInline]
+
+    def reversion_register(self, model, **options):
+        options = {
+            # Foreign keys that will be observed.
+            # "follow": ("author", "reviewer", "peer_reviewer", "qa_reviewer"),
+            # Fields to ignore when creating versions
+            "exclude": ("created", "modified", "published"),
+            "ignore_duplicates": True,
+        }
+        super().reversion_register(model, **options)
+
+
+@admin.register(Style)
+class StyleModelAdmin(admin.ModelAdmin):
+    list_display = ("id", "title")
+
+
+@admin.register(InEditorTemplate)
+class InEditorTemplateModelAdmin(admin.ModelAdmin):
+    list_display = ("uuid", "title", "is_stand_alone_template")
+
+    ordering = ["uuid", "title", "is_stand_alone_template"]
+    search_fields = ["uuid", "title", "description"]
+
+
+@admin.register(Template)
+class TemplateModelAdmin(admin.ModelAdmin):
+    list_display = ("id", "title")
+
+
+class BlockParameterInline(admin.StackedInline):
+    model = BlockParameter
+    extra = 0
+
+
+@admin.register(Block)
+class BlockModelAdmin(admin.ModelAdmin):
+    list_display = ("title",)
+
+    inlines = (BlockParameterInline,)
+
+
+def rerender_publication(modeladmin, request, queryset):
+    for pub in queryset:
+        Publication.create_or_update_from_parser_and_object(pub.parser, pub.content_object)
+
+
+@admin.register(Publication)
+class PublicationModelAdmin(CompareVersionAdmin, admin.ModelAdmin):
+    list_display = ("id", "title", "modified", "created")
+    list_filter = ("created", "modified")
+
+    ordering = ["title", "author", "created", "modified"]
+    search_fields = ["title", "author__computed_str"]
+
+    actions = [rerender_publication]
+
+
+@admin.register(PublicationParser)
+class PublicationParserModelAdmin(admin.ModelAdmin):
+    list_display = ("title",)
+    list_filter = ("title",)
+
+    ordering = ["title", "parser_path"]
+    search_fields = ["title", "slug"]

wbwriter/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class WbwriterConfig(AppConfig):
+    name = "wbwriter"

wbwriter/dynamic_preferences_registry.py

@@ -0,0 +1,15 @@
+from dynamic_preferences.preferences import Section
+from dynamic_preferences.registries import global_preferences_registry
+from dynamic_preferences.types import IntegerPreference
+
+general = Section("wbwriter")
+
+
+@global_preferences_registry.register
+class ReviewerRollDaysRangePreference(IntegerPreference):
+    section = general
+    name = "reviewer_roll_days_range"
+    default = 31
+
+    verbose_name = "Reviewer roll days range"
+    help_text = "The number of days that the reviewer-picking-algorithm looks into the past to count the reviews a member of the reviewer groups has been given."

wbwriter/factories/__init__.py

@@ -0,0 +1,13 @@
+from .article import (
+    AbstractPublicationFactory,
+    ArticleFactory,
+    ArticleTypeFactory,
+    BlockFactory,
+    BlockParameterFactory,
+    InEditorTemplateFactory,
+    PublicationFactory,
+    PublicationParserFactory,
+    TemplateFactory,
+    DependantArticleFactory,
+)
+from .meta_information import MetaInformationFactory, MetaInformationInstanceFactory

wbwriter/factories/article.py

@@ -0,0 +1,181 @@
+import random
+
+import factory
+from django.contrib.contenttypes.models import ContentType
+from wbcore.contrib.authentication.factories.users import InternalUserFactory
+from wbcore.contrib.directory.factories.entries import PersonFactory
+from wbwriter.models import (
+    Article,
+    ArticleType,
+    Block,
+    BlockParameter,
+    DependantArticle,
+    InEditorTemplate,
+    Publication,
+    PublicationParser,
+    Template,
+)
+from wbwriter.publication_parser import PublicationParser as PublicationParserClass
+
+
+class Parser(PublicationParserClass):
+    def is_valid(self):
+        return True
+
+
+def content() -> dict:
+    return {
+        "sectionOrder": ["section-1"],  # A list of section keys that will be used in the `sections` dict.
+        "sections": {
+            "section-1": {
+                "id": "section-1",
+                "templateID": None,  # `null` means no InEditorTemplate instance, otherwise the ID of the instance.
+                "configuration": None,  # `null` means no config. This is otherwise a dict: dict[str, Any]
+                "content": {  # This is a dict: dict[str, str]. The actual content depends on the chosen template and user input.
+                    "content": "lorem ipsum dolor...",
+                },
+            }
+        },
+    }
+
+
+class ArticleFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Article
+
+    name = factory.Sequence(lambda n: f"article {n}")
+    title = factory.Sequence(lambda n: f"title {n}")
+    content = content()
+    type = factory.SubFactory("wbwriter.factories.article.ArticleTypeFactory")
+    author = factory.LazyAttribute(lambda o: InternalUserFactory.create().profile)
+    feedback_contact = factory.LazyAttribute(lambda o: InternalUserFactory.create().profile)
+    reviewer = factory.SubFactory("wbcore.contrib.directory.factories.entries.PersonFactory")
+    peer_reviewer = factory.LazyAttribute(lambda o: InternalUserFactory.create().profile)
+    peer_reviewer_approved = True
+    qa_reviewer = factory.LazyAttribute(lambda o: InternalUserFactory.create().profile)
+    template = factory.SubFactory("wbwriter.factories.article.TemplateFactory")
+    status = Article.Status.DRAFT
+
+    @factory.post_generation
+    def tags(self, create, extracted, **kwargs):
+        if not create:
+            return
+
+        if extracted:
+            for tag in extracted:
+                self.tags.add(tag)
+
+
+class DependantArticleFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = DependantArticle
+
+    article = factory.SubFactory(ArticleFactory)
+    dependant_article = factory.SubFactory(ArticleFactory)
+
+
+class ArticleTypeFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = ArticleType
+
+    label = factory.Sequence(lambda n: f"articletype {n}")
+
+    @factory.post_generation
+    def parsers(self, create, extracted, **kwargs):
+        self.parsers.add(PublicationParserFactory.create())
+
+    @factory.post_generation
+    def peer_reviewers(self, create, extracted, **kwargs):
+        if not create:
+            return
+
+        self.peer_reviewers.add(PersonFactory())
+        if extracted:
+            for peer in extracted:
+                self.peer_reviewers.add(peer)
+
+    @factory.post_generation
+    def qa_reviewers(self, create, extracted, **kwargs):
+        if not create:
+            return
+
+        self.qa_reviewers.add(PersonFactory())
+        if extracted:
+            for peer in extracted:
+                self.qa_reviewers.add(peer)
+
+
+class TemplateFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Template
+
+    title = factory.Sequence(lambda n: f"template {n}")
+    template = factory.Faker("paragraph")
+
+    @factory.post_generation
+    def styles(self, create, extracted, **kwargs):
+        if not create:
+            return
+
+        if extracted:
+            for style in extracted:
+                self.styles.add(style)
+
+
+class BlockFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = Block
+
+    title = factory.Sequence(lambda n: f"block {n}")
+    html = factory.Faker("paragraph")
+
+
+class BlockParameterFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = BlockParameter
+
+    block = factory.SubFactory(BlockFactory)
+    title = factory.Sequence(lambda n: f"blockparameter {n}")
+    order = random.randint(1, 9999)
+
+
+class InEditorTemplateFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = InEditorTemplate
+
+    uuid = factory.Sequence(lambda n: f"uid {n}")
+    title = factory.Sequence(lambda n: f"title {n}")
+    description = factory.Faker("paragraph")
+    style = factory.Faker("paragraph")
+    template = factory.Faker("paragraph")
+
+
+class AbstractPublicationFactory(factory.django.DjangoModelFactory):
+    object_id = factory.SelfAttribute("content_object.id")
+    content_type = factory.LazyAttribute(lambda o: ContentType.objects.get_for_model(o.content_object))
+
+    class Meta:
+        exclude = ["content_object"]
+        abstract = True
+
+
+class PublicationParserFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = PublicationParser
+        django_get_or_create = ("parser_path",)
+
+    title = factory.Sequence(lambda n: f"publicationparser {n}")
+    parser_path = "wbwriter.factories.article"
+
+
+class PublicationFactory(AbstractPublicationFactory):
+    class Meta:
+        model = Publication
+
+    title = factory.Sequence(lambda n: f"publication {n}")
+    # author = factory.SubFactory("wbcore.contrib.directory.factories.PersonFactory")
+    content = factory.Faker("paragraph")
+    parser = factory.SubFactory(PublicationParserFactory)
+    content_object = factory.SubFactory(ArticleFactory)
+    description = factory.Faker("paragraph")
+    target = factory.Faker("pystr")

wbwriter/factories/meta_information.py

@@ -0,0 +1,29 @@
+import factory
+from wbwriter.factories.article import ArticleTypeFactory
+from wbwriter.models import MetaInformation, MetaInformationInstance
+
+
+class MetaInformationFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = MetaInformation
+
+    name = factory.Sequence(lambda n: f"metainfo {n}")
+    key = factory.Sequence(lambda n: f"key {n}")
+
+    @factory.post_generation
+    def article_type(self, create, extracted, **kwargs):
+        if not create:
+            return
+
+        self.article_type.add(ArticleTypeFactory())
+        if extracted:
+            for _type in extracted:
+                self.article_type.add(_type)
+
+
+class MetaInformationInstanceFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = MetaInformationInstance
+
+    article = factory.SubFactory("wbwriter.factories.article.ArticleFactory")
+    meta_information = factory.SubFactory(MetaInformationFactory)

wbwriter/filters/__init__.py

@@ -0,0 +1,2 @@
+from .article import ArticleFilter
+from .metainformationinstance import MetaInformationInstanceFilter

wbwriter/filters/article.py

@@ -0,0 +1,47 @@
+import django_filters
+from django.db.models import Q
+from wbcore import filters
+from wbwriter.models import Article, ArticleType
+
+
+class ArticleFilter(filters.FilterSet):
+    show_only_involved_articles = filters.BooleanFilter(
+        default=True,
+        label="Show only my articles",
+        method="get_my_articles",
+    )
+    type = filters.ModelMultipleChoiceFilter(
+        label="Types",
+        queryset=ArticleType.objects.all(),
+        endpoint=ArticleType.get_representation_endpoint(),
+        value_key=ArticleType.get_representation_value_key(),
+        label_key=ArticleType.get_representation_label_key(),
+    )
+
+    def get_my_articles(self, queryset, name, value):
+        if value:
+            request = self.request
+            user = request.user
+            profile = user.profile
+            return queryset.filter(
+                Q(author=profile) | Q(reviewer=profile) | Q(peer_reviewer=profile) | Q(qa_reviewer=profile)
+            )
+        return queryset
+
+    status = filters.MultipleChoiceFilter(
+        label="Status", choices=Article.Status.choices, widget=django_filters.widgets.CSVWidget
+    )
+
+    class Meta:
+        model = Article
+        fields = {
+            "title": ["icontains"],
+            "tags": ["exact"],
+            "author": ["exact"],
+            "reviewer": ["exact"],
+            "peer_reviewer": ["exact"],
+            "qa_reviewer": ["exact"],
+            "created": ["exact", "lt", "lte", "gt", "gte"],
+            "modified": ["exact", "lt", "lte", "gt", "gte"],
+            "is_private": ["exact"],
+        }

wbwriter/filters/metainformationinstance.py

@@ -0,0 +1,24 @@
+from wbcore import filters as wb_filters
+from wbwriter.models.meta_information import MetaInformationInstance
+
+
+class MetaInformationInstanceFilter(wb_filters.FilterSet):
+    article = wb_filters.ModelChoiceFilter(
+        label="Article",
+        queryset=MetaInformationInstance.objects.all(),
+        endpoint=MetaInformationInstance.get_representation_endpoint(),
+        value_key=MetaInformationInstance.get_representation_value_key(),
+        label_key=MetaInformationInstance.get_representation_label_key(),
+        method="filter_for_article",
+    )
+
+    def filter_for_article(self, queryset, name, value):
+        if value:
+            return MetaInformationInstance.objects.filter(article__id=value)
+        return queryset
+
+    class Meta:
+        model = MetaInformationInstance
+        fields = {
+            "article": ["exact"],
+        }