wbcore 2.2.1__py2.py3-none-any.whl

wbcore/contrib/workflow/workflows/__init__.py

@@ -0,0 +1 @@
+from .assignees import *

wbcore/contrib/workflow/workflows/assignees.py

@@ -0,0 +1,82 @@
+from random import choices, randint
+
+from django.utils.translation import gettext as _
+from wbcore.contrib.authentication.models import User
+from wbcore.contrib.workflow.models import ProcessStep
+
+from ..decorators import register_assignee
+
+# We need to migrate upon name changes!
+
+
+@register_assignee("Instance Assignee's Manager")
+def manager_of_instance_assignee(process_step: ProcessStep, **kwargs) -> User | None:
+    if (
+        (assignee_field := kwargs.get("assignee_field"))
+        and (assignee_type := kwargs.get("assignee_type"))
+        and hasattr(process_step.process.instance, assignee_field)
+    ):
+        assignee = getattr(process_step.process.instance, assignee_field)
+        if assignee_type == "employee":
+            for manager in assignee.get_managers():
+                if hasattr(manager, "user_account") and manager.user_account.is_active:
+                    return manager.user_account
+        elif assignee_type == "entry":
+            for manager in assignee.relationship_managers.all():
+                if hasattr(manager, "user_account") and manager.user_account.is_active:
+                    return manager.user_account
+
+    process_step.step.get_casted_step().set_failed(
+        process_step, _("Error in assignee method: Incorrect input in kwargs field!")
+    )
+    return None
+
+
+@register_assignee("Weighted Random Group Member")
+def weighted_random(process_step: ProcessStep, **kwargs) -> User | None:
+    if (group := process_step.group) and (group_user_count := group.user_set.count()):
+        similar_process_steps_selected_assignees: list[str] = list(
+            ProcessStep.objects.filter(
+                state__in=[ProcessStep.StepState.FINISHED, ProcessStep.StepState.ACTIVE],
+                process=process_step.process,
+                group=group,
+                assignee__isnull=False,
+                step__step_type="UserStep",
+            )
+            .exclude(id=process_step.id)
+            .values_list("assignee", flat=True)
+        )
+        group_member_list: list[User] = list(group.user_set.all())
+        number_of_past_assignee_occurrences: list[int] = [
+            similar_process_steps_selected_assignees.count(x.pk) for x in group_member_list
+        ]
+
+        if sum(number_of_past_assignee_occurrences):
+            # We redistribute each occurrence number between all of the other list items to increase their probability
+            redistributed_list: list[int] = [0 for i in range(group_user_count)]
+            for index, elem in enumerate(number_of_past_assignee_occurrences):
+                for index2, elem2 in enumerate(redistributed_list):
+                    if not index2 == index:
+                        redistributed_list[index2] += elem / (group_user_count - 1) if elem else 0
+            # Transform the list of absolute values into percentages
+            new_weights: list[float] = [x / sum(redistributed_list) for x in redistributed_list]
+            new_assignee: User = choices(group_member_list, weights=new_weights)[0]
+        else:
+            new_assignee: User = choices(group_member_list)[0]
+        return new_assignee
+
+    process_step.step.get_casted_step().set_failed(
+        process_step, _("Error in assignee method: No populated group to pick assignee from selected!")
+    )
+    return None
+
+
+@register_assignee("Random Group Member")
+def random_group_member(process_step: ProcessStep, **kwargs) -> User | None:
+    if (group := process_step.group) and group.user_set.exists():
+        return group.user_set.all()[randint(0, group.user_set.count() - 1)]
+
+    process_step.step.get_casted_step().set_failed(
+        process_step, _("Error in assignee method: No populated group to pick assignee from selected!")
+    )
+    return None

wbcore/crontab/serializers.py

