wbcompliance 2.2.1__py2.py3-none-any.whl

wbcompliance/urls.py

@@ -0,0 +1,238 @@
+from django.urls import include, path
+from wbcompliance import viewsets
+from wbcore.routers import WBCoreRouter
+
+router = WBCoreRouter()
+router.register(
+    r"complianceformrepresentation",
+    viewsets.ComplianceFormRepresentationViewSet,
+    basename="complianceformrepresentation",
+)
+router.register(
+    r"complianceformsectionrepresentation",
+    viewsets.ComplianceFormSectionRepresentationViewSet,
+    basename="complianceformsectionrepresentation",
+)
+router.register(
+    r"complianceformsignaturesectionrepresentation",
+    viewsets.ComplianceFormSignatureSectionRepresentationViewSet,
+    basename="complianceformsignaturesectionrepresentation",
+)
+
+router.register(
+    r"complianceformtyperepresentation",
+    viewsets.ComplianceFormTypeRepresentationViewSet,
+    basename="complianceformtyperepresentation",
+)
+router.register(r"complianceformtype", viewsets.ComplianceFormTypeViewSet, basename="complianceformtype")
+
+router.register(r"complianceform", viewsets.ComplianceFormModelViewSet)
+router.register(
+    r"complianceformsignature", viewsets.ComplianceFormSignatureModelViewSet, basename="complianceformsignature"
+)
+
+router.register(r"complianceformsection", viewsets.ComplianceFormSectionViewSet, basename="complianceformsection")
+
+router.register(r"complianceformrule", viewsets.ComplianceFormRuleViewSet, basename="complianceformrule")
+
+router.register(
+    r"compliancetaskrepresentation",
+    viewsets.ComplianceTaskRepresentationViewSet,
+    basename="compliancetaskrepresentation",
+)
+router.register(r"compliancetask", viewsets.ComplianceTaskModelViewSet, basename="compliancetask")
+router.register(
+    r"compliancetaskinstance", viewsets.ComplianceTaskInstanceModelViewSet, basename="compliancetaskinstance"
+)
+
+router.register(r"complianceaction", viewsets.ComplianceActionModelViewSet, basename="complianceaction")
+router.register(r"complianceevent", viewsets.ComplianceEventModelViewSet, basename="complianceevent")
+
+router.register(
+    r"compliancetyperepresentation",
+    viewsets.ComplianceTypeRepresentationViewSet,
+    basename="compliancetyperepresentation",
+)
+router.register(r"compliancetype", viewsets.ComplianceTypeModelViewSet, basename="compliancetype")
+
+router.register(
+    r"reviewcompliancetaskrepresentation",
+    viewsets.ReviewComplianceTaskRepresentationViewSet,
+    basename="reviewcompliancetaskrepresentation",
+)
+router.register(r"reviewcompliancetask", viewsets.ReviewComplianceTaskModelViewSet, basename="reviewcompliancetask")
+
+
+router.register(
+    r"compliancetaskgrouprepresentation",
+    viewsets.ComplianceTaskGroupRepresentationViewSet,
+    basename="compliancetaskgrouprepresentation",
+)
+router.register(r"compliancetaskgroup", viewsets.ComplianceTaskGroupModelViewSet, basename="compliancetaskgroup")
+
+# Subrouter for compliance type
+compliance_type_router = WBCoreRouter()
+compliance_type_router.register(
+    r"complianceaction",
+    viewsets.TypeComplianceActionModelViewSet,
+    basename="type-complianceaction",
+)
+compliance_type_router.register(
+    r"complianceevent",
+    viewsets.TypeComplianceEventModelViewSet,
+    basename="type-complianceevent",
+)
+
+
+# Subrouter for forms to be signed of a Compliance Form
+compliance_form_router = WBCoreRouter()
+compliance_form_router.register(
+    r"signatures",
+    viewsets.CFComplianceFormSignatureModelViewSet,
+    basename="complianceform-signatures",
+)
+# Subrouter for the section of a Compliance Form
+compliance_form_router.register(
+    r"sections",
+    viewsets.ComplianceFormSectionComplianceFormViewSet,
+    basename="complianceform-sections",
+)
+
+
+# Subrouter for the rules of a section
+section_router = WBCoreRouter()
+section_router.register(
+    r"rules",
+    viewsets.ComplianceFormSectionRuleViewSet,
+    basename="complianceformsection-rules",
+)
+
+section_router.register(
+    r"signauturerules",
+    viewsets.ComplianceFormSignatureSectionRuleViewSet,
+    basename="complianceformsignaturesection-rules",
+)
+
+
+# Subrouter for the compliance task of a group
+taskgroup_router = WBCoreRouter()
+taskgroup_router.register(
+    r"compliancetaskgroup",
+    viewsets.ComplianceTaskComplianceTaskGroupModelViewSet,
+    basename="compliancetaskgroup-compliancetask",
+)
+
+task_router = WBCoreRouter()
+task_router.register(
+    r"compliancetask",
+    viewsets.ComplianceTaskInstanceComplianceTaskModelViewSet,
+    basename="compliancetask-compliancetaskinstance",
+)
+
+
+# Subrouter for the compliance task of a review
+review_router = WBCoreRouter()
+review_router.register(
+    r"compliancetasknogroup",
+    viewsets.ComplianceTaskReviewNoGroupModelViewSet,
+    basename="review-compliancetasknogroup",
+)
+review_router.register(
+    r"compliancetaskinstancenogroup",
+    viewsets.ComplianceTaskInstanceReviewNoGroupModelViewSet,
+    basename="review-compliancetaskinstancenogroup",
+)
+
+# Subrouter for the compliance task of a group of  a review
+review_group_router = WBCoreRouter()
+review_group_router.register(
+    r"compliancetaskgroup",
+    viewsets.ComplianceTaskReviewGroupModelViewSet,
+    basename="review-compliancetaskgroup",
+)
+review_group_router.register(
+    r"compliancetaskinstancegroup",
+    viewsets.ComplianceTaskInstanceReviewGroupModelViewSet,
+    basename="review-compliancetaskinstancegroup",
+)
+
+# Risk Management url routing
+
+router.register("riskcheckrepresentation", viewsets.RiskCheckRepresentationViewSet, basename="riskcheckrepresentation")
+router.register("rulegrouprepresentation", viewsets.RuleGroupRepresentationViewSet, basename="rulegrouprepresentation")
+router.register(
+    "riskincidentrepresentation", viewsets.RiskIncidentRepresentationViewSet, basename="riskincidentrepresentation"
+)
+router.register(
+    "riskincidenttyperepresentation",
+    viewsets.RiskIncidentTypeRepresentationViewSet,
+    basename="riskincidenttyperepresentation",
+)
+router.register(
+    "checkedobjectincidentrelationshiprepresentation",
+    viewsets.CheckedObjectIncidentRelationshipRepresentationViewSet,
+    basename="checkedobjectincidentrelationshiprepresentation",
+)
+router.register(
+    "rulechecked_objectrelationshiprepresentation",
+    viewsets.RuleCheckedObjectRelationshipRepresentationViewSet,
+    basename="rulechecked_objectrelationshiprepresentation",
+)
+router.register(
+    "rulebackendrepresentation", viewsets.RuleBackendRepresentationViewSet, basename="rulebackendrepresentation"
+)
+router.register(
+    "rulethresholdrepresentation", viewsets.RuleThresholdRepresentationViewSet, basename="rulethresholdrepresentation"
+)
+router.register("riskrulerepresentation", viewsets.RiskRuleRepresentationViewSet, basename="riskrulerepresentation")
+router.register("riskincident", viewsets.RiskIncidentModelViewSet, basename="riskincident")
+router.register(
+    "checkedobjectincidentrelationship",
+    viewsets.CheckedObjectIncidentRelationshipModelViewSet,
+    basename="checkedobjectincidentrelationship",
+)
+router.register("riskcheck", viewsets.RiskCheckModelViewSet, basename="riskcheck")
+router.register("riskrule", viewsets.RiskRuleModelViewSet, basename="riskrule")
+
+rule_group_router = WBCoreRouter()
+rule_group_router.register(
+    r"incident",
+    viewsets.RiskIncidentRiskRuleModelViewSet,
+    basename="riskrule-incident",
+)
+rule_group_router.register(
+    r"relationship",
+    viewsets.RuleCheckedObjectRelationshipRiskRuleModelViewSet,
+    basename="riskrule-relationship",
+)
+rule_group_router.register(
+    r"threshold",
+    viewsets.RuleThresholdRiskRuleModelViewSet,
+    basename="riskrule-threshold",
+)
+
+incident_group_router = WBCoreRouter()
+incident_group_router.register(
+    r"relationship",
+    viewsets.CheckedObjectIncidentRelationshipRiskRuleModelViewSet,
+    basename="riskincident-relationship",
+)
+
+# Pandas ViewSet
+router.register("compliancetaskmatrix", viewsets.ComplianceTaskMatrixPandasViewSet, basename="compliancetaskmatrix")
+router.register(
+    "riskmanagementincidenttable", viewsets.RiskManagementIncidentTableView, basename="riskmanagementincidenttable"
+)
+
+urlpatterns = [
+    path("", include(router.urls)),
+    path("riskrule/<int:rule_id>/", include(rule_group_router.urls)),
+    path("riskincident/<int:incident_id>/", include(incident_group_router.urls)),
+    path("complianceform/<int:compliance_form_id>/", include(compliance_form_router.urls)),
+    path("section/<int:section_id>/", include(section_router.urls)),
+    path("taskgroup/<int:group_id>/", include(taskgroup_router.urls)),
+    path("task/<int:task_id>/", include(task_router.urls)),
+    path("review/<int:review_id>/", include(review_router.urls)),
+    path("review/<int:review_id>/group/<int:group_id>/", include(review_group_router.urls)),
+    path("type/<int:type_id>/", include(compliance_type_router.urls)),
+]

