wbwiki 2.2.1__tar.gz

wbwiki-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-*

wbwiki-2.2.1/PKG-INFO

@@ -0,0 +1,5 @@
+Metadata-Version: 2.3
+Name: wbwiki
+Version: 2.2.1
+Author-email: Christopher Wittlinger <c.wittlinger@stainly.com>
+Requires-Dist: wbcore

wbwiki-2.2.1/pyproject.toml

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

wbwiki-2.2.1/wbwiki/__init__.py

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

wbwiki-2.2.1/wbwiki/admin.py

@@ -0,0 +1,18 @@
+from django.contrib import admin
+from wbwiki.models import WikiArticle, WikiArticleRelationship
+
+
+class WikiArticleRelationshipInline(admin.TabularInline):
+    model = WikiArticleRelationship
+    extra = 0
+    raw_id_fields = ["content_type", "wiki"]
+
+
+@admin.register(WikiArticleRelationship)
+class WikiArticleRelationshipAdmin(admin.ModelAdmin):
+    pass
+
+
+@admin.register(WikiArticle)
+class WikiArticleModelAdmin(admin.ModelAdmin):
+    inlines = [WikiArticleRelationshipInline]

wbwiki-2.2.1/wbwiki/apps.py

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

wbwiki-2.2.1/wbwiki/dynamic_preferences_registry.py

@@ -0,0 +1,16 @@
+from django.contrib.contenttypes.models import ContentType
+from django.utils.translation import gettext as _
+from dynamic_preferences.preferences import Section
+from dynamic_preferences.registries import global_preferences_registry
+from dynamic_preferences.types import ModelMultipleChoicePreference
+
+mailing_section = Section("wbwiki")
+
+
+@global_preferences_registry.register
+class AllowedTypeWikiRelationshipPreference(ModelMultipleChoicePreference):
+    section = mailing_section
+    name = "allowed_type_wiki_relationship"
+    queryset = ContentType.objects.all()
+    default = []
+    verbose_name = _("Allowed Type Wiki Relationship")

wbwiki-2.2.1/wbwiki/factories.py

@@ -0,0 +1,30 @@
+import factory
+from django.contrib.contenttypes.models import ContentType
+from wbwiki.models import WikiArticle, WikiArticleRelationship
+
+
+class WikiArticleFactory(factory.django.DjangoModelFactory):
+    class Meta:
+        model = WikiArticle
+
+    title = factory.Faker("pystr")
+    summary = factory.Faker("pystr")
+    content = factory.Faker("pystr")
+
+
+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 WikiArticleRelationshipFactory(AbstractPublicationFactory):
+    class Meta:
+        model = WikiArticleRelationship
+
+    wiki = factory.SubFactory(WikiArticleFactory)
+    content_object = factory.SubFactory("wbcore.contrib.authentication.factories.AuthenticatedPersonFactory")
+    # content_object = factory.SubFactory(WikiArticleFactory)

wbwiki-2.2.1/wbwiki/migrations/0001_initial_squashed_0004_alter_wikiarticle_tags.py

