wbreport 2.2.1__py2.py3-none-any.whl

wbreport/tests/test_models.py

@@ -0,0 +1,253 @@
+import datetime as dt
+
+import pytest
+from django.test import override_settings
+from faker import Faker
+from wbmailing.models import MassMail
+from wbreport.models import ReportVersion
+
+fake = Faker()
+
+
+@pytest.mark.django_db
+class TestReportAssetModel:
+    def test_init(self, report_asset):
+        assert report_asset.id is not None
+
+    def test_str(self, report_asset):
+        assert str(report_asset) == report_asset.key
+
+
+@pytest.mark.django_db
+class TestReportCategoryModel:
+    def test_init(self, report_category):
+        assert report_category.id is not None
+
+    def test_str(self, report_category):
+        assert str(report_category) == report_category.title
+
+
+@pytest.mark.django_db
+class TestReportClassModel:
+    def test_init(self, report_class):
+        assert report_class.id is not None
+
+    def test_get_context(self, report_class, report_version_factory):
+        report_version = report_version_factory.create(parameters={"a": "b"})
+        context = report_class.get_context(report_version)
+        assert context == {"title": report_version.title}
+
+    @pytest.mark.parametrize("report_title", [fake.word()])
+    def test_get_version_title(self, report_class, report_title):
+        title = report_class.get_version_title(report_title, dict(iteration=0))
+        assert title == f"{report_title}-{0}"
+        assert title
+
+    def test_get_version_date(self, report_class):
+        assert report_class.get_version_date({"a": "b"}) is None
+
+    @pytest.mark.parametrize("title", [fake.word()])
+    def test_generate_file(self, title, report_class):
+        output = report_class.generate_file({"title": title})
+        assert output.getvalue().decode("utf_8") == title
+
+    @pytest.mark.parametrize("title", [fake.word()])
+    def test_generate_html(self, title, report_class):
+        output = report_class.generate_html({"title": title})
+        assert output == f"<p>{title}</p>"
+
+
+@pytest.mark.django_db
+class TestReportModel:
+    @staticmethod
+    def convert_date(date: dt.date) -> str:
+        return dt.datetime.strftime(date, "%Y-%m-%d")
+
+    def test_init(self, report_factory):
+        report = report_factory.create()
+        assert report.id is not None
+
+    def test_str(self, report_factory):
+        parent_parent_report = report_factory.create(parent_report=None)
+        parent_report = report_factory.create(parent_report=parent_parent_report)
+        report = report_factory.create(parent_report=parent_report)
+        assert parent_parent_report.__str__() == parent_parent_report.title
+        assert parent_report.__str__() == parent_report.title + f" [{parent_parent_report.title}]"
+        assert report.__str__() == report.title + f" [{parent_report.title} - {parent_parent_report.title}]"
+
+    def test_version(self, report_factory, report_version_factory):
+        report = report_factory.create()
+        report2 = report_factory.create()
+        version_date = fake.date_object()
+        version = report_version_factory.create(
+            report=report, parameters={"a": "b"}, is_primary=True, version_date=version_date
+        )
+        version2 = report_version_factory.create(
+            report=report, parameters={"a": "b"}, is_primary=False, version_date=version_date + dt.timedelta(days=1)
+        )
+        assert report.primary_version == version
+        assert report.earliest_version == version
+        assert report.last_version == version2
+        assert report2.earliest_version is None
+        assert report2.primary_version is None
+        assert report2.last_version is None
+
+    def test_get_gradient(self, report_factory):
+        report = report_factory.create()
+        palette = report.get_gradient()
+        assert len(list(palette)) == len(report.color_palette.colors)
+
+    def test_get_context(self, report_factory):
+        report = report_factory.create()
+        base_context = report.get_context()
+        assert list(base_context.keys()) == [
+            "report_title",
+            "slugify_report_title",
+            "report_base_color",
+            "colors_palette",
+            "report_logo_file_id",
+        ]
+
+    def test_set_primary_version(self, report_factory, report_version_factory):
+        report = report_factory.create()
+        report_version_factory.create(report=report, is_primary=True, parameters={"iteration": 0})
+        assert ReportVersion.objects.filter(is_primary=True).count() == 1
+        report_version_factory.create(report=report, is_primary=False, parameters={"iteration": 1})
+        assert ReportVersion.objects.filter(is_primary=True, parameters={"iteration": 1}).count() == 0
+        report.set_primary_versions({"iteration": 1})
+        assert ReportVersion.objects.filter(is_primary=True, parameters={"iteration": 1}).count() == 1
+
+    def test_get_or_create_version(self, report_factory):
+        report = report_factory.create()
+        assert ReportVersion.objects.count() == 0
+        report.get_or_create_version({"iteration": 0}, update_context=True)
+        assert ReportVersion.objects.count() == 1
+
+    def test_get_next_parameters(self, report_factory, report_version_factory):
+        report = report_factory.create()
+
+        # No Report Version, no explicit parameters, therefore no next parameters.
+        next_parameters = report.get_next_parameters()
+        assert next_parameters is None
+
+        # Explicit parameters.
+        next_parameters = report.get_next_parameters(next_parameters={"a": "b"})
+        assert next_parameters is not None
+
+        end_date = fake.date_object()
+        report_version_factory.create(report=report, parameters={"iteration": 0, "end": self.convert_date(end_date)})
+        next_parameters = report.get_next_parameters()
+        assert next_parameters == {"iteration": 1, "end": self.convert_date(end_date + dt.timedelta(days=1))}
+
+    def test_generate_next_reports(self, report_factory, report_version_factory):
+        end_date = fake.date_object()
+        # The parent report.
+        parent_report = report_factory.create(parent_report=None, is_active=True)
+
+        # Report 1 (parent_report child) has one version.
+        report1 = report_factory.create(parent_report=parent_report, is_active=True)
+        report_version_factory.create(report=report1, parameters={"iteration": 0, "end": self.convert_date(end_date)})
+
+        # Report 2 (parent_report child) has one version but the report is not active.
+        report2 = report_factory.create(parent_report=parent_report, is_active=False)
+        report_version_factory.create(report=report2, parameters={"iteration": 0, "end": self.convert_date(end_date)})
+
+        # A third report (parent_report child), but no version.
+        report_factory.create(parent_report=parent_report, is_active=True)
+
+        parent_report.generate_next_reports(next_parameters=None)
+        assert ReportVersion.objects.count() == 2 + 1  # report1 make a new version.
+
+        # Same function but with "next_parameters" not None: it will make first new version for no existing versions
+        # of report (Parent report + report3) and generate next report version for already existing version report.
+        parent_report.generate_next_reports(
+            next_parameters={"iteration": 2, "end": self.convert_date(end_date + dt.timedelta(days=2))}
+        )
+        assert ReportVersion.objects.count() == 3 + 3
+
+        # Same function but for only leaves node.
+        parent_report.generate_next_reports(max_depth_only=True)
+        assert ReportVersion.objects.count() == 6 + 2
+
+    def test_bulk_create(self, report_factory):
+        parent_report = report_factory.create(is_active=True)
+        report_factory.create_batch(5, parent_report=parent_report, is_active=True)
+        end_date = fake.date_object()
+        parent_report.bulk_create_child_reports(
+            start_parameters={"iteration": 0, "end": self.convert_date(end_date)},
+            end_parameters={"iteration": 2, "end": self.convert_date(end_date + dt.timedelta(days=2))},
+        )
+        assert ReportVersion.objects.count() == 5 * 3 + 3
+
+    def test_set_primary_report_version(self, report_factory):
+        parent_report = report_factory.create(parent_report=None, is_active=True)
+        report_factory.create_batch(5, parent_report=parent_report, is_active=True)
+        end_date = fake.date_object()
+        parent_report.generate_next_reports({"iteration": 0, "end": self.convert_date(end_date)})
+        parent_report.generate_next_reports()
+        parent_report.set_primary_report_version(
+            {"iteration": 1, "end": self.convert_date(end_date + dt.timedelta(days=1))}
+        )
+        parent_report.set_primary_report_version()  # will set primary to the same parameters.
+        assert (
+            ReportVersion.objects.filter(
+                parameters={"iteration": 1, "end": self.convert_date(end_date + dt.timedelta(days=1))}, is_primary=True
+            ).count()
+            == 6
+        )
+
+
+@pytest.mark.django_db
+class TestReportVersionModel:
+    def test_init(self, report_version_factory):
+        report_version = report_version_factory.create(parameters={"a": "b"})
+        assert report_version.id is not None
+
+    def test_generate_file(self, report_version_factory, report_factory):
+        report_version = report_version_factory.create(parameters={"a": "b"})
+        report_version.update_context()
+        output = report_version.generate_file()
+        assert output.getvalue().decode("utf_8") == report_version.title
+
+    def test_generate_html(self, report_version_factory):
+        report_version = report_version_factory.create(parameters={"a": "b"})
+        report_version.update_context()
+        output = report_version.generate_html()
+        assert output == f"<p>{report_version.title}</p>"
+
+    @override_settings(EMAIL_BACKEND="anymail.backends.test.EmailBackend")
+    def test_send_mail(self, report_version_factory, mail_template):
+        report_version = report_version_factory.create(parameters={"a": "b"})
+        report_version.send_mail(mail_template)
+        assert MassMail.objects.count() == 1
+
+    def test_get_context(self, report_version_factory):
+        report_version = report_version_factory.create(parameters={"a": "b"})
+        context = report_version.get_context()
+        assert set(context.keys()) == {
+            "uuid",
+            "download_url",
+            "version_title",
+            "slugify_version_title",
+            "title",
+            "report_title",
+            "slugify_report_title",
+            "comment",
+            "report_base_color",
+            "colors_palette",
+            "report_logo_file_id",
+        }
+
+    def test_update_context(self, report_version_factory):
+        report_version = report_version_factory.create(parameters={"a": "b"})
+        assert report_version.context == dict()
+        report_version.update_context()
+        assert report_version.context["title"] == report_version.title
+
+    def test_update_context_with_error(self, report_version_factory):
+        report_version = report_version_factory.create(parameters=dict())
+        assert report_version.context == dict()
+        assert report_version.disabled is False
+        report_version.update_context()
+        assert report_version.context == dict()
+        assert report_version.disabled is True

