wbcompliance 2.2.1__py2.py3-none-any.whl

wbcompliance/filters/risk_management/rules.py

@@ -0,0 +1,110 @@
+from django.db.models import Count, F, OuterRef, Q, Subquery
+from django.db.models.functions import Coalesce
+from django.utils.translation import gettext_lazy as _
+from wbcompliance.models.risk_management import RiskRule, RuleThreshold
+from wbcore import filters as wb_filters
+from wbcore.contrib.directory.models import Person
+
+from ...models.risk_management.rules import RuleGroup
+from .utils import get_default_handler
+
+
+class RiskRuleFilterSet(wb_filters.FilterSet):
+    checked_object_relationships = wb_filters.MultipleChoiceContentTypeFilter(
+        label="Checked Objects",
+        field_name="checked_object_relationships",
+        distinct=True,
+        object_id_label="checked_object_relationships__checked_object_id",
+        content_type_label="checked_object_relationships__checked_object_content_type",
+        hidden=True,
+    )
+
+    exclude_informational_rule = wb_filters.BooleanFilter(
+        method="filter_exclude_informational_rule", default=True, label=_("Exclude Informational Rule")
+    )
+    rule_group = wb_filters.ModelChoiceFilter(
+        label=_("Group"),
+        queryset=RuleGroup.objects.all(),
+        endpoint=RuleGroup.get_representation_endpoint(),
+        value_key=RuleGroup.get_representation_value_key(),
+        label_key=RuleGroup.get_representation_label_key(),
+        method="filter_rule_group",
+    )
+
+    def filter_rule_group(self, queryset, label, value):
+        if value:
+            return queryset.filter(Q(rule_backend__rule_group=value) | Q(rule_backend__rule_group__isnull=True))
+        return queryset
+
+    def filter_exclude_informational_rule(self, queryset, label, value):
+        if value:
+            queryset = queryset.annotate(
+                threshold_count=Coalesce(
+                    Subquery(
+                        RuleThreshold.objects.filter(rule=OuterRef("pk"))
+                        .values("rule")
+                        .annotate(c=Count("rule"))
+                        .values("c")[:1]
+                    ),
+                    0,
+                ),
+                informational_count=Coalesce(
+                    Subquery(
+                        RuleThreshold.objects.filter(rule=OuterRef("pk"), severity__is_informational=True)
+                        .values("rule")
+                        .annotate(c=Count("rule"))
+                        .values("c")[:1]
+                    ),
+                    0,
+                ),
+            )
+            return queryset.exclude(threshold_count=F("informational_count"))
+        return queryset
+
+    in_breach = wb_filters.ChoiceFilter(
+        method="filter_in_breach",
+        label=_("Open Incidents"),
+        choices=[("BREACH", "In Breach"), ("PASSED", "Passed"), ("INACTIVE", "Inactive")],
+    )
+    open_incidents_count = wb_filters.NumberFilter(
+        label=_("Opened Incident"), field_name="open_incidents_count", lookup_expr="exact"
+    )
+    open_incidents_count__lte = wb_filters.NumberFilter(
+        label=_("Opened Incident"), field_name="open_incidents_count", lookup_expr="lte"
+    )
+    open_incidents_count__gte = wb_filters.NumberFilter(
+        label=_("Opened Incident"), field_name="open_incidents_count", lookup_expr="gte"
+    )
+    notified_by = wb_filters.ModelChoiceFilter(
+        label=_("Notifed Users"),
+        default=get_default_handler,
+        queryset=Person.objects.all(),
+        endpoint=Person.get_representation_endpoint(),
+        value_key=Person.get_representation_value_key(),
+        label_key=Person.get_representation_label_key(),
+        method="filter_notified_by",
+    )
+
+    def filter_notified_by(self, queryset, name, value):
+        if value:
+            thresholds = RuleThreshold.objects.filter(
+                Q(notifiable_users=value) | Q(notifiable_groups__in=value.user_account.groups.all())
+            )
+            return queryset.filter(thresholds__in=thresholds).distinct()
+        return queryset
+
+    def filter_in_breach(self, queryset, name, value):
+        if value:
+            return queryset.filter(in_breach=value)
+        return queryset
+
+    class Meta:
+        model = RiskRule
+        fields = {
+            "rule_backend": ["exact"],
+            "is_enable": ["exact"],
+            "only_passive_check_allowed": ["exact"],
+            "is_silent": ["exact"],
+            "is_mandatory": ["exact"],
+            "automatically_close_incident": ["exact"],
+        }

wbcompliance/filters/risk_management/tables.py