@@ -0,0 +1,33 @@
+# Generated by Django 4.1.8 on 2023-04-19 05:27
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    initial = True
+
+    dependencies = [
+        ("tags", "0001_initial"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="WikiArticle",
+            fields=[
+                ("id", models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("tag_detail_endpoint", models.CharField(blank=True, max_length=255, null=True)),
+                ("tag_representation", models.CharField(blank=True, max_length=512, null=True)),
+                ("title", models.CharField(max_length=1024)),
+                ("content", models.TextField(default="")),
+                ("summary", models.TextField(default="")),
+                (
+                    "tags",
+                    models.ManyToManyField(blank=True, related_name="%(app_label)s_%(class)s_items", to="tags.tag"),
+                ),
+            ],
+            options={
+                "verbose_name": "Wiki Article",
+                "verbose_name_plural": "Wiki Articles",
+            },
+        ),
+    ]

wbwiki-2.2.1/wbwiki/migrations/0005_wikiarticlerelationship_and_more.py

@@ -0,0 +1,52 @@
+# Generated by Django 4.1.9 on 2023-07-11 10:27
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+    dependencies = [
+        ("contenttypes", "0002_remove_content_type_name"),
+        ("wbwiki", "0001_initial_squashed_0004_alter_wikiarticle_tags"),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name="WikiArticleRelationship",
+            fields=[
+                ("id", models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name="ID")),
+                ("computed_str", models.CharField(blank=True, max_length=512, null=True, verbose_name="Name")),
+                ("object_id", models.PositiveIntegerField(verbose_name="Related Item")),
+                (
+                    "content_type",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        to="contenttypes.contenttype",
+                        verbose_name="Item Type",
+                    ),
+                ),
+                (
+                    "wiki",
+                    models.ForeignKey(
+                        on_delete=django.db.models.deletion.CASCADE,
+                        related_name="relationships",
+                        to="wbwiki.wikiarticle",
+                    ),
+                ),
+            ],
+            options={
+                "verbose_name": "Wiki Relationship",
+                "verbose_name_plural": "Wiki Relationships",
+            },
+        ),
+        migrations.AddIndex(
+            model_name="wikiarticlerelationship",
+            index=models.Index(fields=["content_type", "object_id"], name="wbwiki_wiki_content_9ba127_idx"),
+        ),
+        migrations.AddConstraint(
+            model_name="wikiarticlerelationship",
+            constraint=models.UniqueConstraint(
+                fields=("wiki", "content_type", "object_id"), name="unique_wiki_article_relationship"
+            ),
+        ),
+    ]

wbwiki-2.2.1/wbwiki/migrations/0006_auto_20240103_0954.py

@@ -0,0 +1,43 @@
+# Generated by Django 4.2.8 on 2024-01-03 08:54
+
+from contextlib import suppress
+
+from django.apps import apps
+from django.contrib.contenttypes.models import ContentType
+from django.db import migrations
+
+
+def migrate_content_type(apps, schema_editor):
+    WikiArticleRelationship = apps.get_model("wbwiki", "WikiArticleRelationship")
+
+    for model_name in [
+        "Classification",
+        "Instrument",
+        "ClassificationGroup",
+        "Deal",
+        "Exchange",
+        "InstrumentClassificationRelatedInstrument",
+        "InstrumentClassificationThroughModel",
+        "InstrumentFavoriteGroup",
+        "InstrumentList",
+        "InstrumentListThroughModel",
+        "InstrumentRequest",
+        "RelatedInstrumentThroughModel",
+        "InstrumentPrice",
+    ]:
+        with suppress(ContentType.DoesNotExist):
+            old_ct = ContentType.objects.get(app_label="wbportfolio", model=model_name.lower())
+            new_ct = ContentType.objects.get(app_label="wbfdm", model=model_name.lower())
+            WikiArticleRelationship.objects.filter(content_type_id=old_ct.id).update(content_type_id=new_ct.id)
+
+
+class Migration(migrations.Migration):
+    dependencies = (
+        [
+            ("wbwiki", "0005_wikiarticlerelationship_and_more"),
+            ("wbfdm", "0012_instrumentprice_created_instrumentprice_modified"),
+        ]
+        if apps.is_installed("wbfdm")
+        else [("wbwiki", "0005_wikiarticlerelationship_and_more")]
+    )
+    operations = [migrations.RunPython(migrate_content_type)]

wbwiki-2.2.1/wbwiki/models.py

