wbcompliance 2.2.1__py2.py3-none-any.whl

wbcompliance/viewsets/display/risk_managment/incidents.py

@@ -0,0 +1,155 @@
+from typing import Optional
+
+from django.utils.translation import gettext as _
+from rest_framework.reverse import reverse
+from wbcompliance.models.risk_management import RiskIncident, RiskIncidentType
+from wbcore.contrib.icons import WBIcon
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    Display,
+    create_simple_display,
+    create_simple_section,
+)
+from wbcore.metadata.configs.display.instance_display.utils import repeat_field
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+
+def get_formatting(id_field="id", color=False):
+    formattings = []
+    for _type in RiskIncidentType.objects.all():
+        style = {"backgroundColor": _type.color}
+        if color:
+            style["color"] = _type.color
+        formattings.append(
+            dp.FormattingRule(
+                style=style,
+                condition=("==", getattr(_type, id_field)),
+            ),
+        )
+    return dp.Formatting(column="severity", formatting_rules=formattings)
+
+
+def get_legends():
+    legends = []
+    for _type in RiskIncidentType.objects.all():
+        legends.append(dp.LegendItem(icon=_type.color, label=_type.name, value=_type.id))
+    return dp.Legend(items=legends, key="severity")
+
+
+class RiskIncidentDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        fields = [
+            dp.Field(
+                key=None,
+                label="Rule",
+                open_by_default=False,
+                children=[
+                    dp.Field(key="status", label=_("Status"), show="open"),
+                    dp.Field(key="object_repr", label=_("Object")),
+                    dp.Field(key="rule", label=_("Rule")),
+                    dp.Field(key="threshold_repr", label=_("Breached Threshold")),
+                ],
+            ),
+            dp.Field(
+                key=None,
+                label="Incident",
+                open_by_default=False,
+                children=[
+                    dp.Field(key="breached_value", label=_("Breached Value")),
+                    dp.Field(key="report", label=_("Report Detail"), show="open"),
+                    dp.Field(key="checked_date", label=_("Date"), show="open"),
+                ],
+            ),
+            dp.Field(
+                key=None,
+                label="Management",
+                open_by_default=False,
+                children=[
+                    dp.Field(key="resolved_by", label=_("Resolved By")),
+                    dp.Field(key="is_notified", label=_("Users notified"), show="open"),
+                    dp.Field(key="ignore_until", label=_("Ignored Until"), show="open"),
+                    dp.Field(key="comment", label=_("Comment"), show="open"),
+                ],
+            ),
+        ]
+        return dp.ListDisplay(
+            fields=fields,
+            tree=True,
+            tree_group_level_options=[
+                dp.TreeGroupLevelOption(
+                    filter_key="incident",
+                    filter_depth=1,
+                    clear_filter=True,
+                    list_endpoint=reverse(
+                        "wbcompliance:checkedobjectincidentrelationship-list",
+                        args=[],
+                        request=self.request,
+                    ),
+                )
+            ],
+            # tree_group_lookup="id_repr",
+            tree_group_pinned="left",
+            tree_group_field="date_range",
+            tree_group_label=_("Date Range"),
+            legends=[
+                get_legends(),
+                dp.Legend(
+                    key="status",
+                    items=[
+                        dp.LegendItem(
+                            icon=WBIcon.VIEW.icon,
+                            label=_("{} Incidents").format(RiskIncident.Status.OPEN.label),
+                            value=RiskIncident.Status.OPEN.name,
+                        ),
+                    ],
+                ),
+            ],
+            formatting=[
+                get_formatting(),
+                dp.Formatting(
+                    column="status",
+                    formatting_rules=[
+                        dp.FormattingRule(
+                            icon=WBIcon.VIEW.icon,
+                            condition=("==", RiskIncident.Status.OPEN.name),
+                        )
+                    ],
+                ),
+            ],
+        )
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display(
+            [
+                [repeat_field(3, "status")],
+                ["date_range", "rule", "severity"],
+                ["breached_content_type", "breached_object_id", "breached_object_repr"],
+                ["comment", "resolved_by", "ignore_until"],
+                [repeat_field(3, "relationships_section")],
+            ],
+            [
+                create_simple_section(
+                    "relationships_section", _("Relationships"), [["relationships"]], "relationships", collapsed=False
+                )
+            ],
+        )
+
+
+class CheckedObjectIncidentRelationshipRiskRuleDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="status", label=_("status")),
+                dp.Field(key="checked_date", label=_("Date")),
+                dp.Field(key="rule_check", label=_("Check")),
+                dp.Field(key="checked_object", label=_("Checked Object")),
+                dp.Field(key="breached_value", label=_("Breached Value")),
+                dp.Field(key="report", label=_("Report")),
+                dp.Field(key="resolved_by", label=_("resolved_by")),
+                dp.Field(key="comment", label=_("comment")),
+            ],
+            legends=[get_legends()],
+            formatting=[
+                get_formatting(),
+            ],
+        )

