wbcompliance 2.2.1__py2.py3-none-any.whl

wbcompliance/viewsets/risk_management/incidents.py

@@ -0,0 +1,204 @@
+from django.contrib.auth import get_user_model
+from django.contrib.auth.models import Permission
+from django.contrib.contenttypes.models import ContentType
+from django.contrib.messages.api import warning
+from django.contrib.postgres.fields.ranges import DateRangeField
+from django.db.models import (
+    Case,
+    CharField,
+    DateField,
+    Exists,
+    ExpressionWrapper,
+    F,
+    IntegerField,
+    OuterRef,
+    Subquery,
+    Value,
+    When,
+)
+from django.db.models.functions import Cast, Concat
+from django.http import HttpResponse
+from django.utils.functional import cached_property
+from rest_framework import status
+from rest_framework.decorators import action
+from wbcompliance.filters import (
+    CheckedObjectIncidentRelationshipFilterSet,
+    RiskIncidentFilterSet,
+)
+from wbcompliance.models import RuleThreshold
+from wbcompliance.models.risk_management import (
+    CheckedObjectIncidentRelationship,
+    RiskIncident,
+    RiskIncidentType,
+    RiskRule,
+)
+from wbcompliance.models.risk_management.incidents import resolve_all_incidents_as_task
+from wbcompliance.permissions import RulePermission
+from wbcompliance.serializers import (
+    CheckedObjectIncidentRelationshipModelSerializer,
+    CheckedObjectIncidentRelationshipRepresentationSerializer,
+    RiskIncidentModelSerializer,
+    RiskIncidentRepresentationSerializer,
+    RiskIncidentTypeRepresentationSerializer,
+)
+from wbcompliance.viewsets.buttons import RiskIncidentButtonConfig
+from wbcompliance.viewsets.display import (
+    CheckedObjectIncidentRelationshipRiskRuleDisplayConfig,
+    RiskIncidentDisplayConfig,
+)
+from wbcompliance.viewsets.endpoints import (
+    CheckedObjectIncidentRelationshipEndpointConfig,
+    CheckedObjectIncidentRelationshipRiskRuleEndpointConfig,
+    RiskIncidentEndpointConfig,
+)
+from wbcore import viewsets
+from wbcore.contrib.guardian.models import UserObjectPermission
+
+User = get_user_model()
+
+
+class RiskIncidentTypeRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = RiskIncidentType.objects.all()
+    serializer_class = RiskIncidentTypeRepresentationSerializer
+    search_fields = ("name",)
+
+
+class RiskIncidentRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = RiskIncident.objects.all()
+    serializer_class = RiskIncidentRepresentationSerializer
+    search_fields = (
+        "rule__name",
+        "breached_object_repr",
+    )
+
+
+class CheckedObjectIncidentRelationshipRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = CheckedObjectIncidentRelationship.objects.all()
+    serializer_class = CheckedObjectIncidentRelationshipRepresentationSerializer
+
+
+class RiskIncidentModelViewSet(viewsets.ModelViewSet):
+    permission_classes = [RulePermission]
+    display_config_class = RiskIncidentDisplayConfig
+    endpoint_config_class = RiskIncidentEndpointConfig
+    button_config_class = RiskIncidentButtonConfig
+
+    ordering_fields = [
+        "status",
+        "date_range",
+        "rule__name",
+        "object_repr",
+        "severity__name",
+        "resolved_by__computed_str",
+        "comment",
+    ]
+    ordering = ["-date_range", "-severity__severity_order", "id"]
+    serializer_class = RiskIncidentModelSerializer
+    queryset = RiskIncident.objects.select_related(
+        "resolved_by",
+        "breached_content_type",
+        "rule",
+        "severity",
+    ).prefetch_related("checked_object_relationships")
+    filterset_class = RiskIncidentFilterSet
+
+    @action(detail=False, methods=["PATCH"])
+    def resolveallincidents(self, request, pk=None):
+        resolve_status = request.POST.get("resolve_status", RiskIncident.Status.RESOLVED.name)
+        resolve_all_incidents_as_task.delay(
+            request.user.id,
+            request.POST.get("comment", ""),
+            resolve_status == RiskIncident.Status.RESOLVED.name,
+            rule_id=request.GET.get("rule_id", None),
+        )
+        return HttpResponse("All opened incidents are resolved", status=status.HTTP_200_OK)
+
+    @cached_property
+    def rule_content_type(self):
+        return ContentType.objects.get_for_model(RiskRule)
+
+    @cached_property
+    def view_rule_permission(self):
+        return Permission.objects.get(codename="view_riskrule", content_type__app_label="wbcompliance")
+
+    def get_queryset(self):
+        """
+        We protect the queryset to allow only user to see their respective incidents
+        """
+        queryset = super().get_queryset()
+        if not self.request.user.has_perm("administrate_riskrule"):
+            queryset = queryset.annotate(
+                rule_pk=Cast(
+                    "rule_id", output_field=CharField()
+                ),  # We need to cast the rule id into a charfield otherwise postgres complains with the operator
+                have_view_permission_on_rule=Exists(
+                    UserObjectPermission.objects.filter(
+                        permission=self.view_rule_permission,
+                        content_type=self.rule_content_type,
+                        object_pk=OuterRef("rule_pk"),
+                        user=self.request.user,
+                    )
+                ),
+            ).filter(have_view_permission_on_rule=True)
+        queryset = queryset.annotate(
+            has_subincidents=Exists(CheckedObjectIncidentRelationship.objects.filter(incident=OuterRef("pk"))),
+            _group_key=Case(When(has_subincidents=True, then=F("id")), default=None, output_field=IntegerField()),
+            checked_date=ExpressionWrapper(F("date_range__endswith") - 1, output_field=DateField()),
+            object_repr=Concat(Value("Breached: "), F("breached_object_repr")),
+            threshold_repr=Subquery(
+                RuleThreshold.objects.filter(severity=OuterRef("severity"), rule=OuterRef("rule")).values(
+                    "computed_str"
+                )[:1]
+            ),
+        )
+        return queryset
+
+    def add_messages(self, request, instance: RiskIncident | None = None, **kwargs):
+        if instance:
+            if instance.status == RiskIncident.Status.OPEN and instance.last_ignored_date:
+                warning(
+                    request,
+                    f"This incident was automatically reopened after being ignored from {instance.last_ignored_date:%Y-%m-%d} to {instance.get_ignore_until_date():%Y-%m-%d}",
+                )
+
+
+class RiskIncidentRiskRuleModelViewSet(RiskIncidentModelViewSet):
+    permission_classes = [RulePermission]
+
+    def get_queryset(self):
+        return super().get_queryset().filter(rule=self.kwargs["rule_id"])
+
+
+class CheckedObjectIncidentRelationshipModelViewSet(viewsets.ModelViewSet):
+    permission_classes = [RulePermission]
+    ordering = ["-rule_check__evaluation_date"]
+    ordering_fields = ["status", "object_repr", "checked_date"]
+    serializer_class = CheckedObjectIncidentRelationshipModelSerializer
+    queryset = CheckedObjectIncidentRelationship.objects.select_related(
+        "resolved_by",
+        "incident",
+        "rule_check",
+        "severity",
+    ).annotate(
+        object_repr=F("rule_check__rule_checked_object_relationship__checked_object_repr"),
+        checked_date=F("rule_check__evaluation_date"),
+        date_range=Cast(
+            Concat(Value("["), F("checked_date"), Value(","), F("checked_date"), Value("]")),
+            output_field=DateRangeField(),
+        ),
+        threshold_repr=Subquery(
+            RuleThreshold.objects.filter(severity=OuterRef("severity"), rule=OuterRef("incident__rule")).values(
+                "computed_str"
+            )[:1]
+        ),
+    )
+    display_config_class = CheckedObjectIncidentRelationshipRiskRuleDisplayConfig
+    endpoint_config_class = CheckedObjectIncidentRelationshipEndpointConfig
+    filterset_class = CheckedObjectIncidentRelationshipFilterSet
+
+
+class CheckedObjectIncidentRelationshipRiskRuleModelViewSet(CheckedObjectIncidentRelationshipModelViewSet):
+    endpoint_config_class = CheckedObjectIncidentRelationshipRiskRuleEndpointConfig
+
+    def get_queryset(self):
+        return super().get_queryset().filter(incident=self.kwargs["incident_id"])