@@ -0,0 +1,76 @@
+import reversion
+from django.contrib.contenttypes.fields import GenericForeignKey
+from django.contrib.contenttypes.models import ContentType
+from django.db import models
+from django.utils.translation import gettext_lazy as _
+from rest_framework.reverse import reverse
+from wbcore.contrib.tags.models import TagModelMixin
+from wbcore.models import WBModel
+from wbcore.utils.models import ComplexToStringMixin
+
+
+@reversion.register()
+class WikiArticle(TagModelMixin, WBModel):
+    title = models.CharField(max_length=1024)
+    summary = models.TextField(default="")
+    content = models.TextField(default="")
+
+    def __str__(self) -> str:
+        return f"{self.title}"
+
+    @classmethod
+    def get_endpoint_basename(cls):
+        return "wbwiki:wikiarticle"
+
+    @classmethod
+    def get_representation_endpoint(cls):
+        return "wbwiki:wikiarticle-list"
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{ title }}"
+
+    def get_tag_detail_endpoint(self):
+        return reverse("wbwiki:wikiarticle-detail", [self.id])
+
+    def get_tag_representation(self):
+        return self.title
+
+    class Meta:
+        verbose_name = "Wiki Article"
+        verbose_name_plural = "Wiki Articles"
+
+
+class WikiArticleRelationship(ComplexToStringMixin, models.Model):
+    wiki = models.ForeignKey(to="wbwiki.WikiArticle", related_name="relationships", on_delete=models.CASCADE)
+    content_type = models.ForeignKey(ContentType, verbose_name=_("Item Type"), on_delete=models.CASCADE)
+    object_id = models.PositiveIntegerField(verbose_name=_("Related Item"))
+    content_object = GenericForeignKey("content_type", "object_id")
+
+    def __str__(self) -> str:
+        return f"{self.wiki} -> {self.content_object}"
+
+    def compute_str(self) -> str:
+        return f"{self.content_object}"
+
+    class Meta:
+        verbose_name = _("Wiki Relationship")
+        verbose_name_plural = _("Wiki Relationships")
+        constraints = [
+            models.UniqueConstraint(
+                name="unique_wiki_article_relationship", fields=["wiki", "content_type", "object_id"]
+            ),
+        ]
+        indexes = [models.Index(fields=["content_type", "object_id"])]
+
+    @classmethod
+    def get_representation_value_key(cls):
+        return "id"
+
+    @classmethod
+    def get_representation_label_key(cls):
+        return "{{wiki}} -> {{computed_str}}"

wbwiki-2.2.1/wbwiki/preferences.py

@@ -0,0 +1,10 @@
+from django.contrib.contenttypes.models import ContentType
+from django.db.utils import ProgrammingError
+from dynamic_preferences.registries import global_preferences_registry
+
+
+def get_allowed_type_wiki_relationship():
+    try:
+        return global_preferences_registry.manager()["wbwiki__allowed_type_wiki_relationship"]
+    except (RuntimeError, ProgrammingError):
+        return ContentType.objects.none()

wbwiki-2.2.1/wbwiki/serializers.py

