wbcompliance 2.2.1__py2.py3-none-any.whl

wbcompliance/factories/risk_management/__init__.py

@@ -0,0 +1,12 @@
+from .checks import RiskCheckFactory
+from .incidents import (
+    CheckedObjectIncidentRelationshipFactory,
+    RiskIncidentFactory,
+    RiskIncidentTypeFactory,
+)
+from .rules import (
+    RiskRuleFactory,
+    RuleBackendFactory,
+    RuleCheckedObjectRelationshipFactory,
+    RuleThresholdFactory,
+)

wbcompliance/factories/risk_management/backends.py

@@ -0,0 +1,42 @@
+from typing import Generator
+
+from django.contrib.auth import get_user_model
+from django.contrib.contenttypes.models import ContentType
+from faker import Faker
+from wbcompliance.models.risk_management import backend
+from wbcore import serializers as wb_serializers
+
+User = get_user_model()
+fake = Faker()
+
+
+class RuleBackend(backend.AbstractRuleBackend):
+    @classmethod
+    def get_serializer_class(cls):
+        class RuleBackendSerializer(wb_serializers.Serializer):
+            date = wb_serializers.DateField(required=False)
+            name = wb_serializers.CharField(required=False)
+            int = wb_serializers.IntegerField(required=False)
+            anonymous_user = wb_serializers.PrimaryKeyRelatedField(
+                queryset=User.objects.all(), default=User.objects.none(), required=False
+            )
+
+            @classmethod
+            def get_parameter_fields(cls):
+                return ["date", "name", "int", "anonymous_user"]
+
+        return RuleBackendSerializer
+
+    def check_rule(self, *dto_args, **kwargs) -> Generator[backend.IncidentResult, None, None]:
+        severity = self.thresholds.first().severity if self.thresholds.exists() else None
+        yield backend.IncidentResult(
+            breached_object=None,
+            breached_value=str(fake.word()),
+            breached_object_repr=fake.text(max_nb_chars=125),
+            report_details={"label": fake.paragraph()},
+            severity=severity,
+        )
+
+    @classmethod
+    def get_allowed_content_type(cls) -> "ContentType":
+        return None

wbcompliance/factories/risk_management/checks.py

@@ -0,0 +1,12 @@
+import factory
+from wbcompliance.models.risk_management.checks import RiskCheck
+
+
+class RiskCheckFactory(factory.django.DjangoModelFactory):
+    rule_checked_object_relationship = factory.SubFactory(
+        "wbcompliance.factories.risk_management.rules.RuleCheckedObjectRelationshipFactory"
+    )
+    evaluation_date = factory.Faker("date_object")
+
+    class Meta:
+        model = RiskCheck

wbcompliance/factories/risk_management/incidents.py

@@ -0,0 +1,84 @@
+from datetime import timedelta
+
+import factory
+from faker import Faker
+from psycopg.types.range import DateRange
+from wbcompliance.models.risk_management import (
+    CheckedObjectIncidentRelationship,
+    RiskIncident,
+    RiskIncidentType,
+)
+
+from .checks import RiskCheckFactory
+from .rules import RuleCheckedObjectRelationshipFactory
+
+fake = Faker()
+
+
+def _generate_date_range():
+    d1 = fake.date_object()
+    return DateRange(lower=d1, upper=d1 + timedelta(days=fake.pyint(min_value=1, max_value=100)))
+
+
+def _extract_date_range_from_incident(incident):
+    return fake.date_between_dates(incident.date_range.lower, incident.date_range.upper)
+
+
+class RiskIncidentMixinFactory:
+    status = RiskIncident.Status.OPEN.value
+    comment = factory.Faker("paragraph")
+    resolved_by = factory.SubFactory("wbcore.contrib.authentication.factories.AuthenticatedPersonFactory")
+
+
+def get_severity_order(o):
+    types = RiskIncidentType.objects.all()
+    if types.exists():
+        return types.last().severity_order + 1
+    return 0
+
+
+def _get_severity(o):
+    if o.rule.thresholds.exists():
+        return o.rule.thresholds.first().severity
+    return RiskIncidentTypeFactory.create()
+
+
+class RiskIncidentTypeFactory(factory.django.DjangoModelFactory):
+    name = "LOW"
+    severity_order = factory.LazyAttribute(lambda o: get_severity_order(o))
+    is_ignorable = True
+    is_automatically_closed = False
+    is_informational = False
+
+    class Meta:
+        model = RiskIncidentType
+
+
+class RiskIncidentFactory(RiskIncidentMixinFactory, factory.django.DjangoModelFactory):
+    rule = factory.SubFactory("wbcompliance.factories.risk_management.rules.RiskRuleFactory")
+    severity = factory.LazyAttribute(lambda x: x.rule.thresholds.first().severity)
+    date_range = factory.LazyAttribute(lambda o: _generate_date_range())
+
+    breached_content_type = None
+    breached_object_id = None
+    breached_object_repr = factory.Faker("text", max_nb_chars=32)
+
+    class Meta:
+        model = RiskIncident
+
+
+def _create_risk_check(incident):
+    rel = RuleCheckedObjectRelationshipFactory.create(rule=incident.rule)
+    return RiskCheckFactory.create(rule_checked_object_relationship=rel)
+
+
+class CheckedObjectIncidentRelationshipFactory(RiskIncidentMixinFactory, factory.django.DjangoModelFactory):
+    severity = factory.LazyAttribute(lambda x: x.incident.rule.thresholds.first().severity)
+    rule_check = factory.LazyAttribute(lambda x: _create_risk_check(x.incident))
+    incident = factory.SubFactory("wbcompliance.factories.risk_management.incidents.RiskIncidentFactory")
+    # rule_check = factory.SubFactory("wbcompliance.factories.risk_management.checks.RiskCheckFactory")
+    report = factory.Faker("paragraph")
+    report_details = factory.LazyAttribute(lambda x: dict(a="b"))
+
+    class Meta:
+        model = CheckedObjectIncidentRelationship