wbcompliance/viewsets/__init__.py

@@ -0,0 +1,40 @@
+from .compliance_form import (
+    CFComplianceFormSignatureModelViewSet,
+    ComplianceFormModelViewSet,
+    ComplianceFormRepresentationViewSet,
+    ComplianceFormRuleViewSet,
+    ComplianceFormSectionComplianceFormViewSet,
+    ComplianceFormSectionRepresentationViewSet,
+    ComplianceFormSectionRuleViewSet,
+    ComplianceFormSectionViewSet,
+    ComplianceFormSignatureModelViewSet,
+    ComplianceFormSignatureSectionRepresentationViewSet,
+    ComplianceFormSignatureSectionRuleViewSet,
+    ComplianceFormTypeRepresentationViewSet,
+    ComplianceFormTypeViewSet,
+)
+from .compliance_task import (
+    ComplianceActionModelViewSet,
+    ComplianceEventModelViewSet,
+    ComplianceTaskComplianceTaskGroupModelViewSet,
+    ComplianceTaskGroupModelViewSet,
+    ComplianceTaskGroupRepresentationViewSet,
+    ComplianceTaskInstanceComplianceTaskModelViewSet,
+    ComplianceTaskInstanceModelViewSet,
+    ComplianceTaskInstanceReviewGroupModelViewSet,
+    ComplianceTaskInstanceReviewNoGroupModelViewSet,
+    ComplianceTaskMatrixPandasViewSet,
+    ComplianceTaskModelViewSet,
+    ComplianceTaskRepresentationViewSet,
+    ComplianceTaskReviewGroupModelViewSet,
+    ComplianceTaskReviewNoGroupModelViewSet,
+    ReviewComplianceTaskModelViewSet,
+    ReviewComplianceTaskRepresentationViewSet,
+    TypeComplianceActionModelViewSet,
+    TypeComplianceEventModelViewSet,
+)
+from .compliance_type import (
+    ComplianceTypeModelViewSet,
+    ComplianceTypeRepresentationViewSet,
+)
+from .risk_management import *