@@ -0,0 +1,91 @@
+from django.utils.translation import gettext as _
+from rest_framework import serializers as rf_serializers
+from rest_framework.reverse import reverse
+from wbcore import serializers
+from wbcore.content_type.serializers import (
+    ContentTypeRepresentationSerializer,
+    DynamicObjectIDRepresentationSerializer,
+)
+from wbcore.contrib.tags.serializers import TagSerializerMixin
+from wbwiki.models import WikiArticle, WikiArticleRelationship
+
+from .preferences import get_allowed_type_wiki_relationship
+
+
+class WikiArticleRepresentationSerializer(serializers.RepresentationSerializer):
+    class Meta:
+        model = WikiArticle
+        fields = ("id", "title")
+
+
+class WikiArticleModelSerializer(TagSerializerMixin, serializers.ModelSerializer):
+    @serializers.register_only_instance_resource()
+    def relationship_resources(self, instance, request, user, **kwargs):
+        resources = {"relationship": reverse("wiki:wiki-relationship-list", args=[instance.id], request=request)}
+        return resources
+
+    class Meta:
+        model = WikiArticle
+        fields = (
+            "id",
+            "title",
+            "summary",
+            "content",
+            "tags",
+            "_tags",
+            "_additional_resources",
+        )
+
+
+class WikiArticleRelationshipModelSerializer(serializers.ModelSerializer):
+    _wiki = WikiArticleRepresentationSerializer(source="wiki")
+    _content_type = ContentTypeRepresentationSerializer(
+        source="content_type",
+        label_key="{{model_title}}",
+        allowed_types=get_allowed_type_wiki_relationship(),
+    )
+    _object_id = DynamicObjectIDRepresentationSerializer(
+        source="object_id",
+        optional_get_parameters={"content_type": "content_type"},
+        depends_on=[{"field": "content_type", "options": {}}],
+    )
+
+    @serializers.register_only_instance_resource()
+    def additional_resources(self, instance, request, user, view, **kwargs):
+        if instance and hasattr(instance.content_object, "get_endpoint_basename"):
+            return {
+                "object_endpoint": reverse(
+                    f"{instance.content_object.get_endpoint_basename()}-detail",
+                    args=[instance.object_id],
+                    request=request,
+                )
+            }
+
+    class Meta:
+        model = WikiArticleRelationship
+        dependency_map = {"object_id": ["content_type"]}
+        fields = (
+            "id",
+            "content_type",
+            "_content_type",
+            "object_id",
+            "_object_id",
+            "wiki",
+            "_wiki",
+            "computed_str",
+            "_additional_resources",
+        )
+
+    def validate(self, validated_data):
+        content_type = validated_data.get("content_type", self.instance.content_type if self.instance else None)
+        wiki = validated_data.get("wiki", self.instance.wiki if self.instance else None)
+        object_id = validated_data.get("object_id", self.instance.object_id if self.instance else None)
+
+        if content_type and wiki and object_id:
+            qs = WikiArticleRelationship.objects.filter(wiki=wiki, content_type=content_type, object_id=object_id)
+            qs = qs.exclude(id=self.instance.id) if self.instance else qs
+            if qs.exists():
+                raise rf_serializers.ValidationError(
+                    {"object_id": _("Relationship with wiki: {} already exists").format(wiki)}
+                )
+        return super().validate(validated_data)

wbwiki-2.2.1/wbwiki/tests/conftest.py

@@ -0,0 +1,13 @@
+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.geography.tests.signals import app_pre_migration
+from wbwiki.factories import WikiArticleFactory, WikiArticleRelationshipFactory
+
+register(WikiArticleFactory)
+register(WikiArticleRelationshipFactory)
+
+from .signals import *
+
+pre_migrate.connect(app_pre_migration, sender=apps.get_app_config("wbwiki"))

wbwiki-2.2.1/wbwiki/tests/signals.py

@@ -0,0 +1,13 @@
+from django.contrib.contenttypes.models import ContentType
+from django.dispatch import receiver
+from wbcore.test.signals import custom_update_kwargs
+from wbwiki.factories import WikiArticleRelationshipFactory
+from wbwiki.viewsets import ContentObjectWikiArticleModelViewSet
+
+
+@receiver(custom_update_kwargs, sender=ContentObjectWikiArticleModelViewSet)
+def receive_kwargs_content_object(sender, *args, **kwargs):
+    if wiki := kwargs.get("obj_factory"):
+        WikiArticleRelationshipFactory(wiki=wiki, content_object=wiki)
+        return {"content_type": ContentType.objects.get_for_model(wiki).id, "content_id": wiki.id}
+    return {}

wbwiki-2.2.1/wbwiki/tests/test_initial.py

@@ -0,0 +1,2 @@
+def test_initial():
+    assert True

wbwiki-2.2.1/wbwiki/tests/tests.py

@@ -0,0 +1,17 @@
+import pytest
+from wbcore.test import GenerateTest, default_config
+
+config = {}
+for key, value in default_config.items():
+    config[key] = list(
+        filter(
+            lambda x: x.__module__.startswith("wbwiki") and x.__name__ not in ["WikiArticleRelationshipModelViewSet"],
+            value,
+        )
+    )
+
+
+@pytest.mark.django_db
+@GenerateTest(config)
+class TestProject:
+    pass

wbwiki-2.2.1/wbwiki/urls.py

