wbwriter 2.2.1__tar.gz

wbwriter-2.2.1/.gitignore

@@ -0,0 +1,181 @@
+~
+
+# Docker volumes
+volumes/
+# Poetry auth file
+auth.toml
+
+media/*
+media/
+mediafiles/
+mediafiles/*
+test/*
+staticfiles/*
+staticfiles/
+#
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+info/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+.dccache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+report.xml
+*/report.xml
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+*.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+*.ipynb
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+.vscode/
+.idea/
+.idea.bkp/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+crm/
+# Cython debug symbols
+cython_debug/
+
+# Gitlab Runner
+builds
+builds/
+
+# Integrator Office 365 : reverse proxy tunnel for outlook365
+ngrok
+*/ngrok
+/modules/**/system/
+
+/modules/wbmailing/files/*
+/modules/wbmailing/mailing/*
+
+/projects/*/requirements.txt
+public
+
+# Ignore archive localization generated folder
+backend/modules/**/archive/*
+**/**/requirements.txt
+CHANGELOG-*

wbwriter-2.2.1/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.3
+Name: wbwriter
+Version: 2.2.1
+Author-email: Christopher Wittlinger <c.wittlinger@stainly.com>
+Requires-Dist: pillow==9.1.*
+Requires-Dist: reportlab==3.*
+Requires-Dist: wbcore
+Requires-Dist: weasyprint==57.*

wbwriter-2.2.1/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "wbwriter"
+description = ""
+authors = [{ name = "Christopher Wittlinger", email = "c.wittlinger@stainly.com"}]
+dynamic = ["version"]
+
+dependencies = [
+  "wbcore",
+  "pillow == 9.1.*",
+  "reportlab == 3.*",
+  "weasyprint == 57.*",
+]
+
+[tool.uv.sources]
+wbcore = { workspace = true }
+
+[tool.uv]
+package = true
+
+[tool.hatch.version]
+path = "../../pyproject.toml"
+
+[tool.hatch.build.targets.sdist]
+include = ["wbwriter/*"]
+
+[tool.hatch.build.targets.wheel]
+packages = ["wbwriter"]
+only-packages = true
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"

wbwriter-2.2.1/wbwriter/__init__.py

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

wbwriter-2.2.1/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-2.2.1/wbwriter/apps.py

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

wbwriter-2.2.1/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-2.2.1/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-2.2.1/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-2.2.1/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-2.2.1/wbwriter/filters/__init__.py

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

wbwriter-2.2.1/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-2.2.1/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"],
+        }