wbcompliance/viewsets/buttons/__init__.py

@@ -0,0 +1,9 @@
+from .compliance_form import (
+    ComplianceFormButtonConfig,
+    ComplianceFormSignatureButtonConfig,
+)
+from .compliance_task import (
+    ComplianceTaskButtonConfig,
+    ReviewComplianceTaskButtonConfig,
+)
+from .risk_managment import *

wbcompliance/viewsets/buttons/compliance_form.py

@@ -0,0 +1,78 @@
+from django.utils.translation import gettext as _
+from wbcompliance.serializers import ComplianceFormSignatureModelSerializer
+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,
+)
+
+
+class AbstractComplianceDocumentButtonConfig:
+    @classmethod
+    def _get_compliance_document_button(cls) -> bt.ActionButton:
+        class ComplianceDocumentSerializer(wb_serializers.Serializer):
+            send_email = wb_serializers.BooleanField(default=False, label=_("Email me the document"))
+
+        return bt.ActionButton(
+            method=RequestType.PATCH,
+            key="regenerate_document",
+            action_label=_("Regenerate Document"),
+            title=_("Regenerate Document"),
+            label=_("Regenerate Document"),
+            icon=WBIcon.DOCUMENT.icon,
+            serializer=ComplianceDocumentSerializer,
+            instance_display=create_simple_display([["send_email"]]),
+        )
+
+
+# COMPLIANCE FORM
+class ComplianceFormButtonConfig(ButtonViewConfig):
+    CUSTOM_INSTANCE_BUTTONS = CUSTOM_LIST_INSTANCE_BUTTONS = {
+        bt.ActionButton(
+            method=RequestType.PATCH,
+            identifiers=("wbcompliance:compliance_form",),
+            key="send_compliance_form_notification",
+            action_label=_("Send signature reminder notification"),
+            title=_("Send signature reminder notification"),
+            label=_("Send signature reminder notification"),
+            icon=WBIcon.FEEDBACK.icon,
+            description_fields=_(
+                """<p> <b>{{_form_type.name}} :</b> {{title}}</p>
+             <p>Do you want to send a Compliance Form reminder notification ? </p>"""
+            ),
+            confirm_config=bt.ButtonConfig(label=_("Confirm")),
+            cancel_config=bt.ButtonConfig(label=_("Cancel")),
+        ),
+        bt.WidgetButton(key="signatures", label=_("List all signatures"), icon=WBIcon.VIEW.icon),
+        AbstractComplianceDocumentButtonConfig._get_compliance_document_button(),
+    }
+
+
+# COMPLIANCE FORM SIGNATURE
+class ComplianceFormSignatureButtonConfig(ButtonViewConfig):
+    CUSTOM_INSTANCE_BUTTONS = CUSTOM_LIST_INSTANCE_BUTTONS = {
+        bt.ActionButton(
+            method=RequestType.PATCH,
+            identifiers=("wbcompliance:complianceformsignature",),
+            key="signature",
+            action_label=_("Signature"),
+            title=_("Signature Compliance Form"),
+            label=_("Signature"),
+            icon=WBIcon.CONFIRM.icon,
+            description_fields=_(
+                """
+            <p> <b>{{_compliance_form.form_type}} : <span>{{_compliance_form.title}}</span></b></p>
+            <p>Version : {{version}}</p> <p><br/><br/>Do you want to sign <b>{{_compliance_form.title}}</b> ? </p>
+            <p><span style='color:red'>This action is not reversible</span></p>
+            """
+            ),
+            serializer=ComplianceFormSignatureModelSerializer,
+            confirm_config=bt.ButtonConfig(label=_("Confirm")),
+            cancel_config=bt.ButtonConfig(label=_("Cancel")),
+            instance_display=create_simple_display([["remark"]]),
+        ),
+        AbstractComplianceDocumentButtonConfig._get_compliance_document_button(),
+    }