@@ -0,0 +1,26 @@
+from django.urls import include, path
+from wbcore.routers import WBCoreRouter
+from wbwiki import viewsets
+
+router = WBCoreRouter()
+router.register(r"wikiarticle", viewsets.WikiArticleModelViewSet, basename="wikiarticle")
+
+wiki_router = WBCoreRouter()
+wiki_router.register(
+    r"relationship",
+    viewsets.WikiArticleRelationshipModelViewSet,
+    basename="wiki-relationship",
+)
+
+content_object_wiki_router = WBCoreRouter()
+content_object_wiki_router.register(
+    r"contentobjectwiki",
+    viewsets.ContentObjectWikiArticleModelViewSet,
+    basename="contentobjectwiki",
+)
+
+urlpatterns = [
+    path("", include(router.urls)),
+    path("wiki/<wiki_id>/", include(wiki_router.urls)),
+    path("contentobjectwiki/<int:content_type>/<int:content_id>/", include(content_object_wiki_router.urls)),
+]

wbwiki-2.2.1/wbwiki/viewsets/__init__.py

@@ -0,0 +1,5 @@
+from .wikis import (
+    ContentObjectWikiArticleModelViewSet,
+    WikiArticleModelViewSet,
+    WikiArticleRelationshipModelViewSet,
+)

wbwiki-2.2.1/wbwiki/viewsets/buttons/__init__.py

@@ -0,0 +1,4 @@
+from .wikis import (
+    ContentObjectWikiArticleButtonConfig,
+    WikiArticleRelationshipButtonConfig,
+)

wbwiki-2.2.1/wbwiki/viewsets/buttons/wikis.py

@@ -0,0 +1,51 @@
+from django.utils.translation import gettext as _
+from rest_framework.reverse import reverse
+from wbcore import serializers as wb_serializers
+from wbcore.contrib.icons import WBIcon
+from wbcore.enums import RequestType
+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 wbwiki.models import WikiArticle
+from wbwiki.serializers import WikiArticleRepresentationSerializer
+
+
+class WikiArticleRelationshipButtonConfig(ButtonViewConfig):
+    def get_custom_instance_buttons(self):
+        return self.get_custom_list_instance_buttons()
+
+    def get_custom_list_instance_buttons(self):
+        return {
+            bt.WidgetButton(key="object_endpoint", label="{{computed_str}}", icon=WBIcon.CLIPBOARD.icon),
+        }
+
+
+class ContentObjectWikiArticleButtonConfig(ButtonViewConfig):
+    def get_custom_buttons(self):
+        if not self.view.kwargs.get("pk", None):
+
+            class WikiArticleSerializer(wb_serializers.Serializer):
+                wiki = wb_serializers.PrimaryKeyRelatedField(
+                    queryset=WikiArticle.objects.all(),
+                    required=True,
+                    label=_("Wiki"),
+                )
+                _wiki = WikiArticleRepresentationSerializer(source="wiki")
+
+            return {
+                bt.ActionButton(
+                    identifiers=("wbwiki:wikiarticle",),
+                    method=RequestType.PATCH,
+                    endpoint=f"{reverse('wbwiki:wikiarticle-linkwiki', args=[], request=self.request)}?content_type={self.view.kwargs['content_type']}&content_id={self.view.kwargs['content_id']}",
+                    action_label=_("Add Existing Wiki"),
+                    title=_("Add Existing Wiki"),
+                    label=_("Add Existing Wiki"),
+                    icon=WBIcon.LINK.icon,
+                    serializer=WikiArticleSerializer,
+                    description_fields="<p>Link item to Existing Wiki</p><p>Are you sure you want to proceed?</p>",
+                    instance_display=create_simple_display([["wiki"]]),
+                )
+            }
+        return {}

wbwiki-2.2.1/wbwiki/viewsets/display/__init__.py

@@ -0,0 +1 @@
+from .wikis import WikiArticleDisplayConfig, WikiArticleRelationshipDisplayConfig

wbwiki-2.2.1/wbwiki/viewsets/display/wikis.py