wbcompliance/viewsets/display/risk_managment/rules.py

@@ -0,0 +1,146 @@
+from typing import Optional
+
+from django.utils.translation import gettext as _
+from wbcore.contrib.color.enums import WBColor
+from wbcore.enums import Unit
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.instance_display.shortcuts import (
+    Display,
+    create_simple_display,
+    create_simple_section,
+)
+from wbcore.metadata.configs.display.instance_display.utils import repeat_field
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+
+class RuleThresholdRiskRuleDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                # dp.Field(key="range", label=_("Range")),
+                dp.Field(key="range_lower", label=_("Lower Range")),
+                dp.Field(key="range_upper", label=_("Upper Range")),
+                dp.Field(key="severity", label=_("Severity")),
+                dp.Field(key="notifiable_users", label=_("Notifiable Users")),
+                dp.Field(key="notifiable_groups", label=_("Notifiable Groups")),
+                dp.Field(key="upgradable_after_days", label=_("Upgrade severity after")),
+            ]
+        )
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display(
+            [
+                ["severity", "upgradable_after_days", "range_lower", "range_upper"],
+                [repeat_field(2, "notifiable_users"), repeat_field(2, "notifiable_groups")],
+            ]
+        )
+
+
+class RuleCheckedObjectRelationshipRiskRuleDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                # dp.Field(key="checked_object_content_type",  label=_("Content Type")),
+                # dp.Field(key="checked_object_id",  label=_("Object ID")),
+                dp.Field(key="checked_object_repr", label=_("Checked Objects")),
+            ]
+        )
+
+    def get_instance_display(self) -> Display:
+        return create_simple_display([["checked_object_id" if self.new_mode else "checked_object_repr"]])
+
+
+class RiskRuleDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        return dp.ListDisplay(
+            fields=[
+                dp.Field(key="name", label=_("Name"), width=Unit.PIXEL(300)),
+                dp.Field(key="description", label=_("Description")),
+                dp.Field(key="open_incidents_count", label=_("Open Incidents")),
+                dp.Field(key="is_enable", label=_("Enable")),
+                dp.Field(key="only_passive_check_allowed", label=_("Passive Only")),
+                dp.Field(
+                    key=None,
+                    label="Administration",
+                    open_by_default=False,
+                    children=[
+                        dp.Field(key="rule_backend", label=_("Rule Backend"), width=Unit.PIXEL(200)),
+                        dp.Field(key="frequency", label=_("Frequency"), width=Unit.PIXEL(200)),
+                        dp.Field(key="activation_date", label=_("Activation Date"), width=Unit.PIXEL(200)),
+                        dp.Field(key="is_silent", label=_("Silent"), show="open"),
+                        dp.Field(key="is_mandatory", label=_("Mandatory"), show="open"),
+                        dp.Field(
+                            key="automatically_close_incident", label=_("Automatically Close Incidents"), show="open"
+                        ),
+                        dp.Field(key="apply_to_all_active_relationships", label=_("All Checked Objects"), show="open"),
+                        dp.Field(key="permission_type", label=_("Permission"), show="open"),
+                    ],
+                ),
+            ],
+            legends=[
+                dp.Legend(
+                    key="in_breach",
+                    items=[
+                        dp.LegendItem(icon=WBColor.RED_LIGHT.value, label=_("In Breach"), value="BREACH"),
+                        dp.LegendItem(icon=WBColor.GREEN_LIGHT.value, label=_("Passed"), value="PASSED"),
+                    ],
+                ),
+            ],
+            formatting=[
+                dp.Formatting(
+                    column="in_breach",
+                    formatting_rules=[
+                        dp.FormattingRule(
+                            style={"backgroundColor": WBColor.RED_LIGHT.value},
+                            condition=("==", "BREACH"),
+                        ),
+                        dp.FormattingRule(
+                            style={"backgroundColor": WBColor.GREEN_LIGHT.value},
+                            condition=("==", "PASSED"),
+                        ),
+                    ],
+                )
+            ],
+        )
+
+    def get_instance_display(self) -> Display:
+        try:
+            rule = self.view.get_object()
+            parameter_fields = [
+                [
+                    f"parameters__{field}"
+                    for field in rule.rule_backend.backend_class.get_serializer_class().get_parameter_fields()
+                ]
+            ]
+        except Exception:
+            parameter_fields = [["parameters"]]
+        return create_simple_display(
+            [
+                [repeat_field(2, "name"), repeat_field(2, "rule_backend"), "is_enable"],
+                ["permission_type", "frequency", "activation_date", repeat_field(2, "creator")],
+                [
+                    "only_passive_check_allowed",
+                    "is_silent",
+                    "is_mandatory",
+                    "automatically_close_incident",
+                    "apply_to_all_active_relationships",
+                ],
+                [repeat_field(5, "description")],
+                [repeat_field(5, "parameters_section")],
+                [repeat_field(5, "thresholds_section")],
+                [repeat_field(5, "relationships_section")],
+                [repeat_field(5, "incidents_section")],
+            ],
+            [
+                create_simple_section("parameters_section", _("Parameters"), parameter_fields, collapsed=True),
+                create_simple_section(
+                    "thresholds_section", _("Thresholds"), [["thresholds"]], "thresholds", collapsed=True
+                ),
+                create_simple_section(
+                    "relationships_section", _("Relationships"), [["relationships"]], "relationships", collapsed=True
+                ),
+                create_simple_section(
+                    "incidents_section", _("Incidents"), [["incidents"]], "incidents", collapsed=False
+                ),
+            ],
+        )