wbcompliance/viewsets/buttons/compliance_task.py

@@ -0,0 +1,149 @@
+from django.apps import apps
+from django.contrib.contenttypes.models import ContentType
+from django.db.models import Q
+from django.utils.translation import gettext as _
+from rest_framework.reverse import reverse
+from wbcompliance.models import ComplianceType, ReviewComplianceTask
+from wbcompliance.viewsets.buttons.compliance_form import (
+    AbstractComplianceDocumentButtonConfig,
+)
+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,
+)
+
+
+def get_custom_report(_request, review: ReviewComplianceTask):
+    try:
+        content_type = ContentType.objects.get(app_label="wbcompliance", model="reviewcompliancetask")
+        ReportVersion = apps.get_model("wbreport", "ReportVersion")
+        BUTTTONS = []
+        versions = ReportVersion.objects.filter(
+            version_date=review.to_date, report__content_type=content_type, report__is_active=True
+        ).filter(Q(parameters__type=review.type.name) | Q(parameters__type=review.type.id))
+        for version in versions:
+            BUTTTONS.append(
+                bt.HyperlinkButton(
+                    endpoint=reverse("report:reportversion-html", args=[version.id], request=_request),
+                    label=_("Show {}").format(version.title),
+                    icon=WBIcon.DOCUMENT.icon,
+                )
+            )
+            if not version.lock:
+                BUTTTONS.append(
+                    bt.ActionButton(
+                        method=RequestType.GET,
+                        identifiers=("wbreport:reportversion",),
+                        endpoint=reverse("wbreport:reportversion-updatecontext", args=[version.id], request=_request),
+                        label=_("Update {}").format(version.title),
+                        description_fields=_(
+                            """
+                        <p>Update and actualize context</p>
+                        """
+                        ),
+                        icon=WBIcon.REGENERATE.icon,
+                        action_label=_("Update Context {}").format(version.title),
+                        title=_("Update {}").format(version.title),
+                    ),
+                )
+        if BUTTTONS:
+            return {
+                bt.DropDownButton(
+                    label=_("Report"),
+                    icon=WBIcon.UNFOLD.icon,
+                    buttons=tuple(BUTTTONS),
+                ),
+            }
+    except LookupError:
+        pass
+
+    return set()
+
+
+class ComplianceTaskButtonConfig(ButtonViewConfig):
+    def get_custom_instance_buttons(self):
+        class OccuredSerializer(wb_serializers.Serializer):
+            occured = wb_serializers.DateField(required=True)
+
+        BUTTONS = []
+        if self.view.kwargs.get("pk", None) and self.request.user.is_superuser:
+            review = self.view.get_object()
+            if review.active:
+                BUTTONS += [
+                    bt.ActionButton(
+                        method=RequestType.PATCH,
+                        identifiers=("wbcompliance:compliancetask",),
+                        key="generateinstance",
+                        action_label=_("Generate Instance"),
+                        title=_("Generate Instance "),
+                        label=_("Generate Instance"),
+                        icon=WBIcon.ADD.icon,
+                        serializer=OccuredSerializer,
+                        instance_display=create_simple_display([["occured"]]),
+                    )
+                ]
+        return {*BUTTONS}
+
+
+class ReviewComplianceTaskButtonConfig(ButtonViewConfig):
+    def get_custom_instance_buttons(self):
+        class LinkedTypeSerializer(wb_serializers.Serializer):
+            type = wb_serializers.ChoiceField(
+                required=True, choices=ComplianceType.objects.all().values_list("name", flat=True)
+            )
+            operation = wb_serializers.ChoiceField(
+                choices=[("ADD", "Add existing indicators"), ("REMOVE", "Remove existing Indicators")],
+            )
+
+        BUTTONS = []
+        if self.view.kwargs.get("pk", None) and self.request.user.has_perm("wbcompliance.administrate_compliance"):
+            review = self.view.get_object()
+            if review.is_instance:
+                BUTTONS = get_custom_report(_request=self.request, review=review)
+            else:
+                if review.status == ReviewComplianceTask.Status.VALIDATED:
+                    BUTTONS += [AbstractComplianceDocumentButtonConfig._get_compliance_document_button()]
+
+                    if self.request.user.has_perm("wbcompliance.administrate_compliance"):
+                        BUTTONS += [
+                            bt.ActionButton(
+                                method=RequestType.PATCH,
+                                identifiers=("wbcompliance:reviewcompliancetask",),
+                                key="generate_instance",
+                                action_label="Generate Instance Report Indicator",
+                                title="Generate Instance Report Indicator",
+                                label="Generate Instance Report Indicator",
+                                icon=WBIcon.ADD.icon,
+                                confirm_config=bt.ButtonConfig(label=_("Confirm")),
+                                cancel_config=bt.ButtonConfig(label=_("Cancel")),
+                            ),
+                        ]
+
+                if review.status == ReviewComplianceTask.Status.DRAFT and self.request.user.is_superuser:
+                    BUTTONS += [
+                        bt.ActionButton(
+                            method=RequestType.PATCH,
+                            identifiers=("wbcompliance:reviewcompliancetask",),
+                            key="link_tasks",
+                            action_label=_("Add/Remove Indicators of a Type"),
+                            title=_("Add/Remove existing indicators"),
+                            label=_("Add/Remove existing indicators"),
+                            icon=WBIcon.LINK.icon,
+                            description_fields=_(
+                                """
+                            <p> <b>Indicators Report : <span>{{title}} </span></b><br/><br/>
+                            Linking Indicators of type
+                            """
+                            ),
+                            serializer=LinkedTypeSerializer,
+                            instance_display=create_simple_display([["type"], ["operation"]]),
+                            confirm_config=bt.ButtonConfig(label=_("Confirm")),
+                            cancel_config=bt.ButtonConfig(label=_("Cancel")),
+                        ),
+                    ]
+
+        return {*BUTTONS}