wbcompliance/factories/risk_management/rules.py

@@ -0,0 +1,100 @@
+import json
+import random
+from datetime import date
+
+import factory
+from django.contrib.auth import get_user_model
+from django.contrib.contenttypes.models import ContentType
+from django.core.serializers.json import DjangoJSONEncoder
+from faker import Faker
+from guardian.utils import get_anonymous_user
+from psycopg.types.range import NumericRange
+from wbcompliance.models.risk_management.rules import (
+    RiskRule,
+    RuleBackend,
+    RuleCheckedObjectRelationship,
+    RuleThreshold,
+)
+from wbcore.contrib.authentication.factories import UserFactory
+
+fake = Faker()
+
+
+class RuleBackendFactory(factory.django.DjangoModelFactory):
+    name = factory.Faker("name")
+    backend_class_path = "wbcompliance.factories.risk_management.backends"
+    backend_class_name = "RuleBackend"
+    allowed_checked_object_content_type = None
+
+    class Meta:
+        model = RuleBackend
+
+
+def _get_default_parameter():
+    return json.loads(
+        json.dumps(
+            {
+                "date": fake.date_object(),
+                "name": fake.name(),
+                "int": fake.pyint(),
+                "anonymous_user": get_anonymous_user().id,
+            },
+            cls=DjangoJSONEncoder,
+        )
+    )
+
+
+class RiskRuleFactory(factory.django.DjangoModelFactory):
+    name = factory.Faker("name")
+    description = factory.Faker("paragraph")
+    rule_backend = factory.SubFactory("wbcompliance.factories.risk_management.RuleBackendFactory")
+    is_enable = True
+    only_passive_check_allowed = True
+    is_silent = False
+    is_mandatory = True
+    automatically_close_incident = False
+    parameters = factory.LazyAttribute(lambda x: _get_default_parameter())
+    activation_date = date.min
+
+    @factory.post_generation
+    def threshold(self, create, extracted, **kwargs):
+        if not RuleThreshold.objects.filter(rule=self).exists():
+            RuleThresholdFactory.create(rule=self, notifiable_users=[UserFactory.create().profile])
+
+    class Meta:
+        model = RiskRule
+
+
+class RuleThresholdFactory(factory.django.DjangoModelFactory):
+    rule = factory.SubFactory("wbcompliance.factories.risk_management.RiskRuleFactory")
+    range = factory.LazyAttribute(lambda o: NumericRange(lower=random.uniform(0, 0.5), upper=random.uniform(0.5, 1)))
+    severity = factory.SubFactory("wbcompliance.factories.risk_management.incidents.RiskIncidentTypeFactory")
+
+    @factory.post_generation
+    def notifiable_users(self, create, extracted, **kwargs):
+        if not create:
+            return
+        if extracted:
+            for person in extracted:
+                self.notifiable_users.add(person)
+
+    @factory.post_generation
+    def notifiable_groups(self, create, extracted, **kwargs):
+        if not create:
+            return
+        if extracted:
+            for group in extracted:
+                self.notifiable_groups.add(group)
+
+    class Meta:
+        model = RuleThreshold
+
+
+class RuleCheckedObjectRelationshipFactory(factory.django.DjangoModelFactory):
+    rule = factory.SubFactory("wbcompliance.factories.risk_management.RiskRuleFactory")
+    checked_object_content_type = factory.LazyAttribute(lambda o: ContentType.objects.get_for_model(get_user_model()))
+    checked_object_id = 1
+
+    class Meta:
+        model = RuleCheckedObjectRelationship
+        django_get_or_create = ["rule", "checked_object_content_type", "checked_object_id"]