@@ -0,0 +1,23 @@
+from django_celery_beat.models import CrontabSchedule
+from wbcore import serializers
+
+
+class CrontabScheduleRepresentationSerializer(serializers.RepresentationSerializer):
+    endpoint = "wbcore:crontabschedulerepresentation-list"
+    value_key = "id"
+
+    human_readable = serializers.SerializerMethodField()
+    obj_str = serializers.SerializerMethodField()
+
+    def get_obj_str(self, obj):
+        return str(obj)
+
+    def get_human_readable(self, obj):
+        return obj.human_readable
+
+    def __init__(self, *args, label_key="{{human_readable}} [ {{obj_str}} ]", **kwargs):
+        super().__init__(*args, label_key=label_key, **kwargs)
+
+    class Meta:
+        model = CrontabSchedule
+        fields = ("id", "month_of_year", "day_of_month", "day_of_week", "hour", "minute", "human_readable", "obj_str")

wbcore/crontab/viewsets.py

@@ -0,0 +1,9 @@
+from django_celery_beat.models import CrontabSchedule
+from wbcore import viewsets
+
+from .serializers import CrontabScheduleRepresentationSerializer
+
+
+class CrontabScheduleRepresentationViewSet(viewsets.RepresentationViewSet):
+    queryset = CrontabSchedule.objects.all()
+    serializer_class = CrontabScheduleRepresentationSerializer

wbcore/dispatch.py

@@ -0,0 +1,55 @@
+from django.apps import apps
+from wbcore.utils.itertools import get_inheriting_subclasses
+
+
+def receiver_all_subclasses(signal, sender, *args, **kwargs):
+    def _decorator(func):
+        signal.connect(func, *args, sender=sender, dispatch_uid=func.__name__ + "_" + sender.__name__, **kwargs)
+        for subclass in sender.__subclasses__():
+            signal.connect(
+                func, *args, sender=subclass, dispatch_uid=func.__name__ + "_" + subclass.__name__, **kwargs
+            )
+
+        return func
+
+    return _decorator
+
+
+def receiver_subclasses(signal, sender, *args, only_leaf=True, **kwargs):
+    """
+    A decorator for connecting receivers and all receiver's subclasses to signals. Used by passing in the
+    signal and keyword arguments to connect::
+    The signal needs to be registered after all child models are registered (e.g. by placing the signal in a dedicated
+    signal file)
+        @receiver_subclasses(post_save, sender=MyModel)
+        def signal_receiver(sender, **kwargs):
+            ...
+    """
+
+    def _decorator(func):
+        if isinstance(sender, str):
+            sender_class = apps.get_model(sender)
+        else:
+            sender_class = sender
+        for snd in get_inheriting_subclasses(sender_class, only_leaf=only_leaf):
+            signal.connect(func, *args, sender=snd, dispatch_uid=func.__name__ + "_" + snd.__name__, **kwargs)
+        return func
+
+    return _decorator
+
+
+def receiver_inherited_through_models(signal, sender, through_field_name, **kwargs):
+    """
+    A decorator for connecting receivers and all subclasses's through model'.
+    """
+
+    def _decorator(func):
+        for sub_class in sender.__subclasses__():
+            if (through_field := getattr(sub_class, through_field_name, None)) and (
+                through_class := getattr(through_field, "through", None)
+            ):
+                signal.connect(
+                    func, sender=through_class, dispatch_uid=func.__name__ + "_" + through_class.__name__, **kwargs
+                )
+
+    return _decorator

wbcore/docs/__init__.py

@@ -0,0 +1,25 @@
+import markdown
+from django.conf import settings
+from markdown.extensions.tables import TableExtension
+from markdown_blockdiag import BlockdiagExtension
+from rest_framework.response import Response
+
+
+def get_markdown_docs(docs):
+    try:
+        with open(docs, "r") as f:
+            return Response(
+                markdown.markdown(
+                    f.read(),
+                    extensions=settings.WBCORE_DEFAULT_MARKDOWN_EXTENSIONS,
+                )
+            )
+    except FileNotFoundError:
+        return Response(
+            markdown.markdown(
+                docs,
+                extensions=settings.WBCORE_DEFAULT_MARKDOWN_EXTENSIONS,
+            )
+        )
+    except AttributeError:
+        return Response({"errors": "No documentation available."})