wbreport/tests/test_tasks.py

@@ -0,0 +1,17 @@
+import pytest
+from django.core import mail
+from django.test import override_settings
+from wbcore.contrib.authentication.factories import SuperUserFactory
+from wbreport.tasks import generate_and_send_current_report_file
+
+
+@pytest.mark.django_db
+class TestTasks:
+    @override_settings(EMAIL_BACKEND="anymail.backends.test.EmailBackend")
+    def test_generate_and_send_current_report_file(self, report_factory):
+        parent_report = report_factory.create(is_active=True)
+        report_factory.create_batch(5, is_active=True, parent_report=parent_report)
+        parent_report.generate_next_reports({"iteration": 0})
+        user = SuperUserFactory()
+        generate_and_send_current_report_file(user.id, parent_report.id)
+        assert len(mail.outbox) == 1

wbreport/tests/tests.py

@@ -0,0 +1,12 @@
+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("wbreport"), value))
+
+
+@pytest.mark.django_db
+@GenerateTest(config)
+class TestProject:
+    pass

wbreport/urls.py

@@ -0,0 +1,29 @@
+from django.urls import include, path
+from wbcore.routers import WBCoreRouter
+from wbreport.viewsets import viewsets
+
+router = WBCoreRouter()
+
+router.register(
+    r"reportcategoryrepresentation",
+    viewsets.ReportCategoryRepresentationViewSet,
+    basename="reportcategoryrepresentation",
+)
+router.register(
+    r"reportversionerepresentation",
+    viewsets.ReportVersionRepresentationViewSet,
+    basename="reportversionrepresentation",
+)
+router.register(
+    r"reportclassrepresentation", viewsets.ReportClassRepresentationViewSet, basename="reportclassrepresentation"
+)
+router.register(r"reportrepresentation", viewsets.ReportRepresentationViewSet, basename="reportrepresentation")
+router.register(r"report", viewsets.ReportModelViewSet, basename="report")
+router.register(r"reportversion", viewsets.ReportVersionModelViewSet, basename="reportversion")
+router.register(r"reportcategory", viewsets.ReportCategoryModelViewSet, basename="reportcategory")
+
+report_router = WBCoreRouter()
+report_router.register(r"version", viewsets.ReportVersionReportModelViewSet, basename="report-version")
+
+
+urlpatterns = [path("", include(router.urls)), path("report/<int:report_id>/", include(report_router.urls))]