wbcompliance/viewsets/display/risk_managment/tables.py

@@ -0,0 +1,51 @@
+from typing import Optional
+
+from django.utils.translation import gettext as _
+from wbcore.contrib.color.enums import WBColor
+from wbcore.enums import Unit
+from wbcore.metadata.configs import display as dp
+from wbcore.metadata.configs.display.view_config import DisplayViewConfig
+
+from .incidents import get_formatting, get_legends
+
+
+class RiskManagementIncidentTableDisplayConfig(DisplayViewConfig):
+    def get_list_display(self) -> Optional[dp.ListDisplay]:
+        if content_type := self.view.checked_object_content_type:
+            field_name = content_type.name
+        else:
+            field_name = "Checked object"
+        fields = [
+            dp.Field(
+                key="checked_object_repr",
+                label=field_name,
+                width=Unit.PIXEL(250),
+                formatting_rules=[dp.FormattingRule(style={"fontWeight": "bold"})],
+            )
+        ]
+        for key, label in self.view.get_rule_map:
+            fields.append(
+                dp.Field(
+                    key=key,
+                    label=label,
+                    width=Unit.PIXEL(200),
+                    formatting_rules=[
+                        dp.FormattingRule(
+                            condition=("==", -1),
+                            style={"backgroundColor": WBColor.GREEN_LIGHT.value, "color": WBColor.GREEN_LIGHT.value},
+                        ),
+                        *get_formatting(id_field="severity_order", color=True).formatting_rules,
+                    ],
+                )
+            )
+        return dp.ListDisplay(
+            fields=fields,
+            legends=[
+                dp.Legend(
+                    items=[
+                        dp.LegendItem(icon=WBColor.GREEN_LIGHT.value, label=_("No Incident")),
+                        *get_legends().items,
+                    ]
+                )
+            ],
+        )

wbcompliance/viewsets/endpoints/__init__.py

@@ -0,0 +1,27 @@
+from .compliance_form import (
+    CFComplianceFormSectionEndpointConfig,
+    CFComplianceFormSignatureEndpointConfig,
+    ComplianceFormEndpointConfig,
+    ComplianceFormRuleEndpointConfig,
+    ComplianceFormSectionRuleEndpointConfig,
+    ComplianceFormSignatureEndpointConfig,
+    ComplianceFormSignatureSectionRuleEndpointConfig,
+    ComplianceFormTypeEndpointConfig,
+)
+from .compliance_task import (
+    ComplianceActionEndpointConfig,
+    ComplianceEventEndpointConfig,
+    ComplianceTaskComplianceTaskGroupEndpointConfig,
+    ComplianceTaskEndpointConfig,
+    ComplianceTaskGroupEndpointConfig,
+    ComplianceTaskInstanceComplianceTaskEndpointConfig,
+    ComplianceTaskInstanceEndpointConfig,
+    ComplianceTaskInstanceReviewGroupEndpointConfig,
+    ComplianceTaskInstanceReviewNoGroupEndpointConfig,
+    ComplianceTaskMatrixEndpointConfig,
+    ComplianceTaskReviewGroupEndpointConfig,
+    ComplianceTaskReviewNoGroupEndpointConfig,
+    ReviewComplianceTaskEndpointConfig,
+)
+from .compliance_type import ComplianceTypeEndpointConfig
+from .risk_managment import *