wbcompliance/filters/__init__.py

@@ -0,0 +1,2 @@
+from .compliances import *
+from .risk_management import *

wbcompliance/filters/compliances.py

@@ -0,0 +1,189 @@
+from django.db.models import Max, Q
+from django.utils.translation import gettext_lazy as _
+from wbcompliance.models import (
+    ComplianceAction,
+    ComplianceEvent,
+    ComplianceForm,
+    ComplianceFormSignature,
+    ComplianceTask,
+    ComplianceTaskGroup,
+    ComplianceTaskInstance,
+    ComplianceType,
+    ReviewComplianceTask,
+)
+from wbcore import filters as wb_filters
+
+
+class ComplianceFormFilter(wb_filters.FilterSet):
+    is_signed = wb_filters.BooleanFilter(label=_("Is Signed"), required=False)
+
+    class Meta:
+        model = ComplianceForm
+        fields = {
+            "form_type": ["exact"],
+            "compliance_type": ["exact"],
+            "title": ["exact", "icontains"],
+            "creator": ["exact"],
+            "changer": ["exact"],
+            "version": ["exact"],
+            "status": ["exact"],
+            "start": ["gte", "lte"],
+            "end": ["gte", "lte"],
+        }
+
+
+class ComplianceFormSignatureFilter(wb_filters.FilterSet):
+    is_signed = wb_filters.BooleanFilter(label=_("Is Signed"), required=False)
+    last_version = wb_filters.BooleanFilter(
+        label=_("Last version"), default=True, required=False, method="filter_version"
+    )
+    # compliance_form = wb_filters.ModelChoiceFilter(
+    #     label=_("Compliance Form"),
+    #     queryset=ComplianceForm.objects.filter(status=ComplianceForm.Status.ACTIVE),
+    #     endpoint=ComplianceForm.get_representation_endpoint(),
+    #     value_key=ComplianceForm.get_representation_value_key(),
+    #     label_key = ComplianceForm.get_representation_label_key(),
+    #     method="filter_compliance_form"
+    # )
+    # def filter_compliance_form(self, queryset, name, value):
+    #     return queryset.filter(status=ComplianceForm.Status.ACTIVE)
+
+    class Meta:
+        model = ComplianceFormSignature
+        fields = {
+            "person": ["exact"],
+            "signed": ["gte", "lte"],
+            "version": ["exact"],
+            "compliance_form": ["exact"],
+        }
+
+    def filter_version(self, queryset, name, value):
+        if value:
+            max_compliance_forms = queryset.values("compliance_form").annotate(max_version=Max("version")).order_by()
+            q_statement = Q()
+            for max_compliance_form in max_compliance_forms:
+                q_statement |= Q(compliance_form__exact=max_compliance_form["compliance_form"]) & Q(
+                    version=max_compliance_form["max_version"]
+                )
+            return queryset.filter(q_statement)
+
+        return queryset
+
+
+class ComplianceTypeFilter(wb_filters.FilterSet):
+    class Meta:
+        model = ComplianceType
+        fields = {
+            "name": ["exact", "icontains"],
+        }
+
+
+class ComplianceTaskGroupFilter(wb_filters.FilterSet):
+    class Meta:
+        model = ComplianceTaskGroup
+        fields = {
+            "name": ["exact", "icontains"],
+        }
+
+
+class ComplianceTaskReviewFilter(wb_filters.FilterSet):
+    class Meta:
+        model = ComplianceTask
+        fields = {
+            "title": ["exact", "icontains"],
+            "occurrence": ["exact"],
+            "active": ["exact"],
+            "type": ["exact"],
+            "group": ["exact"],
+            "risk_level": ["exact"],
+        }
+
+
+class ComplianceTaskFilter(ComplianceTaskReviewFilter):
+    is_recurring = wb_filters.BooleanFilter(
+        label=_("Is Recurring"), required=False, default=True, method="filter_occurrence"
+    )
+    active = wb_filters.BooleanFilter(label=_("Active"), required=False, default=True)
+
+    def filter_occurrence(self, queryset, name, value):
+        if value is not None:
+            if value:
+                return queryset.filter(~Q(occurrence=ComplianceTask.Occurrence.NEVER))
+            else:
+                return queryset.filter(occurrence=ComplianceTask.Occurrence.NEVER)
+        return queryset
+
+
+class ComplianceTaskInstanceFilter(wb_filters.FilterSet):
+    type_name = wb_filters.CharFilter(label=_("Administrator"), lookup_expr="icontains")
+    group_name = wb_filters.CharFilter(label=_("Group"), lookup_expr="icontains")
+
+    class Meta:
+        model = ComplianceTaskInstance
+        fields = {"task": ["exact"], "occured": ["lte", "gte"], "status": ["exact"], "review": ["exact"]}
+
+
+class ComplianceTaskMatrixFilter(wb_filters.FilterSet):
+    type_name = wb_filters.CharFilter(label=_("Administrator"), lookup_expr="icontains")
+    group_name = wb_filters.CharFilter(label=_("Group"), lookup_expr="icontains")
+    task_title = wb_filters.CharFilter(label=_("Tasks"), lookup_expr="icontains")
+
+    class Meta:
+        model = ComplianceTaskInstance
+        fields = {}
+
+
+class ComplianceActionFilter(wb_filters.FilterSet):
+    active = wb_filters.BooleanFilter(label=_("Active"), required=False, default=True)
+
+    class Meta:
+        model = ComplianceAction
+        fields = {
+            "title": ["exact", "icontains"],
+            "deadline": ["exact"],
+            "progress": ["exact"],
+            "status": ["exact"],
+            "active": ["exact"],
+            "type": ["exact"],
+            "creator": ["exact"],
+            "changer": ["exact"],
+            "last_modified": ["lte", "gte"],
+        }
+
+
+class ComplianceEventFilter(wb_filters.FilterSet):
+    active = wb_filters.BooleanFilter(label=_("Active"), required=False, default=True)
+
+    class Meta:
+        model = ComplianceEvent
+        fields = {
+            "title": ["exact", "icontains"],
+            "type": ["exact"],
+            "level": ["exact"],
+            "active": ["exact"],
+            "type_event": ["exact"],
+            "creator": ["exact"],
+            "last_modified": ["lte", "gte"],
+            "confidential": ["exact"],
+        }
+
+
+class ReviewComplianceTaskFilter(wb_filters.FilterSet):
+    is_instance = wb_filters.BooleanFilter(label=_("Is occurrence"), default=True, required=False)
+
+    class Meta:
+        model = ReviewComplianceTask
+        fields = {
+            "year": ["exact"],
+            "from_date": ["lte", "gte"],
+            "to_date": ["lte", "gte"],
+            "title": ["exact", "icontains"],
+            "is_instance": ["exact"],
+            "status": ["exact"],
+            "changer": ["exact"],
+            "changed": ["lte", "gte"],
+            "occured": ["lte", "gte"],
+            "review_task": ["exact"],
+            "occurrence": ["exact"],
+            "type": ["exact"],
+        }