wbcompliance/viewsets/risk_management/mixins.py

@@ -0,0 +1,52 @@
+from contextlib import suppress
+
+from django.contrib.contenttypes.models import ContentType
+from rest_framework.reverse import reverse
+from wbcompliance.models.risk_management.checks import RiskCheck
+from wbcore.contrib.icons import WBIcon
+from wbcore.metadata.configs import buttons as bt
+from wbcore.signals import add_additional_resource, add_instance_button
+
+
+class RiskCheckViewSetMixin:
+    @classmethod
+    def _get_risk_checks_button_title(cls) -> str:
+        return "Checks"
+
+    @classmethod
+    def _add_risk_check_button(cls, sender, many, *args, view=None, **kwargs):
+        icon = WBIcon.CONFIRM.icon
+        with suppress(AssertionError):
+            if view and (obj := view.get_object()):
+                icon = RiskCheck.CheckStatus[obj.get_worst_check_status()].icon
+        return bt.WidgetButton(key="checks", label=cls._get_risk_checks_button_title(), icon=icon)
+
+    @classmethod
+    def _add_risk_check_add_additional_resource(
+        cls, sender, serializer, instance, request, user, view=None, is_list=False, **kwargs
+    ):
+        if not is_list and instance.checks.exists() and (content_type := ContentType.objects.get_for_model(instance)):
+            return {
+                "checks": f'{reverse("wbcompliance:riskcheck-list", args=[], request=request)}?triggers=[[{content_type.id},{instance.id}]]'
+            }
+        return {}
+
+    def options(self, request, *args, **kwargs):
+        """
+        Handler method for HTTP 'OPTIONS' request.
+        """
+        add_instance_button.connect(
+            self._add_risk_check_button,
+            sender=self.__class__,
+            dispatch_uid="wbcompliance_add_instance_button_riskcheck",
+        )
+        return super().options(request, *args, **kwargs)
+
+    def get_serializer_class(self):
+        serializer_class = super().get_serializer_class()
+        add_additional_resource.connect(
+            self._add_risk_check_add_additional_resource,
+            sender=serializer_class,
+            dispatch_uid="wbcompliance_add_additional_resource_riskcheck",
+        )
+        return serializer_class