@@ -0,0 +1,75 @@
+from django.utils.translation import gettext as _
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.instance_display import (
+    Display,
+    Inline,
+    Layout,
+    Page,
+    Style,
+    create_simple_display,
+)
+from wbcore.metadata.configs.display.instance_display.operators import default
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+
+class WikiArticleRelationshipDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> dp.ListDisplay:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="content_type", label="Item Type"),
+                dp.Field(key="computed_str", label="Related Item"),
+            ]
+        )
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display([["content_type", "object_id"]])
+
+
+class WikiArticleDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> dp.ListDisplay:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="title", label="Title"),
+                dp.Field(key="summary", label="Summary"),
+                dp.Field(key="tags", label="Tags"),
+            ]
+        )
+
+    def _get_custom_instance_display(self) -> Display:
+        return Display(
+            pages=[
+                Page(
+                    title=_("Main Information"),
+                    layouts={
+                        default(): Layout(
+                            grid_template_areas=[["title"], ["summary"], ["tags"], ["content"]],
+                            grid_template_columns=[
+                                "minmax(min-content, 1fr)",
+                            ],
+                        ),
+                    },
+                ),
+                Page(
+                    title=_("Relationship"),
+                    layouts={
+                        default(): Layout(
+                            grid_template_areas=[["relationship_key"]],
+                            inlines=[Inline(key="relationship_key", endpoint="relationship")],
+                            grid_template_columns=[
+                                "minmax(min-content, 1fr)",
+                            ],
+                            grid_auto_rows=Style.MIN_CONTENT,
+                        ),
+                    },
+                ),
+            ]
+        )
+
+    def get_instance_display(self) -> Display:
+        display = (
+            self._get_custom_instance_display()
+            if "pk" in self.view.kwargs
+            else create_simple_display([["title", "summary", "tags", "content"]])
+        )
+
+        return display

wbwiki-2.2.1/wbwiki/viewsets/endpoints/__init__.py

@@ -0,0 +1,4 @@
+from .wikis import (
+    ContentObjectWikiArticleEndpointConfig,
+    WikiArticleRelationshipEndpointConfig,
+)

wbwiki-2.2.1/wbwiki/viewsets/endpoints/wikis.py

@@ -0,0 +1,20 @@
+from rest_framework.reverse import reverse
+from wbcore.metadata.configs.endpoints import EndpointViewConfig
+
+
+class WikiArticleRelationshipEndpointConfig(EndpointViewConfig):
+    def get_endpoint(self, **kwargs):
+        return reverse(
+            "wiki:wiki-relationship-list",
+            args=[self.view.kwargs["wiki_id"]],
+            request=self.request,
+        )
+
+
+class ContentObjectWikiArticleEndpointConfig(EndpointViewConfig):
+    def get_endpoint(self, **kwargs):
+        return reverse(
+            "wiki:contentobjectwiki-list",
+            args=[self.view.kwargs["content_type"], self.view.kwargs["content_id"]],
+            request=self.request,
+        )

wbwiki-2.2.1/wbwiki/viewsets/menu/__init__.py

@@ -0,0 +1 @@
+from .wikis import WIKI_MENU, WIKI_MENU_ITEM

wbwiki-2.2.1/wbwiki/viewsets/menu/wikis.py

@@ -0,0 +1,21 @@
+from wbcore.menus import ItemPermission, Menu, MenuItem
+
+WIKI_MENU_ITEM = MenuItem(
+    label="WIKI",
+    endpoint="wbwiki:wikiarticle-list",
+    add=MenuItem(
+        label="Create a wiki article",
+        endpoint="wbwiki:wikiarticle-list",
+        permission=ItemPermission(
+            permissions=["wbwiki.create_wikiarticle"],
+        ),
+    ),
+    permission=ItemPermission(
+        permissions=["wbwiki.view_wikiarticle"],
+    ),
+)
+
+WIKI_MENU = Menu(
+    label="WIKI",
+    items=[WIKI_MENU_ITEM],
+)

wbwiki-2.2.1/wbwiki/viewsets/wikis.py