wbreport/urls_public.py

@@ -0,0 +1,10 @@
+from django.urls import path
+from wbreport.viewsets import viewsets
+
+urlpatterns = [
+    path("<str:namespace>/", viewsets.report, name="report"),
+    path("version/<str:lookup>/", viewsets.report_version, name="report_version"),
+    path(
+        "download_version_file/<str:uuid>/", viewsets.download_report_version_file, name="report_download_version_file"
+    ),
+]

wbreport/viewsets/__init__.py

@@ -0,0 +1,10 @@
+from .viewsets import (
+    ReportCategoryRepresentationViewSet,
+    ReportClassRepresentationViewSet,
+    ReportModelViewSet,
+    ReportRepresentationViewSet,
+    ReportVersionModelViewSet,
+    ReportVersionRepresentationViewSet,
+    download_report_version_file,
+    report_version,
+)

wbreport/viewsets/configs/__init__.py

@@ -0,0 +1,18 @@
+from .buttons import ReportButtonConfig, ReportVersionButtonConfig
+from .displays import (
+    ReportCategoryDisplayConfig,
+    ReportDisplayConfig,
+    ReportVersionDisplayConfig,
+    ReportVersionReportDisplayConfig,
+)
+from .endpoints import (
+    ReportEndpointConfig,
+    ReportVersionEndpointConfig,
+    ReportVersionReportEndpointConfig,
+)
+from .titles import (
+    ReportTitleConfig,
+    ReportVersionReportTitleConfig,
+    ReportVersionTitleConfig,
+)
+from .menus import REPORT_MENUITEM