wbcore/docs/orderable.md

@@ -0,0 +1,29 @@
+# Orderable View
+
+An orderable view enables the user to freely reorder rows inside AG Grid by drag-and-drop.
+
+**NOTE**: As these changes are saved in a model field, this will change the order globally for each user! Reordering on a per-user basis requires a way more sophisticated approach that is currently out of scope. Please also keep in mind that this also means that different orders for different views of the same model are not possible.
+
+## Implementation Steps
+
+### Simple Reordering
+
+Reorder rows inside a basic list view. Also includes the first level of tree views (level 0).
+
+1. Add the `OrderableModel` from `wbcore.models.orderable` to your model and migrate. Set initial values for existing instances by either `Model.orderable_objects.reset_order()` or calling `save()` on every object.
+2. Add the `order` field to your serializer.
+3. Add the `OrderableMixin` from `wbcore.viewsets.mixins` to your viewset. If you have defined a viewset ordering, make sure to first order by `order`.
+4. Add both `reorderable_column="order"` and `reorderable_endpoint=reverse(f"{endpoint.basename}-reorder", args=["{{id}}"], request=self.request)` to your list display.
+
+### Tree Child Reordering
+
+We currently only support reordering the first child row (i.e. level 1).
+
+1. Add the `OrderableModel` from `wbcore.models.orderable` to your model and migrate. Also add the class variable `PARTITION_BY` to your class and set it to the name of the foreign key field to the child's parent to partition the order values based on the parent. In this case the order number is unique only for the parent and not over the entire model anymore. Set initial values for existing instances by either `Model.orderable_objects.reset_order()` or calling `save()` on every object.
+2. Add the `order` field to your serializer.
+3. Add the `OrderableMixin` from `wbcore.viewsets.mixins` to your viewset. If you have defined a viewset ordering, make sure to first order by `order`.
+4. Add both `tree_reorderable_column="order"` and `tree_reorderable_endpoint=reverse(f"{endpoint.basename}-reorder", args=["{{id}}"], request=self.request)` to **the parent's** list display.
+
+## Example
+
+For an example please take a look at _example_app/team_. In this case we wanted both level 0 (Team) and level 1 (Player) to be reorderable so this example incorporates both a simple reordering for the parent level and a tree child reordering for the child level.

wbcore/docs/reparent.md

@@ -0,0 +1,13 @@
+# Reparent View
+
+A reparent view enables the user to switch a child's parent object inside a tree view by drag-and-dropping the child inside the new parent. Please note that this is currently only supported with level 1 children inside the tree view.
+
+## Implementation Steps
+
+1. Add a `PARENT_FK` class variable to the child's model and set it to the field name of the foreign key to the parent.
+2. Add the `ReparentMixin` from `wbcore.viewsets.mixins` to your viewset.
+3. Add both `tree_reparent_pk_field=f"{pk_field_name}"` and `tree_reparent_endpoint=reverse(f"{endpoint.basename}-reparent", args=["{{id}}"], request=self.request)` to the parent's list display.
+
+## Example
+
+For an example please take a look at _example_app/team_. Drag-and-dropping a child (Player) inside a new parent (Team) will transfer this player to a new team.

wbcore/dynamic_preferences_registry.py

@@ -0,0 +1,29 @@
+from django.utils.translation import gettext as _
+from dynamic_preferences.preferences import Section
+from dynamic_preferences.registries import global_preferences_registry
+from dynamic_preferences.types import IntegerPreference, StringPreference
+
+wbcore = Section("wbcore")
+
+
+@global_preferences_registry.register
+class RetentionPeriod(IntegerPreference):
+    section = wbcore
+    name = "retention_period"
+    default = 365
+
+    verbose_name = _("Retention Period in Days")
+    help_text = _(
+        "When an object cannot be deleted and is disabled instead, it gets hidden from the queryset but not deleted. For compliance reasons we enable the retention for a specific period of days (defaults to a year)"
+    )
+
+
+@global_preferences_registry.register
+class SystemUserEmailPeriod(StringPreference):
+    section = wbcore
+    name = "system_user_email"
+
+    default = "system@stainly-bench.com"
+
+    verbose_name = _("System User Email")
+    help_text = _("System User Email")