@@ -0,0 +1,112 @@
+from django.contrib.contenttypes.models import ContentType
+from django.db.models import Count, Q
+from django.dispatch import receiver
+from django.utils.translation import gettext_lazy as _
+from wbcompliance.models.risk_management import CheckedObjectIncidentRelationship
+from wbcore import filters as wb_filters
+from wbcore.signals.filters import add_filters
+
+
+def get_content_type_default(*args, **kwargs):
+    content_type_id = (
+        CheckedObjectIncidentRelationship.objects.values(
+            "rule_check__rule_checked_object_relationship__checked_object_content_type"
+        )
+        .annotate(c=Count("rule_check__rule_checked_object_relationship__checked_object_content_type"))
+        .order_by("c")
+        .first()["rule_check__rule_checked_object_relationship__checked_object_content_type"]
+    )
+    return ContentType.objects.get(id=content_type_id).id
+
+
+def filter_date_range(queryset, label, value):
+    if value:
+        return queryset.filter(
+            Q(rule_check__evaluation_date__gte=value.lower) & Q(rule_check__evaluation_date__lte=value.upper)
+        )
+    return queryset
+
+
+class RiskManagementIncidentFilter(wb_filters.FilterSet):
+    incident_date_range = wb_filters.DateRangeFilter(label=_("Date Range"), method=filter_date_range)
+    only_open_incident = wb_filters.BooleanFilter(
+        default=True, method="filter_only_open_incident", label=_("Only open incidents")
+    )
+
+    checked_object_content_type = wb_filters.ModelChoiceFilter(
+        required=True,
+        method="filter_checked_object_content_type",
+        queryset=ContentType.objects.all(),
+        endpoint="wbcore:contenttyperepresentation-list",
+        value_key="id",
+        label_key="{{app_label}} | {{model}}",
+        label=_("Checked Object Type"),
+        default=get_content_type_default,
+        filter_params={"related_name_isnull": "risk_management_checked_objects"},
+        clearable=False,
+    )
+
+    def filter_checked_object_content_type(self, queryset, label, value):
+        if value:
+            return queryset.filter(rule_check__rule_checked_object_relationship__checked_object_content_type=value)
+        return queryset
+
+    def filter_only_open_incident(self, queryset, name, value):
+        if value:
+            return queryset.filter(status=CheckedObjectIncidentRelationship.Status.OPEN)
+        return queryset
+
+    class Meta:
+        model = CheckedObjectIncidentRelationship
+        fields = {
+            # "rule_backend": ["exact"],
+            # "is_enable": ["exact"],
+            # "only_passive_check_allowed": ["exact"],
+            # "is_silent": ["exact"],
+            # "is_mandatory": ["exact"],
+        }
+
+
+@receiver(add_filters, sender=RiskManagementIncidentFilter)
+def add_checked_object_repr_filter(sender, request=None, *args, **kwargs):
+    content_type = None
+    if request and (content_type_id := request.GET.get("checked_object_content_type", None)):
+        content_type = ContentType.objects.get(id=content_type_id)
+    elif default_callback := getattr(sender, "default", None):
+        content_type = ContentType.objects.get(id=default_callback())
+    if content_type:
+
+        def filter_checked_object_repr(queryset, label, value):
+            if value:
+                return queryset.filter(rule_check__rule_checked_object_relationship__checked_object_id=value.id)
+            return queryset
+
+        model_class = content_type.model_class()
+        return {
+            "checked_object_repr": wb_filters.ModelChoiceFilter(
+                label=content_type.name,
+                field_name="checked_object_repr",
+                queryset=model_class.objects.all(),
+                endpoint=model_class.get_representation_endpoint(),
+                value_key=model_class.get_representation_value_key(),
+                label_key=model_class.get_representation_label_key(),
+                method=filter_checked_object_repr,
+            )
+        }
+    else:
+
+        def filter_checked_object_repr(queryset, label, value):
+            if value:
+                return queryset.filter(
+                    rule_check__rule_checked_object_relationship__checked_object_repr__icontains=value
+                )
+            return queryset
+
+        return {
+            "checked_object_repr": wb_filters.CharFilter(
+                label=_("Checked Object Repr."),
+                method=filter_checked_object_repr,
+                lookup_expr="icontains",
+                field_name="checked_object_repr",
+            )
+        }

wbcompliance/filters/risk_management/utils.py

@@ -0,0 +1,3 @@
+def get_default_handler(field, request, view, **kwargs):
+    if not request.user.is_superuser and (profile := request.user.profile):
+        return profile.id

wbcompliance/management/__init__.py

@@ -0,0 +1,10 @@
+from django.utils.module_loading import autodiscover_modules
+from django.db import DEFAULT_DB_ALIAS
+from django.apps import apps as global_apps
+
+
+def autodiscover_riskmanagement_backends(
+    app_config, verbosity=2, interactive=True, using=DEFAULT_DB_ALIAS, apps=global_apps, **kwargs
+):
+    # we wrap the autodiscover into a post_migrate receiver because we expect db calls
+    autodiscover_modules("risk_management.backends")