wbreport/viewsets/configs/buttons.py

@@ -0,0 +1,193 @@
+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 wbreport.models import Report
+
+
+class CommentSerializer(wb_serializers.Serializer):
+    comment = wb_serializers.TextField(default="")
+
+
+class ReportButtonConfig(ButtonViewConfig):
+    def get_custom_list_instance_buttons(self):
+        return {
+            bt.HyperlinkButton(
+                key="last_version",
+                label="Last Version (unreleased)",
+                icon=WBIcon.DOCUMENT_IN_PROGRESS.icon,
+            ),
+            bt.HyperlinkButton(
+                key="primary_version",
+                label="Primary Version",
+                icon=WBIcon.DOCUMENT_PRIVATE.icon,
+            ),
+        }
+
+    def get_custom_instance_buttons(self):
+        default_parameters = earliest_parent_parameters = latest_parent_paremeters = dict()
+        if report_id := self.view.kwargs.get("pk", None):
+            report = Report.objects.get(id=report_id)
+            if version := report.last_version:
+                default_parameters = version.parameters
+            if default_parameters:
+                report.report_class.get_next_parameters(default_parameters)
+            if parent_report := report.parent_report:
+                if version := parent_report.earliest_version:
+                    earliest_parent_parameters = version.parameters
+                if version := parent_report.last_version:
+                    latest_parent_paremeters = version.parameters
+
+        class ParametersSerializer(wb_serializers.Serializer):
+            parameters = wb_serializers.JSONTableField(default=default_parameters, label="Version Parameters")
+
+        class StartEndParametersSerializer(wb_serializers.Serializer):
+            start_parameters = wb_serializers.JSONTableField(
+                default=earliest_parent_parameters, label="Start Parameters"
+            )
+            end_parameters = wb_serializers.JSONTableField(default=latest_parent_paremeters, label="End Parameters")
+            comment = wb_serializers.TextField(default="")
+
+        class GenerateNextReportSerializer(CommentSerializer):
+            max_depth_only = wb_serializers.BooleanField(default=False)
+            start_date = wb_serializers.DateField()
+            end_date = wb_serializers.DateField()
+
+        return self.get_custom_list_instance_buttons() | {
+            bt.DropDownButton(
+                label="Utility",
+                icon=WBIcon.UNFOLD.icon,
+                buttons=(
+                    bt.ActionButton(
+                        method=RequestType.PATCH,
+                        identifiers=("wbreport:report",),
+                        key="generate_next_reports",
+                        label="Generate Next Report",
+                        icon=WBIcon.GENERATE_NEXT.icon,
+                        description_fields="""
+                        <p> Generate reports based on current report parameters to next iteration?</p>
+                        <p> Note: This action takes a minute</p>
+                        """,
+                        serializer=GenerateNextReportSerializer,
+                        action_label="Generate Next Report",
+                        title="Generate Report to Next Iteration",
+                        instance_display=create_simple_display([["start_date"], ["end_date"], ["max_depth_only"]]),
+                    ),
+                    bt.ActionButton(
+                        method=RequestType.PATCH,
+                        identifiers=("wbreport:report",),
+                        key="update_versions_context",
+                        label="Regenerate context",
+                        icon=WBIcon.REGENERATE.icon,
+                        serializer=ParametersSerializer,
+                        description_fields="""
+                        <p> Do you want to regenerate this report's versions?</p>
+                        <p> If parameters is unset, it will recompute all report's versions</p>
+                        <p> Note: This action takes few minute?</p>
+                        """,
+                        action_label="Regenerate versions context",
+                        title="Regenerate versions context",
+                        instance_display=create_simple_display([["all_versions"], ["parameters"]]),
+                    ),
+                    bt.ActionButton(
+                        method=RequestType.PATCH,
+                        identifiers=("wbreport:report",),
+                        key="bundle_versions",
+                        label="Bundle Versions",
+                        icon=WBIcon.FOLDERS_OPEN.icon,
+                        description_fields="""
+                        <p>Generate a reports bundle for the specified parameters.
+                        If left empty, will use the latest parameters state.</p>
+                        <p> Note: This action takes around 10 minutes</p>
+                        """,
+                        serializer=ParametersSerializer,
+                        action_label="Bundle Versions",
+                        title="Bundle Versions",
+                        instance_display=create_simple_display([["parameters"]]),
+                    ),
+                    bt.ActionButton(
+                        method=RequestType.PATCH,
+                        identifiers=("wbreport:report",),
+                        key="bulk_create_reports",
+                        label="Bulk Reports Creations",
+                        icon=WBIcon.FOLDERS_ADD.icon,
+                        description_fields="""
+                        <p>Create all the report version between the two specified parameters set.
+                        <p> Note: This action takes around 10 minutes</p>
+                        """,
+                        serializer=StartEndParametersSerializer,
+                        action_label="Bulk Reports Creations",
+                        title="Bulk Reports Creations",
+                        instance_display=create_simple_display([["start_parameters"], ["end_parameters"]]),
+                    ),
+                    bt.ActionButton(
+                        method=RequestType.PATCH,
+                        identifiers=("wbreport:report",),
+                        key="switch_primary_versions",
+                        label="Switch Primary Versions",
+                        description_fields="""
+                        <p>Switch the Primary Versions of all the child reports to the given parameters. </p>
+                        <p> The primary version is the one display by default</p>
+                        """,
+                        icon=WBIcon.SYNCHRONIZE.icon,
+                        serializer=ParametersSerializer,
+                        action_label="Switch Primary Versions",
+                        title="Switch Primary Versions",
+                        instance_display=create_simple_display([["parameters"]]),
+                    ),
+                ),
+            )
+        }
+
+
+class ReportVersionButtonConfig(ButtonViewConfig):
+    def get_custom_list_instance_buttons(self):
+        return {
+            bt.HyperlinkButton(
+                key="html",
+                label="Report (HTML)",
+                icon=WBIcon.LINK.icon,
+            ),
+            bt.HyperlinkButton(
+                key="file",
+                label="Report (File)",
+                icon=WBIcon.SAVE.icon,
+            ),
+            bt.HyperlinkButton(
+                key="public_html",
+                label="Public Report",
+                icon=WBIcon.SAVE.icon,
+            ),
+            bt.ActionButton(
+                method=RequestType.GET,
+                identifiers=("wbreport:reportversion",),
+                key="update_context",
+                label="Update Context",
+                description_fields="""
+                <p>Update and actualize context</p>
+                """,
+                serializer=CommentSerializer,
+                icon=WBIcon.REGENERATE.icon,
+                action_label="Update Context",
+                title="Update Context",
+            ),
+            bt.ActionButton(
+                method=RequestType.GET,
+                identifiers=("wbreport:reportversion",),
+                key="send_email",
+                label="Send to Mailing List",
+                description_fields="""
+                <p>Send this version as email to the specified report mailing list</p>
+                """,
+                icon=WBIcon.MAIL.icon,
+                action_label="Send Email",
+                title="Send Email",
+            ),
+        }
+
+    def get_custom_instance_buttons(self):
+        return self.get_custom_list_instance_buttons()