@@ -0,0 +1,107 @@
+from django.utils.translation import gettext_lazy as _
+from rest_framework import status
+from rest_framework.decorators import action
+from rest_framework.response import Response
+from reversion.views import RevisionMixin
+from wbcore import viewsets
+from wbcore.contrib.authentication.authentication import JWTCookieAuthentication
+from wbwiki.models import WikiArticle, WikiArticleRelationship
+from wbwiki.serializers import (
+    WikiArticleModelSerializer,
+    WikiArticleRelationshipModelSerializer,
+)
+
+from .buttons import (
+    ContentObjectWikiArticleButtonConfig,
+    WikiArticleRelationshipButtonConfig,
+)
+from .display import WikiArticleDisplayConfig, WikiArticleRelationshipDisplayConfig
+from .endpoints import (
+    ContentObjectWikiArticleEndpointConfig,
+    WikiArticleRelationshipEndpointConfig,
+)
+
+
+class WikiArticleModelViewSet(RevisionMixin, viewsets.ModelViewSet):
+    queryset = WikiArticle.objects.all()
+    serializer_class = WikiArticleModelSerializer
+    # search_fields = ("title", "summary", "content", "tags__title")
+    filterset_fields = {
+        "title": ["icontains"],
+        "summary": ["icontains"],
+        "tags": ["exact"],
+    }
+
+    display_config_class = WikiArticleDisplayConfig
+
+    @action(detail=False, methods=["PATCH"], authentication_classes=[JWTCookieAuthentication])
+    def linkwiki(self, request, pk=None):
+        content_type_id = request.GET.get("content_type")
+        object_id = request.GET.get("content_id")
+        wiki_id = request.POST.get("wiki")
+
+        if content_type_id and object_id:
+            if wiki_id:
+                wiki_relationship, created = WikiArticleRelationship.objects.get_or_create(
+                    wiki_id=wiki_id,
+                    content_type_id=content_type_id,
+                    object_id=object_id,
+                )
+                if created:
+                    message = _("Relationship Item has been added to wiki")
+                    _status = status.HTTP_200_OK
+                else:
+                    message = _("Wiki has already been linked to this Item")
+                    _status = status.HTTP_400_BAD_REQUEST
+            else:
+                message = _("Wiki is mandatory")
+                _status = status.HTTP_400_BAD_REQUEST
+        else:
+            message = _("Relationship Item could not be linked to wiki")
+            _status = status.HTTP_400_BAD_REQUEST
+
+        return Response(
+            {"__notification": {"title": message}},
+            status=_status,
+        )
+
+
+class ContentObjectWikiArticleModelViewSet(WikiArticleModelViewSet):
+    endpoint_config_class = ContentObjectWikiArticleEndpointConfig
+    button_config_class = ContentObjectWikiArticleButtonConfig
+
+    def get_queryset(self):
+        if (content_type_id := self.kwargs.get("content_type")) and (object_id := self.kwargs.get("content_id")):
+            return (
+                super()
+                .get_queryset()
+                .filter(relationships__content_type=content_type_id, relationships__object_id=object_id)
+            )
+        return WikiArticle.objects.none()
+
+    def create(self, request, *args, **kwargs):
+        response = super().create(request, *args, **kwargs)
+
+        if (content_type_id := self.kwargs.get("content_type")) and (object_id := self.kwargs.get("content_id")):
+            WikiArticleRelationship.objects.get_or_create(
+                wiki_id=response.data["instance"]["id"],
+                content_type_id=content_type_id,
+                object_id=object_id,
+            )
+
+        return response
+
+
+class WikiArticleRelationshipModelViewSet(viewsets.ModelViewSet):
+    serializer_class = WikiArticleRelationshipModelSerializer
+    display_config_class = WikiArticleRelationshipDisplayConfig
+    endpoint_config_class = WikiArticleRelationshipEndpointConfig
+    button_config_class = WikiArticleRelationshipButtonConfig
+    queryset = WikiArticleRelationship.objects.all()
+    search_fields = ("computed_str", "content_type__model")
+    filterset_fields = {
+        "computed_str": ["icontains", "exact"],
+    }
+
+    def get_queryset(self):
+        return super().get_queryset().filter(wiki__id=self.kwargs["wiki_id"])