wbcore/enums.py

@@ -0,0 +1,98 @@
+from enum import Enum
+from typing import Union
+
+
+class RequestType(Enum):
+    GET = "get"
+    POST = "post"
+    DELETE = "delete"
+    PATCH = "patch"
+    PUT = "put"
+    OPTIONS = "options"
+    HEAD = "head"
+
+
+class Button(Enum):
+    # Buttons
+    REFRESH = "refresh"
+    NEW = "new"
+    DELETE = "delete"
+
+    # Buttons and Create Buttons
+    SAVE = "save"
+    SAVE_AND_CLOSE = "saveandclose"
+    SAVE_AND_NEW = "saveandnew"
+
+    # Create Buttons
+    RESET = "reset"
+
+    # Custom Buttons
+    DROPDOWN = "dropdown"
+    HYPERLINK = "hyperlink"
+    WIDGET = "widget"
+    ACTION = "action"
+
+    @classmethod
+    def buttons(cls):
+        return [
+            cls.REFRESH.value,
+            cls.NEW.value,
+            cls.DELETE.value,
+            cls.SAVE.value,
+            cls.SAVE_AND_CLOSE.value,
+            cls.SAVE_AND_NEW.value,
+        ]
+
+    @classmethod
+    def create_buttons(cls):
+        return [
+            cls.SAVE.value,
+            cls.SAVE_AND_CLOSE.value,
+            cls.SAVE_AND_NEW.value,
+            cls.RESET.value,
+        ]
+
+    @classmethod
+    def custom_buttons(cls):
+        return [
+            cls.DROPDOWN.value,
+            cls.HYPERLINK.value,
+            cls.WIDGET.value,
+            cls.ACTION.value,
+        ]
+
+
+class WidgetType(Enum):
+    LIST = "list"
+    INSTANCE = "instance"
+    CHART = "chart"
+    SELECT = "select"
+
+
+class Operator(Enum):
+    EQUAL = "=="
+    UNEQUAL = "!="
+    GREATER = ">"
+    GREATER_EQUAL = ">="
+    LESS = "<"
+    LESS_EQUAL = "<="
+    EXISTS = "∃"
+
+
+class Unit(Enum):
+    FRACTION = "fr"
+    REM = "rem"
+    PIXEL = "px"
+
+    def __call__(self, _value):
+        return (float(_value), self.value)
+
+    def unit(self, _value: Union[float, str, int]):
+        assert isinstance(_value, (float, str, int)), "_value needs to be one of str, float or int"
+
+        return f"{float(_value)}{self.value}"
+
+
+class AuthType(Enum):
+    NONE = "NONE"
+    JWT = "JWT"

wbcore/filters/__init__.py

@@ -0,0 +1,21 @@
+from .backends import DjangoFilterBackend
+from .fields import (
+    BooleanFilter,
+    CharFilter,
+    ChoiceFilter,
+    DateFilter,
+    DateRangeFilter,
+    FinancialPerformanceDateRangeFilter,
+    DateTimeFilter,
+    DateTimeRangeFilter,
+    ModelChoiceFilter,
+    ModelMultipleChoiceFilter,
+    MultipleChoiceContentTypeFilter,
+    MultipleChoiceFilter,
+    NumberFilter,
+    YearFilter,
+    RangeSelectFilter,
+    TimeFilter,
+    MultipleLookupFilter,
+)
+from .filterset import FilterSet

wbcore/filters/backends.py