wbcompliance/viewsets/risk_management/rules.py

@@ -0,0 +1,179 @@
+import pandas as pd
+from django.contrib.auth import get_user_model
+from django.db.models import Case, CharField, Count, OuterRef, Q, Subquery, Value, When
+from django.db.models.functions import Coalesce
+from django.http import HttpResponse
+from django.shortcuts import get_object_or_404
+from rest_framework import status
+from rest_framework.decorators import action
+from wbcompliance.filters import RiskRuleFilterSet
+from wbcompliance.models.risk_management import (
+    RiskIncident,
+    RiskRule,
+    RuleBackend,
+    RuleCheckedObjectRelationship,
+    RuleThreshold,
+)
+from wbcompliance.models.risk_management.rules import RuleGroup, process_rule_as_task
+from wbcompliance.permissions import RulePermission
+from wbcompliance.serializers import (
+    RiskRuleModelSerializer,
+    RiskRuleRepresentationSerializer,
+    RuleBackendRepresentationSerializer,
+    RuleCheckedObjectRelationshipModelSerializer,
+    RuleCheckedObjectRelationshipRepresentationSerializer,
+    RuleGroupRepresentationSerializer,
+    RuleThresholdModelSerializer,
+    RuleThresholdRepresentationSerializer,
+)
+from wbcompliance.viewsets.buttons import RiskRuleButtonConfig
+from wbcompliance.viewsets.display import (
+    RiskRuleDisplayConfig,
+    RuleCheckedObjectRelationshipRiskRuleDisplayConfig,
+    RuleThresholdRiskRuleDisplayConfig,
+)
+from wbcompliance.viewsets.endpoints import (
+    RiskRuleEndpointConfig,
+    RuleCheckedObjectRelationshipRiskRuleEndpointConfig,
+    RuleThresholdRiskRuleEndpointConfig,
+)
+from wbcore import serializers as wb_serializers
+from wbcore import viewsets
+from wbcore.contrib.guardian.viewsets.mixins import GuardianFilterMixin
+from wbcore.utils.date import get_date_interval_from_request
+
+User = get_user_model()
+
+
+class RuleGroupRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = RuleGroup.objects.all()
+    serializer_class = RuleGroupRepresentationSerializer
+    search_fields = ("name",)
+
+
+class RuleCheckedObjectRelationshipRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = RuleCheckedObjectRelationship.objects.all()
+    serializer_class = RuleCheckedObjectRelationshipRepresentationSerializer
+    search_fields = ("checked_object_repr",)
+
+
+class RuleBackendRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = RuleBackend.objects.all()
+    serializer_class = RuleBackendRepresentationSerializer
+    search_fields = ("name",)
+
+
+class RuleThresholdRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = RuleThreshold.objects.all()
+    serializer_class = RuleThresholdRepresentationSerializer
+
+
+class RiskRuleRepresentationViewSet(GuardianFilterMixin, viewsets.RepresentationViewSet):
+    queryset = RiskRule.objects.all()
+    serializer_class = RiskRuleRepresentationSerializer
+    search_fields = (
+        "name",
+        "description",
+        "rule_backend__name",
+    )
+
+
+class RuleThresholdRiskRuleModelViewSet(viewsets.ModelViewSet):
+    permission_classes = [RulePermission]
+    display_config_class = RuleThresholdRiskRuleDisplayConfig
+    endpoint_config_class = RuleThresholdRiskRuleEndpointConfig
+    queryset = RuleThreshold.objects.all()
+    serializer_class = RuleThresholdModelSerializer
+    filterset_fields = {
+        "severity": ["exact"],
+    }
+
+    def get_queryset(self):
+        return super().get_queryset().filter(rule_id=self.kwargs["rule_id"])
+
+
+class RuleCheckedObjectRelationshipRiskRuleModelViewSet(viewsets.ModelViewSet):
+    permission_classes = [RulePermission]
+    display_config_class = RuleCheckedObjectRelationshipRiskRuleDisplayConfig
+    endpoint_config_class = RuleCheckedObjectRelationshipRiskRuleEndpointConfig
+    queryset = RuleCheckedObjectRelationship.objects.all()
+    serializer_class = RuleCheckedObjectRelationshipModelSerializer
+    search_fields = ["checked_object_repr"]
+    filterset_fields = {
+        "checked_object_repr": ["icontains"],
+    }
+
+    def get_queryset(self):
+        return super().get_queryset().filter(rule_id=self.kwargs["rule_id"])
+
+
+class RiskRuleModelViewSet(GuardianFilterMixin, viewsets.ModelViewSet):
+    display_config_class = RiskRuleDisplayConfig
+    endpoint_config_class = RiskRuleEndpointConfig
+    button_config_class = RiskRuleButtonConfig
+
+    queryset = RiskRule.objects.all()
+    serializer_class = RiskRuleModelSerializer
+    filterset_class = RiskRuleFilterSet
+
+    search_fields = ("name", "description", "checked_object_relationships__checked_object_repr")
+    ordering_fields = (
+        "name",
+        "is_enable",
+        "only_passive_check_allowed",
+        "is_silent",
+        "is_mandatory",
+        "open_incidents_count",
+    )
+    ordering = ("name",)
+
+    def get_serializer_class(self):
+        if "pk" in self.kwargs:
+            if rule := self.get_object():
+                parameter_fields = rule.rule_backend.backend_class.get_serializer_class().get_parameter_fields()
+
+                class TmpSerializer(RiskRuleModelSerializer):
+                    class Meta(RiskRuleModelSerializer.Meta):
+                        flatten_fields = {
+                            "parameters": wb_serializers.JSONTableField(
+                                serializer_class=rule.rule_backend.backend_class.get_serializer_class(),
+                                flatten_field_names=parameter_fields,
+                            )
+                        }
+
+                return TmpSerializer
+        return RiskRuleModelSerializer
+
+    def _subquery_open_risk_incidents_count(self):
+        queryset = RiskIncident.objects.filter(status=RiskIncident.Status.OPEN, rule=OuterRef("pk"))
+        return Coalesce(Subquery(queryset.values("rule").annotate(c=Count("rule")).values("c")[:1]), 0)
+
+    def get_queryset(self):
+        return (
+            super()
+            .get_queryset()
+            .annotate(
+                open_incidents_count=self._subquery_open_risk_incidents_count(),
+                in_breach=Case(
+                    When(Q(open_incidents_count__gt=0) & Q(is_enable=True), then=Value("BREACH")),
+                    When(Q(open_incidents_count=0) & Q(is_enable=True), then=Value("PASSED")),
+                    default=Value("INACTIVE"),
+                    output_field=CharField(),
+                ),
+            )
+            .select_related(
+                "rule_backend",
+                "creator",
+            )
+            .prefetch_related("incidents")
+        )
+
+    @action(detail=True, methods=["PATCH"])
+    def recheck(self, request, pk=None):
+        start, end = get_date_interval_from_request(request, request_type="POST")
+        if start and end:
+            rule = get_object_or_404(RiskRule, pk=pk)
+            for evaluation_date in pd.date_range(start, end, freq="B"):
+                process_rule_as_task.delay(rule.id, evaluation_date, override_incident=False)
+            return HttpResponse("Rule is checking", status=status.HTTP_200_OK)
+        return HttpResponse("Wrong arguments", status=status.HTTP_400_BAD_REQUEST)