wbcompliance/viewsets/endpoints/compliance_form.py

@@ -0,0 +1,207 @@
+from rest_framework.reverse import reverse
+from wbcompliance.models import ComplianceForm, ComplianceFormSection, ComplianceType
+from wbcore.metadata.configs.endpoints import EndpointViewConfig
+
+
+# Compliance Form
+class ComplianceFormEndpointConfig(EndpointViewConfig):
+    def get_instance_endpoint(self, **kwargs):
+        if self.instance:
+            obj = self.view.get_object()
+            if (
+                not ComplianceType.is_administrator(self.request.user)
+                or obj.status == ComplianceForm.Status.ACTIVATION_REQUESTED
+            ):
+                return None
+        return super().get_instance_endpoint()
+
+    def get_create_endpoint(self, **kwargs):
+        if ComplianceType.is_administrator(self.request.user):
+            return super().get_create_endpoint()
+        return None
+
+    def get_delete_endpoint(self, **kwargs):
+        if self.instance:
+            obj = self.view.get_object()
+            if (
+                not ComplianceType.is_administrator(self.request.user)
+                or obj.status == ComplianceForm.Status.ACTIVATION_REQUESTED
+            ):
+                return None
+        return super().get_delete_endpoint()
+
+
+class ComplianceFormSignatureEndpointConfig(EndpointViewConfig):
+    def get_endpoint(self, **kwargs):
+        return reverse(f"{self.view.get_model().get_endpoint_basename()}-list", request=self.request)
+
+    def get_instance_endpoint(self, **kwargs):
+        if self.instance:
+            obj = self.view.get_object()
+            if obj.person != self.request.user.profile or obj.signed:
+                return None
+        return super().get_instance_endpoint()
+
+    def get_create_endpoint(self, **kwargs):
+        return None
+
+    def get_delete_endpoint(self, **kwargs):
+        return None
+
+
+class CFComplianceFormSignatureEndpointConfig(ComplianceFormSignatureEndpointConfig):
+    def get_endpoint(self, **kwargs):
+        return reverse(
+            "wbcompliance:complianceform-signatures-list",
+            args=[self.view.kwargs["compliance_form_id"]],
+            request=self.request,
+        )
+
+
+# SECTION OF THE COMPLIANCE FORM
+class CFComplianceFormSectionEndpointConfig(EndpointViewConfig):
+    def get_endpoint(self, **kwargs):
+        return reverse(
+            "wbcompliance:complianceform-sections-list",
+            args=[self.view.kwargs["compliance_form_id"]],
+            request=self.request,
+        )
+
+    def get_instance_endpoint(self, **kwargs):
+        if self.instance and not ComplianceType.is_administrator(self.request.user):
+            return None
+        if self.instance and "compliance_form_id" in self.view.kwargs:
+            obj = ComplianceForm.objects.get(id=self.view.kwargs.get("compliance_form_id"))
+            if obj.status == ComplianceForm.Status.ACTIVATION_REQUESTED:
+                return None
+        return super().get_instance_endpoint()
+
+    def get_create_endpoint(self, **kwargs):
+        if not ComplianceType.is_administrator(self.request.user):
+            return None
+        if "compliance_form_id" in self.view.kwargs:
+            obj = ComplianceForm.objects.get(id=self.view.kwargs.get("compliance_form_id"))
+            if obj.status == ComplianceForm.Status.ACTIVATION_REQUESTED:
+                return None
+        return super().get_create_endpoint()
+
+    def get_delete_endpoint(self, **kwargs):
+        if not ComplianceType.is_administrator(self.request.user):
+            return None
+        if "compliance_form_id" in self.view.kwargs:
+            obj = ComplianceForm.objects.get(id=self.view.kwargs.get("compliance_form_id"))
+            if obj.status == ComplianceForm.Status.ACTIVATION_REQUESTED:
+                return None
+        if "pk" in self.view.kwargs:
+            return f'{self.get_endpoint()}{self.view.kwargs["pk"]}/'
+        return super().get_delete_endpoint()
+
+
+# RULES OF THE SECTION
+class ComplianceFormRuleEndpointConfig(EndpointViewConfig):
+    def get_list_endpoint(self, **kwargs):
+        return reverse(f"{self.view.get_model().get_endpoint_basename()}-list", request=self.request)
+
+    def get_instance_endpoint(self, **kwargs):
+        if self.instance and not ComplianceType.is_administrator(self.request.user):
+            return None
+        return super().get_instance_endpoint()
+
+    def get_create_endpoint(self, **kwargs):
+        if ComplianceType.is_administrator(self.request.user):
+            return super().get_create_endpoint()
+        return None
+
+    def get_delete_endpoint(self, **kwargs):
+        if ComplianceType.is_administrator(self.request.user):
+            return super().get_delete_endpoint()
+        return None
+
+
+class ComplianceFormSectionRuleEndpointConfig(EndpointViewConfig):
+    def get_endpoint(self, **kwargs):
+        return reverse(
+            "wbcompliance:complianceformsection-rules-list",
+            args=[self.view.kwargs["section_id"]],
+            request=self.request,
+        )
+
+    def get_list_endpoint(self, **kwargs):
+        return super().get_list_endpoint()
+
+    def get_instance_endpoint(self, **kwargs):
+        if self.instance and not ComplianceType.is_administrator(self.request.user):
+            return None
+        if self.instance and "section_id" in self.view.kwargs:
+            obj = ComplianceFormSection.objects.get(id=self.view.kwargs.get("section_id"))
+            if obj.compliance_form.status == ComplianceForm.Status.ACTIVATION_REQUESTED:
+                return None
+        return super().get_instance_endpoint()
+
+    def get_create_endpoint(self, **kwargs):
+        if not ComplianceType.is_administrator(self.request.user):
+            return None
+        if "section_id" in self.view.kwargs:
+            obj = ComplianceFormSection.objects.get(id=self.view.kwargs.get("section_id"))
+            if obj.compliance_form.status == ComplianceForm.Status.ACTIVATION_REQUESTED:
+                return None
+        return super().get_create_endpoint()
+
+    def get_delete_endpoint(self, **kwargs):
+        if not ComplianceType.is_administrator(self.request.user):
+            return None
+        if "section_id" in self.view.kwargs:
+            obj = ComplianceFormSection.objects.get(id=self.view.kwargs.get("section_id"))
+            if obj.compliance_form.status == ComplianceForm.Status.ACTIVATION_REQUESTED:
+                return None
+        if "pk" in self.view.kwargs:
+            return f'{self.get_endpoint()}{self.view.kwargs["pk"]}/'
+        return super().get_delete_endpoint()
+
+
+class ComplianceFormSignatureSectionRuleEndpointConfig(EndpointViewConfig):
+    def get_endpoint(self, **kwargs):
+        return reverse(
+            "wbcompliance:complianceformsignaturesection-rules-list",
+            args=[self.view.kwargs["section_id"]],
+            request=self.request,
+        )
+
+    def get_list_endpoint(self, **kwargs):
+        return super().get_list_endpoint()
+
+    def get_instance_endpoint(self, **kwargs):
+        if self.instance:
+            obj = self.view.get_object()
+            if (
+                obj.section.compliance_form_signature.person != self.request.user.profile
+                or obj.section.compliance_form_signature.signed
+            ):
+                return None
+        return super().get_instance_endpoint()
+
+    def get_create_endpoint(self, **kwargs):
+        return None
+
+    def get_delete_endpoint(self, **kwargs):
+        return None
+
+
+class ComplianceFormTypeEndpointConfig(EndpointViewConfig):
+    def get_list_endpoint(self, **kwargs):
+        return reverse(f"{self.view.get_model().get_endpoint_basename()}-list", request=self.request)
+
+    def get_instance_endpoint(self, **kwargs):
+        if self.instance and not ComplianceType.is_administrator(self.request.user):
+            return None
+        return super().get_instance_endpoint()
+
+    def get_create_endpoint(self, **kwargs):
+        if ComplianceType.is_administrator(self.request.user):
+            return super().get_create_endpoint()
+        return None
+
+    def get_delete_endpoint(self, **kwargs):
+        if ComplianceType.is_administrator(self.request.user):
+            return super().get_delete_endpoint()
+        return None