wbcompliance/viewsets/buttons/risk_managment/__init__.py

@@ -0,0 +1,3 @@
+from .checks import RiskCheckButtonConfig
+from .incidents import RiskIncidentButtonConfig
+from .rules import RiskRuleButtonConfig

wbcompliance/viewsets/buttons/risk_managment/checks.py

@@ -0,0 +1,11 @@
+from django.utils.translation import gettext as _
+from wbcore.contrib.icons import WBIcon
+from wbcore.metadata.configs import buttons as bt
+from wbcore.metadata.configs.buttons.view_config import ButtonViewConfig
+
+
+class RiskCheckButtonConfig(ButtonViewConfig):
+    def get_custom_list_instance_buttons(self):
+        return {
+            bt.WidgetButton(key="incidents", label=_("Incidents"), icon=WBIcon.WARNING.icon),
+        }

wbcompliance/viewsets/buttons/risk_managment/incidents.py

@@ -0,0 +1,51 @@
+from django.utils.translation import gettext as _
+from rest_framework.reverse import reverse
+from wbcompliance.models.risk_management import RiskIncident
+from wbcore import serializers as wb_serializers
+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,
+)
+
+
+class RiskIncidentButtonConfig(ButtonViewConfig):
+    def get_custom_buttons(self):
+        if not self.view.kwargs.get("pk", None) and RiskIncident.can_manage(self.request.user):
+
+            class RiskRuleTypeSerializer(wb_serializers.Serializer):
+                resolve_status = wb_serializers.ChoiceField(
+                    label=_("Rule Type"),
+                    choices=[
+                        (RiskIncident.Status.RESOLVED.name, RiskIncident.Status.RESOLVED.label),
+                        (RiskIncident.Status.IGNORED.name, RiskIncident.Status.IGNORED.label),
+                    ],
+                    default=RiskIncident.Status.RESOLVED,
+                )
+                comment = wb_serializers.TextField(default="", label=_("Comment"))
+
+            endpoint = reverse("wbcompliance:riskincident-resolveallincidents", args=[], request=self.request)
+            queryset = RiskIncident.objects.all()
+            if rule_id := self.view.kwargs.get("rule_id", None):
+                queryset = queryset.filter(rule=rule_id)
+                endpoint += f"?rule_id={rule_id}"
+            return {
+                bt.ActionButton(
+                    method=RequestType.PATCH,
+                    identifiers=("wbcompliance:riskincident",),
+                    endpoint=endpoint,
+                    label=_("Resolve all open Incident"),
+                    description_fields=_(
+                        "<p>Are you sure you want to close the current <b>{}</b> opened incidents?</p>"
+                    ).format(queryset.count()),
+                    serializer=RiskRuleTypeSerializer,
+                    action_label=_("resolveallincidents"),
+                    title=_("Resolve all open Incident"),
+                    instance_display=create_simple_display([["resolve_status"], ["comment"]]),
+                )
+            }
+        return set()
+
+    def get_custom_list_instance_buttons(self):
+        return set()

wbcompliance/viewsets/buttons/risk_managment/rules.py

@@ -0,0 +1,35 @@
+from django.utils.translation import gettext as _
+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,
+)
+
+
+class RiskRuleButtonConfig(ButtonViewConfig):
+    def get_custom_instance_buttons(self):
+        class CheckSerializer(wb_serializers.Serializer):
+            start = wb_serializers.DateField(label=_("Start"))
+            end = wb_serializers.DateField(label=_("End"))
+
+        return {
+            bt.ActionButton(
+                method=RequestType.PATCH,
+                identifiers=("risk_management:riskcheck",),
+                key="recheck",
+                label=_("Recheck Rules"),
+                icon=WBIcon.REGENERATE.icon,
+                description_fields=_(
+                    """
+                <p>Recheck all the rules between a certain interval</p>
+                """
+                ),
+                serializer=CheckSerializer,
+                action_label=_("recheck"),
+                title=_("Recheck Rules"),
+                instance_display=create_simple_display([["start"], ["end"]]),
+            )
+        }