@@ -0,0 +1,19 @@
+from django_filters.rest_framework import DjangoFilterBackend as StandardFilterBackend
+
+from .filterset import FilterSet
+
+
+class DjangoFilterBackend(StandardFilterBackend):
+    filterset_base = FilterSet
+
+    def get_filterset_kwargs(self, request, queryset, view):
+        return {"data": request.query_params, "queryset": queryset, "request": request, "view": view}
+
+    def get_filterset_class(self, view, queryset=None):
+        if method := getattr(view, "get_filterset_class", None):
+            view.filterset_class = method(view.request)
+
+        if method := getattr(view, "get_filterset_fields", None):
+            view.filterset_fields = method(view.request)
+
+        return super().get_filterset_class(view, queryset)

wbcore/filters/defaults.py

@@ -0,0 +1,69 @@
+from calendar import monthrange
+from datetime import date, timedelta
+
+from django.utils.timezone import localdate
+from psycopg.types.range import DateRange
+from rest_framework.exceptions import APIException
+from wbcore.utils.date import get_end_date_from_date, get_start_date_from_date
+
+
+def current_quarter_date_start(*args, **kwargs):
+    return get_start_date_from_date(localdate())
+
+
+def current_quarter_date_end(*args, **kwargs):
+    return get_end_date_from_date(localdate())
+
+
+def current_quarter_date_range(*args, **kwargs):
+    return DateRange(current_quarter_date_start(*args, **kwargs), current_quarter_date_end(*args, **kwargs))
+
+
+def current_month_date_start(*args, **kwargs):
+    today = date.today()
+    return date(today.year, today.month, 1)
+
+
+def current_month_date_end(*args, **kwargs):
+    today = date.today()
+    return date(today.year, today.month, monthrange(today.year, today.month)[1])
+
+
+def current_month_date_range(*args, **kwargs):
+    return DateRange(current_month_date_start(*args, **kwargs), current_month_date_end(*args, **kwargs))
+
+
+def current_year_date_range(*args, **kwargs):
+    d = localdate()
+    return DateRange(date(d.year, 1, 1), max((date(d.year + 1, 1, 1), d + timedelta(days=60))))
+
+
+def year_to_date_range(*args, **kwargs):
+    d = localdate()
+    return DateRange(d.replace(day=1, month=1), d.today())
+
+
+def n_year_data_range(n: int, *args, **kwargs):
+    d = localdate()
+    return DateRange(d - timedelta(days=n * 365), d)
+
+
+def one_year_date_range(*args, **kwargs):
+    return n_year_data_range(1)
+
+
+def five_year_data_range(*args, **kwargs):
+    return n_year_data_range(5)
+
+
+def current_quarter_date_interval(*args, **kwargs):
+    return (
+        current_quarter_date_start(),
+        current_quarter_date_end(*args, **kwargs),
+    )
+
+
+class RequiredFilterMissing(APIException):
+    status_code = 400
+    default_detail = "Required filters are not available in the query parameters."
+    default_code = "required_filters_missing"

wbcore/filters/fields/__init__.py

@@ -0,0 +1,15 @@
+from .choices import ChoiceFilter, MultipleChoiceField, MultipleChoiceFilter
+from .datetime import (
+    TimeFilter,
+    DateTimeFilter,
+    DateFilter,
+    DateRangeFilter,
+    DateTimeRangeFilter,
+    FinancialPerformanceDateRangeFilter,
+)
+from .models import ModelChoiceFilter, ModelMultipleChoiceFilter
+from .numbers import NumberFilter, YearFilter, RangeSelectFilter
+from .text import CharFilter
+from .booleans import BooleanFilter
+from .content_type import MultipleChoiceContentTypeFilter
+from .multiple_lookups import MultipleLookupFilter

wbcore/filters/fields/booleans.py

@@ -0,0 +1,6 @@
+import django_filters
+from wbcore.filters.mixins import WBCoreFilterMixin
+
+
+class BooleanFilter(WBCoreFilterMixin, django_filters.BooleanFilter):
+    filter_type = "boolean"