wbcompliance/viewsets/risk_management/tables.py

@@ -0,0 +1,96 @@
+import numpy as np
+import pandas as pd
+from django.contrib.contenttypes.models import ContentType
+from django.db.models import Q
+from django.utils.functional import cached_property
+from django.utils.translation import gettext as _
+from wbcompliance.filters import RiskManagementIncidentFilter
+from wbcompliance.models.risk_management import (
+    CheckedObjectIncidentRelationship,
+    RiskRule,
+)
+from wbcore.pandas import fields as pf
+from wbcore.pandas.views import PandasAPIViewSet
+from wbcore.utils.models import get_object
+
+from ..display import RiskManagementIncidentTableDisplayConfig
+from ..endpoints import RiskManagementIncidentTableEndpointConfig
+from ..titles import RiskManagementIncidentTableTitleConfig
+
+
+class RiskManagementIncidentTableView(PandasAPIViewSet):
+    IDENTIFIER = "wbcompliance:riskmanagementincidentpandas"
+    filterset_class = RiskManagementIncidentFilter
+    queryset = CheckedObjectIncidentRelationship.objects.all()
+
+    display_config_class = RiskManagementIncidentTableDisplayConfig
+    title_config_class = RiskManagementIncidentTableTitleConfig
+    endpoint_config_class = RiskManagementIncidentTableEndpointConfig
+
+    @cached_property
+    def checked_object_content_type(self):
+        if checked_object_content_type_id := self.request.GET.get("checked_object_content_type", None):
+            return ContentType.objects.get(id=checked_object_content_type_id)
+
+    @cached_property
+    def get_rule_map(self):
+        rules = RiskRule.objects.filter(
+            Q(is_enable=True)
+            & (
+                Q(rule_backend__allowed_checked_object_content_type__isnull=True)
+                | Q(rule_backend__allowed_checked_object_content_type=self.checked_object_content_type)
+            )
+        )
+        return list(map(lambda x: (f'rule_{x["id"]}', x["name"]), rules.order_by("name").values("id", "name")))
+
+    def get_ordering_fields(self):
+        return ["checked_object_repr", *[x[0] for x in self.get_rule_map]]
+
+    def get_pandas_fields(self, request):
+        fields = [
+            pf.PKField(key="id", label=_("ID")),
+            pf.CharField(key="checked_object_repr", label=_("ID")),
+        ]
+        for key, label in self.get_rule_map:
+            fields.append(pf.IntegerField(key=key, label=label))
+        return pf.PandasFields(fields=tuple(fields))
+
+    def get_queryset(self):
+        return CheckedObjectIncidentRelationship.objects.filter(incident__rule__is_enable=True)
+
+    def get_dataframe(self, request, queryset, **kwargs):
+        df = pd.DataFrame()
+        if checked_object_content_type := self.checked_object_content_type:
+            df = pd.DataFrame(
+                queryset.values(
+                    "rule_check__rule_checked_object_relationship__checked_object_id",
+                    "incident__rule__id",
+                    "severity__severity_order",
+                ),
+                columns=[
+                    "rule_check__rule_checked_object_relationship__checked_object_id",
+                    "incident__rule__id",
+                    "severity__severity_order",
+                ],
+            )
+            df = df.rename(
+                columns={
+                    "rule_check__rule_checked_object_relationship__checked_object_id": "id",
+                    "incident__rule__id": "rule",
+                    "severity__severity_order": "severity",
+                }
+            )
+
+            if not df.empty:
+                df = (
+                    df.pivot_table(index="id", columns=["rule"], values="severity", aggfunc=np.max, fill_value=-1)
+                    .rename_axis(None, axis=1)
+                    .astype("int")
+                )
+                df = df.rename(columns=lambda x: f"rule_{x}")
+                df = df.reset_index()
+                df["checked_object_repr"] = df.id.apply(
+                    lambda x: str(get_object(checked_object_content_type.model_class(), x))
+                )
+                df = df.where(pd.notnull(df), -1)
+        return df