wbreport/viewsets/configs/displays.py

@@ -0,0 +1,116 @@
+from typing import Optional
+
+from rest_framework.reverse import reverse
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.instance_display import Display
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    create_simple_display,
+    create_simple_section,
+)
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+
+class ReportCategoryDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=(
+                dp.Field(key="title", label="Title"),
+                dp.Field(key="order", label="Order"),
+            )
+        )
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display([["title"], ["order"]])
+
+
+class ReportDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="title", label="Title"),
+                dp.Field(key="namespace", label="Namespace"),
+                dp.Field(key="parent_report", label="Parent Report"),
+                dp.Field(key="category", label="Category"),
+                dp.Field(key="is_active", label="Active"),
+                dp.Field(key="permission_type", label="Permission Type"),
+                dp.Field(key="file_disabled", label="PDF Disabled"),
+                dp.Field(key="base_color", label="Color"),
+                dp.Field(key="mailing_list", label="Mailing List"),
+            ],
+            tree=True,
+            # tree_group_lookup="id_repr",
+            tree_group_pinned="left",
+            tree_group_field="title",
+            tree_group_label="Title",
+            tree_group_level_options=[
+                dp.TreeGroupLevelOption(
+                    filter_key="parent_report",
+                    filter_depth=1,
+                    list_endpoint=reverse(
+                        "wbreport:report-list",
+                        args=[],
+                        request=self.request,
+                    ),
+                )
+            ],
+        )
+
+    def get_instance_display(self) -> Display:
+        version_section = create_simple_section("version_section", "Versions", [["content_type"], ["object_id"]])
+        version_table_section = create_simple_section("version_table_section", "Versions", [["versions"]], "versions")
+        child_report_section = create_simple_section("child_report_section", "Child Reports", [["reports"]], "reports")
+        return create_simple_display(
+            [
+                ["title", "namespace", "."],
+                ["base_color", "category", "file_content_type"],
+                ["is_active", "permission_type", "file_disabled"],
+                ["mailing_list", "report_class", "."],
+                ["version_section", "version_section", "version_section"],
+                ["version_table_section", "version_table_section", "version_table_section"],
+                ["child_report_section", "child_report_section", "child_report_section"],
+            ],
+            [child_report_section, version_table_section, version_section],
+        )
+
+
+class ReportVersionDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=(
+                dp.Field(key="uuid", label="UUID"),
+                dp.Field(key="lookup", label="Lookup"),
+                dp.Field(key="title", label="Title"),
+                dp.Field(key="version_date", label="Date"),
+                dp.Field(key="report", label="Report"),
+                dp.Field(key="is_primary", label="Is Primary"),
+                dp.Field(key="disabled", label="Disabled"),
+                dp.Field(key="parameters", label="Parameters"),
+            )
+        )
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display(
+            [
+                ["title", "lookup", "uuid"],
+                ["version_date", "creation_date", "update_date"],
+                ["is_primary", "disabled", "disabled"],
+                ["parameters", ".", "."],
+            ]
+        )
+
+
+class ReportVersionReportDisplayConfig(ReportVersionDisplayConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=(
+                dp.Field(key="uuid", label="UUID"),
+                dp.Field(key="lookup", label="Lookup"),
+                dp.Field(key="title", label="Title"),
+                dp.Field(key="version_date", label="Date"),
+                dp.Field(key="report", label="Report"),
+                dp.Field(key="is_primary", label="Is Primary"),
+                dp.Field(key="disabled", label="Disabled"),
+                dp.Field(key="parameters", label="Parameters"),
+                dp.Field(key="comment", label="Comment"),
+            )
+        )