wbcore/filters/fields/choices.py

@@ -0,0 +1,61 @@
+import itertools
+from urllib.parse import quote
+
+import django_filters
+from django_filters.filters import MultipleChoiceField
+from wbcore.filters.mixins import WBCoreFilterMixin
+
+
+class WBCoreChoiceFilterMixin(WBCoreFilterMixin):
+    def __init__(self, *args, **kwargs):
+        self.choices = kwargs["choices"]
+        super().__init__(*args, **kwargs)
+
+    def get_representation(self, request, name, view):
+        representation, lookup_expr = super().get_representation(request, name, view)
+        lookup_expr["input_properties"]["choices"] = list()
+        if callable(self.choices):
+            choice_keys = [
+                choice[0] for choice in self.field.choices
+            ]  # we save the choices key for validation in case we narrow down the choices list in get_representation
+            # we get a new choices set but make sure its keys are still valid regarding the initial choices
+            choices = list(filter(lambda x: x[0] in choice_keys, self.choices(request, view)))
+        else:
+            choices = self.choices
+
+        for choice in choices:
+            lookup_expr["input_properties"]["choices"].append(
+                {"value": quote(choice[0]) if isinstance(choice[0], str) else choice[0], "label": choice[1]}
+            )
+        return representation, lookup_expr
+
+
+class ChoiceFilter(WBCoreChoiceFilterMixin, django_filters.ChoiceFilter):
+    filter_type = "select"
+
+
+class WBCoreMultipleChoiceField(MultipleChoiceField):
+    def to_python(self, value):
+        # We do this because DRF wrap a coma seperated list of choices into a one list element
+        if value and isinstance(value, list):
+            value = list(itertools.chain(*[v.split(",") for v in value]))
+        return super().to_python(value)
+
+
+class MultipleChoiceFilter(WBCoreChoiceFilterMixin, django_filters.MultipleChoiceFilter):
+    field_class = WBCoreMultipleChoiceField
+    filter_type = "select"
+
+    def _validate_default_with_request(self, default, request, name):
+        if request_default := request.GET.get(name):
+            return request_default.split(",")
+        return default
+
+    def get_representation(self, request, name, view):
+        representation, lookup_expr = super().get_representation(request, name, view)
+        lookup_expr["input_properties"]["multiple"] = True
+        if (default := lookup_expr["input_properties"].get("default")) and not isinstance(default, list):
+            lookup_expr["input_properties"]["default"] = [default]
+        if (initial := lookup_expr["input_properties"].get("initial")) and not isinstance(initial, list):
+            lookup_expr["input_properties"]["initial"] = [initial]
+        return representation, lookup_expr

wbcore/filters/fields/content_type.py

@@ -0,0 +1,33 @@
+import operator
+from functools import reduce
+
+import django_filters
+from django.contrib.contenttypes.models import ContentType
+from django.db.models import Q
+from django_filters.constants import EMPTY_VALUES
+from wbcore.filters.mixins import WBCoreFilterMixin
+from wbcore.forms import ContentTypeMultiValueField
+
+
+class MultipleChoiceContentTypeFilter(WBCoreFilterMixin, django_filters.Filter):
+    field_class = ContentTypeMultiValueField
+    filter_type = "text"
+
+    def __init__(self, object_id_label="object_id", content_type_label="content_type", **kwargs):
+        self.object_id_label = object_id_label
+        self.content_type_label = content_type_label
+        super().__init__(**kwargs)
+
+    def filter(self, qs, value):
+        if value in EMPTY_VALUES:
+            return qs
+        if self.distinct:
+            qs = qs.distinct()
+        conditions = [
+            (
+                Q(**{self.content_type_label: ContentType.objects.get_for_model(val)})
+                & Q(**{self.object_id_label: val.id})
+            )
+            for val in value
+        ]
+        return qs.filter(reduce(operator.or_, conditions))