wbcompliance/filters/risk_management/__init__.py

@@ -0,0 +1,3 @@
+from .incidents import CheckedObjectIncidentRelationshipFilterSet, RiskIncidentFilterSet
+from .rules import RiskRuleFilterSet
+from .tables import RiskManagementIncidentFilter

wbcompliance/filters/risk_management/checks.py

@@ -0,0 +1,22 @@
+from wbcompliance.models.risk_management import RiskCheck
+from wbcore import filters as wb_filters
+
+
+class RiskCheckFilterSet(wb_filters.FilterSet):
+    triggers = wb_filters.MultipleChoiceContentTypeFilter(
+        label="Triggerers",
+        field_name="triggers",
+        object_id_label="trigger_id",
+        content_type_label="trigger_content_type",
+        distinct=True,
+    )
+
+    class Meta:
+        model = RiskCheck
+
+        fields = {
+            "rule_checked_object_relationship": ["exact"],
+            "creation_datetime": ["gte", "exact", "lte"],
+            "evaluation_date": ["exact"],
+            "status": ["exact"],
+        }

wbcompliance/filters/risk_management/incidents.py

@@ -0,0 +1,113 @@
+from django.db.models import Q
+from django.utils.translation import gettext_lazy as _
+from wbcompliance.models.risk_management import (
+    CheckedObjectIncidentRelationship,
+    RiskIncident,
+    RiskIncidentType,
+    RiskRule,
+    RuleCheckedObjectRelationship,
+)
+from wbcompliance.models.risk_management.rules import RuleGroup
+from wbcore import filters as wb_filters
+
+
+def get_default_severity(*args, **kwargs):
+    non_informational_qs = RiskIncidentType.objects.exclude(is_informational=True)
+    if non_informational_qs.exists():
+        return list(non_informational_qs.values_list("id", flat=True))
+    return []
+
+
+class RiskIncidentFilterSet(wb_filters.FilterSet):
+    date_range = wb_filters.DateRangeFilter(label="Date Range")
+    status = wb_filters.ChoiceFilter(
+        default=RiskIncident.Status.OPEN, choices=RiskIncident.Status.choices, label=_("Label")
+    )
+    rule = wb_filters.ModelMultipleChoiceFilter(
+        label=_("Rule"),
+        queryset=RiskRule.objects.all(),
+        endpoint=RiskRule.get_representation_endpoint(),
+        value_key=RiskRule.get_representation_value_key(),
+        label_key=RiskRule.get_representation_label_key(),
+    )
+
+    severity = wb_filters.ModelMultipleChoiceFilter(
+        label=_("Severity"),
+        queryset=RiskIncidentType.objects.all(),
+        endpoint=RiskIncidentType.get_representation_endpoint(),
+        value_key=RiskIncidentType.get_representation_value_key(),
+        label_key=RiskIncidentType.get_representation_label_key(),
+        default=get_default_severity,
+    )
+    checked_object_relationships = wb_filters.MultipleChoiceContentTypeFilter(
+        label="Checked Objects",
+        field_name="checked_object_relationships",
+        object_id_label="checked_object_relationships__rule_check__rule_checked_object_relationship__checked_object_id",
+        content_type_label="checked_object_relationships__rule_check__rule_checked_object_relationship__checked_object_content_type",
+        distinct=True,
+        hidden=True,
+    )
+
+    rule_checked_object_relationship = wb_filters.ModelChoiceFilter(
+        label=_("Rule Relationship"),
+        queryset=RuleCheckedObjectRelationship.objects.all(),
+        endpoint=RuleCheckedObjectRelationship.get_representation_endpoint(),
+        value_key=RuleCheckedObjectRelationship.get_representation_value_key(),
+        label_key=RuleCheckedObjectRelationship.get_representation_label_key(),
+        hidden=True,
+        method="filter_rule_checked_object_relationship",
+    )
+    object_repr = wb_filters.CharFilter(label="Object Representation", lookup_expr="icontains")
+
+    def filter_rule_checked_object_relationship(self, queryset, label, value):
+        if value:
+            return queryset.filter(checked_object_relationships__rule_check__rule_checked_object_relationship=value)
+        return queryset
+
+    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__rule_backend__rule_group=value) | Q(rule__rule_backend__rule_group__isnull=True)
+            )
+        return queryset
+
+    class Meta:
+        model = RiskIncident
+        fields = {
+            "status": ["exact"],
+            "resolved_by": ["exact"],
+            "comment": ["icontains"],
+            "severity": ["exact"],
+        }
+
+
+class CheckedObjectIncidentRelationshipFilterSet(wb_filters.FilterSet):
+    checked_object = wb_filters.CharFilter(
+        method="filter_checked_object", field_name="checked_object", lookup_expr="icontains"
+    )
+
+    def filter_checked_object(self, queryset, label, value):
+        if value:
+            return queryset.filter(rule_check__rule_checked_object_relationship__checked_object_repr__icontains=value)
+        return queryset
+
+    class Meta:
+        model = CheckedObjectIncidentRelationship
+        fields = {
+            "severity": ["exact"],
+            "report": ["icontains"],
+            "comment": ["icontains"],
+            "resolved_by": ["exact"],
+            "incident": ["exact"],
+            "rule_check": ["exact"],
+            "status": ["exact"],
+        }