wbcompliance/viewsets/titles/__init__.py

@@ -0,0 +1,17 @@
+from .compliance_form import (
+    ComplianceFormSectionRuleTitleConfig,
+    ComplianceFormSectionTitleConfig,
+    ComplianceFormSignatureSectionRuleTitleConfig,
+    ComplianceFormSignatureTitleConfig,
+    ComplianceFormTitleConfig,
+)
+from .compliance_task import (
+    ComplianceTaskComplianceTaskGroupTitleConfig,
+    ComplianceTaskGroupTitleConfig,
+    ComplianceTaskInstanceTitleConfig,
+    ComplianceTaskMatrixPandasTitleConfig,
+    ComplianceTaskTitleConfig,
+    ReviewComplianceTaskTitleConfig,
+)
+from .compliance_type import ComplianceTypeTitleConfig
+from .risk_managment import *

wbcompliance/viewsets/titles/compliance_form.py

@@ -0,0 +1,101 @@
+from django.utils.translation import gettext as _
+from wbcompliance.models import (
+    ComplianceForm,
+    ComplianceFormRule,
+    ComplianceFormSection,
+    ComplianceFormSignatureRule,
+    ComplianceFormSignatureSection,
+)
+from wbcore.metadata.configs.titles import TitleViewConfig
+
+
+class ComplianceFormTitleConfig(TitleViewConfig):
+    def get_instance_title(self):
+        return _("Compliance Form: {{title}} - version {{version}}")
+
+    def get_list_title(self):
+        return _("Compliance Forms")
+
+    def get_create_title(self):
+        return _("New Compliance Form")
+
+
+class ComplianceFormSignatureTitleConfig(TitleViewConfig):
+    def get_instance_title(self):
+        return _("Compliance Form Signature: {{_compliance_form.title}} - version {{_compliance_form.version}}")
+
+    def get_list_title(self):
+        return _("Compliance Form Signatures")
+
+    def get_create_title(self):
+        return _("New Compliance Form Signature")
+
+
+class ComplianceFormSectionTitleConfig(TitleViewConfig):
+    def get_instance_title(self):
+        if ref_id := self.view.kwargs.get("pk"):
+            _section = ComplianceFormSection.objects.get(id=ref_id)
+            return _("Compliance Form Section: {} of Compliance Form: - version {}").format(
+                _section.name, _section.compliance_form.title, _section.compliance_form.version
+            )
+
+        return _("Compliance Form Section: {{name}}")
+
+    def get_list_title(self):
+        if compliance_form_id := self.view.kwargs.get("compliance_form_id"):
+            compliance_form = ComplianceForm.objects.get(id=compliance_form_id)
+            return _("Compliance Form: {} - version {}").format(compliance_form.title, compliance_form.version)
+        return _("Compliance Form Sections")
+
+    def get_create_title(self):
+        if compliance_form_id := self.view.kwargs.get("compliance_form_id"):
+            compliance_form = ComplianceForm.objects.get(id=compliance_form_id)
+            return _("New Section of Compliance Form: {} - version {}").format(
+                compliance_form.title, compliance_form.version
+            )
+        return _("New Section")
+
+
+class ComplianceFormSectionRuleTitleConfig(TitleViewConfig):
+    def get_instance_title(self):
+        if ref_id := self.view.kwargs.get("pk"):
+            _rule = ComplianceFormRule.objects.get(id=ref_id)
+            return _("Compliance Form Rule: {} of Section: {}").format(_rule.id, _rule.section.name)
+        return _("Compliance Form Rule: {{id}}")
+
+    def get_list_title(self):
+        if section_id := self.view.kwargs.get("section_id"):
+            section = ComplianceFormSection.objects.get(id=section_id)
+            return _("Compliance Form: {} - version {}").format(
+                section.compliance_form.title, section.compliance_form.version
+            )
+        return _("Compliance Form Rules")
+
+    def get_create_title(self):
+        if section_id := self.view.kwargs.get("section_id"):
+            section = ComplianceFormSection.objects.get(id=section_id)
+            return _("New Rule of Section: {}").format(section.name)
+        return _("New Rule")
+
+
+class ComplianceFormSignatureSectionRuleTitleConfig(TitleViewConfig):
+    def get_instance_title(self):
+        if ref_id := self.view.kwargs.get("pk"):
+            _rule = ComplianceFormSignatureRule.objects.get(id=ref_id)
+            return _("Compliance Form Signature Rule: {} of Section: {}").format(_rule.id, _rule.section.name)
+        return _("Compliance Form Signature Rule: {{id}}")
+
+    def get_list_title(self):
+        if section_id := self.view.kwargs.get("section_id"):
+            section = ComplianceFormSignatureSection.objects.get(id=section_id)
+            return _("Compliance Form Signature: {} - version {}").format(
+                section.compliance_form_signature.compliance_form.title,
+                section.compliance_form_signature.compliance_form.version,
+            )
+        return _("Compliance Form Signature Rules")
+
+    def get_create_title(self):
+        if section_id := self.view.kwargs.get("section_id"):
+            section = ComplianceFormSignatureSection.objects.get(id=section_id)
+            return _("New Rule of Section: {}").format(section.name)
+        return _("New Rule")