wbcore 2.2.1__py2.py3-none-any.whl

wbcore/serializers/fields/mixins.py

@@ -0,0 +1,175 @@
+import logging
+from contextlib import suppress
+from typing import Any, ClassVar, Type
+
+from django.db.models.fields import NOT_PROVIDED
+from rest_framework.fields import empty
+from rest_framework.serializers import Field
+
+logger = logging.getLogger(__name__)
+
+
+def decorator(position: str, value: str, decorator_type: str = "icon") -> dict:
+    assert position in ("left", "right"), "Decorator Position can only be right or left"
+    assert decorator_type in ("icon", "text"), "Decorator Type can only be icon or text"
+    return {"position": position, "value": value, "type": decorator_type}
+
+
+class WBCoreSerializerFieldMixin:
+    """
+    A mixin that takes care of adding all the necessary magic to each implementation
+    of the serializer fields
+    """
+
+    def __init__(
+        self,
+        *args,
+        decorators=None,
+        depends_on=None,
+        math=None,
+        extra=None,
+        read_only=False,
+        copyable=None,
+        related_key=None,
+        **kwargs,
+    ):
+        if not decorators:
+            decorators = list()
+        if not depends_on:
+            depends_on = list()
+        self.extra = extra
+        self.decorators = decorators
+        self.depends_on = depends_on
+        self.math = math
+        self.copyable = copyable
+        # To satisfy DRF assertion, we detect if the readonly given is a callable and in that case, we consider the default read only attribute to be true
+        self._callable_read_only = None
+        if callable(read_only):
+            self._callable_read_only = read_only
+            read_only = True
+        self.related_key = related_key
+        super().__init__(*args, read_only=read_only, **kwargs)
+
+    def _evaluate_read_only(self):
+        if self._callable_read_only:
+            # if view is present, we use it as parameter to the callable, otherwise we assume read_only is True
+            if view := self.view:
+                self.read_only = self._callable_read_only(view)
+            else:
+                self.read_only = True
+
+    def bind(self, field_name, parent):
+        super().bind(field_name, parent)
+        # After binding to the parent happens, we evaluate the callable readonly if given
+        self._evaluate_read_only()
+
+    def get_related_key(self) -> str:
+        return self.related_key or self.source
+
+    @property
+    def view(self):
+        # Helper property to return the stored instantiated view in the context
+        return self.context.get("view", getattr(self.context.get("request"), "parser_context", {}).get("view"))
+
+    def set_attr(self, attr, value):
+        setattr(self, attr, value)
+        self._kwargs[attr] = value
+
+    def append_depend_on(self, depend_on):
+        existing_fields = [elem["field"] for elem in self.depends_on]
+        if depend_on["field"] not in existing_fields:
+            self.depends_on.append(depend_on)
+            self._kwargs["depends_on"] = self.depends_on
+
+    def get_representation(self, request, field_name) -> tuple[str, dict]:
+        if meta := getattr(self.parent, "Meta", None):
+            if field_name in getattr(meta, "required_fields", []):
+                self.required = True
+
+        representation = {
+            "key": field_name,
+            "label": getattr(self, "label", None),
+            "type": getattr(self, "field_type", "undefined"),
+            "required": getattr(self, "required", True),
+            "read_only": getattr(self, "read_only", False),
+        }
+
+        default = getattr(self, "default", None)
+        if default is None or default == empty or default == NOT_PROVIDED:
+            try:
+                default = self.parent.Meta.model._meta._forward_fields_map[field_name].default
+            except Exception:  # TODO Add some explicit exception handling
+                pass
+
+        if default is not None and default != empty and default != NOT_PROVIDED:
+            if callable(default):
+                if getattr(default, "requires_context", False):
+                    default = default(self)
+                else:
+                    default = default()
+            if default is not None:
+                representation["default"] = self.to_representation(default)
+
+        representation["decorators"] = getattr(self, "decorators", [])
+        representation["depends_on"] = getattr(self, "depends_on", [])
+
+        for _attr in ["help_text", "extra"]:
+            attr = getattr(self, _attr, None)
+            if attr:
+                representation[_attr] = attr
+
+        if self.math:
+            representation["math"] = self.math
+        if self.copyable:
+            representation["copyable"] = self.copyable
+        return field_name, representation
+
+    def validate_empty_values(self, data):
+        if isinstance(data, str) and data == "null":
+            data = None
+        return super().validate_empty_values(data)
+
+
+class RangeMixin(WBCoreSerializerFieldMixin, Field):
+    """
+    This mixin represents a range in the form of:
+    (value1,value2)
+
+    When using this mixin, you must supply the internal_field (usually the postgres wrapper) that converts the range tuple to some datastructure.
+    """
+
+    default_error_messages = {
+        "lower_gt_upper": "The upper bound must be greater than the lower bound.",
+    }
+    internal_field: ClassVar[Type]
+
+    def _transform_range(self, lower, upper, inward: bool | None = None):
+        return lower, upper
+
+    def to_internal_value(self, data) -> Any:
+        # If formdata is used, we need to separate the string into the range
+        if isinstance(data, str) and "," in data:
+            data = data.split(",")
+        lower = upper = None
+        if isinstance(data, list):
+            if len(data) > 0 and data[0]:
+                lower = super().to_internal_value(data[0])
+            if len(data) > 1 and data[1]:
+                upper = super().to_internal_value(data[1])
+        lower, upper = self._transform_range(lower, upper, inward=True)
+        if lower and upper and lower >= upper:
+            self.fail("lower_gt_upper")
+        return self.internal_field(lower, upper)
+
+    def to_representation(self, instance):
+        lower, upper = self._transform_range(instance.lower, instance.upper, inward=False)
+        with suppress(Exception):
+            lower = super().to_representation(lower)
+        with suppress(Exception):
+            upper = super().to_representation(upper)
+        return lower, upper
+
+    def get_representation(self, request, field_name) -> tuple[str, dict]:
+        key, representation = super().get_representation(request, field_name)
+        representation["range"] = True
+        return key, representation

wbcore/serializers/fields/number.py

@@ -0,0 +1,103 @@
+from psycopg.types.range import NumericRange
+from rest_framework import serializers
+
+from .mixins import RangeMixin, WBCoreSerializerFieldMixin, decorator
+from .types import DisplayMode, WBCoreType
+
+percent_decorator = decorator(position="right", value="%", decorator_type="text")
+
+
+class NumberFieldMixin:
+    def __init__(
+        self,
+        *args,
+        percent=False,
+        display_mode=DisplayMode.DECIMAL,
+        precision=2,
+        delimiter=",",
+        decimal_mark=".",
+        signed: bool = True,
+        **kwargs,
+    ):
+        super().__init__(*args, **kwargs)
+        self.percent = percent
+        self.delimiter = delimiter
+        self.decimal_mark = decimal_mark
+        if self.delimiter == self.decimal_mark:
+            raise ValueError("Decimal mark and delimiter need to be different character")
+        self.display_mode = display_mode
+        self.precision = kwargs.get("decimal_places", precision)
+        self.max_digits = kwargs.get("max_digits", 34)
+        self.signed = signed
+
+    def set_precision(self, precision):
+        self.precision = precision
+        self._kwargs["precision"] = self.precision
+
+    def set_percent(self, percent):
+        self.percent = percent
+        self._kwargs["percent"] = self.percent
+
+    def get_representation(self, request, field_name) -> tuple[str, dict]:
+        key, representation = super().get_representation(request, field_name)
+        representation["display_mode"] = self.display_mode.value
+        representation["precision"] = self.precision
+        representation["max_digits"] = self.max_digits
+        representation["delimiter"] = self.delimiter
+        representation["decimal_mark"] = self.decimal_mark
+        representation["signed"] = self.signed
+
+        if self.percent:  # TODO: Discuss with Christoph if this is necessary like this
+            representation["type"] = WBCoreType.PERCENT.value
+            representation["precision"] = self.precision - 2
+        return key, representation
+
+
+class IntegerField(NumberFieldMixin, WBCoreSerializerFieldMixin, serializers.IntegerField):
+    field_type = WBCoreType.NUMBER.value
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.precision = 0
+
+
+class YearField(IntegerField):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.delimiter = ""
+        self.decimal_mark = "."
+
+
+class DecimalField(NumberFieldMixin, WBCoreSerializerFieldMixin, serializers.DecimalField):
+    field_type = WBCoreType.NUMBER.value
+
+    # TODO: If this is used, then the validation for max_digits and decimal_fields is not done
+    # def validate_precision(self, value):
+    #     return value
+
+    def get_representation(self, request, field_name) -> tuple[str, dict]:
+        field_name, representation = super().get_representation(request, field_name)
+
+        if meta := getattr(self.parent, "Meta", None):
+            odp = getattr(meta, "override_decimal_places", None)
+            percent_fields = getattr(meta, "percent_fields", [])
+            if odp is not None and field_name not in percent_fields:
+                representation["precision"] = odp
+
+        return field_name, representation
+
+
+class FloatField(NumberFieldMixin, WBCoreSerializerFieldMixin, serializers.FloatField):
+    field_type = WBCoreType.NUMBER.value
+
+
+class DecimalRangeField(RangeMixin, WBCoreSerializerFieldMixin, serializers.DecimalField):
+    field_type = WBCoreType.NUMBER.value
+    internal_field = NumericRange
+
+    def __init__(self, max_digits=None, decimal_places=None, **kwargs):
+        if not max_digits:
+            max_digits = 3
+        if not decimal_places:
+            decimal_places = 2
+        super().__init__(max_digits, decimal_places, **kwargs)

wbcore/serializers/fields/other.py

@@ -0,0 +1,42 @@
+# TODO: Most likely to be removed
+from rest_framework import serializers
+
+from .mixins import WBCoreSerializerFieldMixin
+from .number import IntegerField
+
+
+class StarRatingField(IntegerField):
+    field_type = "starrating"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.delimiter = ""
+        self.decimal_mark = ""
+
+
+class EmojiRatingField(IntegerField):
+    field_type = "emojirating"
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.delimiter = ""
+        self.decimal_mark = ""
+
+
+class RangeSelectField(WBCoreSerializerFieldMixin, serializers.FloatField):
+    field_type = "rangeselect"
+
+    def __init__(self, *args, start: float = 0.0, end: float = 1.0, step_size: float = 0.25, **kwargs):
+        self.color = kwargs.pop("color", "rgb(133, 144, 162)")
+        self.start = start
+        self.end = end
+        self.step_size = step_size
+        super().__init__(*args, **kwargs)
+
+    def get_representation(self, request, field_name) -> tuple[str, dict]:
+        key, representation = super().get_representation(request, field_name)
+        representation["color"] = self.color
+        representation["start"] = self.start
+        representation["end"] = self.end
+        representation["step_size"] = self.step_size
+        return key, representation

wbcore/serializers/fields/primary_key.py

@@ -0,0 +1,22 @@
+from rest_framework import serializers
+
+from .mixins import WBCoreSerializerFieldMixin
+from .types import WBCoreType
+
+
+class PrimaryKeyField(WBCoreSerializerFieldMixin, serializers.IntegerField):
+    field_type = WBCoreType.PRIMARY_KEY.value
+
+    def __init__(self, *args, **kwargs):
+        kwargs["read_only"] = True
+        kwargs["required"] = False
+        super().__init__(*args, **kwargs)
+
+
+class PrimaryKeyCharField(WBCoreSerializerFieldMixin, serializers.CharField):
+    field_type = WBCoreType.PRIMARY_KEY.value
+
+    def __init__(self, *args, **kwargs):
+        kwargs["read_only"] = True
+        kwargs["required"] = False
+        super().__init__(*args, **kwargs)

wbcore/serializers/fields/related.py

@@ -0,0 +1,152 @@
+from contextlib import suppress
+
+from django.core.exceptions import FieldDoesNotExist
+from rest_framework import serializers
+from rest_framework.fields import empty
+from rest_framework.relations import ManyRelatedField, PKOnlyObject
+from rest_framework.request import Request
+
+from .list import ListFieldMixin
+from .mixins import WBCoreSerializerFieldMixin
+from .types import WBCoreType
+
+
+class WBCoreManyRelatedField(ListFieldMixin, WBCoreSerializerFieldMixin, ManyRelatedField):
+    def __init__(self, *args, **kwargs):
+        required = kwargs.get("required", True)
+        if not required:
+            kwargs["allow_null"] = True
+        super().__init__(*args, **kwargs)
+
+    def bind(self, field_name, parent):
+        super().bind(field_name, parent)
+        # The `many=True` parameter on the related field returns this class,
+        # where `children_relation` is directly bound to it. However, the context
+        # processor does not yet have access to the request, so the `view` property
+        # is currently `None`. To handle this, we need to explicitly re-evaluate
+        # the `read_only` property for the `children_relation` when the binding
+        # occurs from the List serializer to this instance.
+        self.child_relation.context["view"] = self.view
+        self.child_relation._evaluate_read_only()
+        if not self.child_relation.read_only and hasattr(self.child_relation, "_queryset"):
+            setattr(self.child_relation, "queryset", self.child_relation._queryset)
+
+    def get_representation(self, request: Request, field_name: str) -> tuple[str, dict]:
+        key, representation = self.child_relation.get_representation(request, field_name)
+        representation["multiple"] = True
+        if not representation.get("label", None) and self.label:
+            representation["label"] = self.label
+        return key, representation
+
+
+class PrimaryKeyRelatedField(WBCoreSerializerFieldMixin, serializers.PrimaryKeyRelatedField):
+    MANY_RELATION_KWARGS = (
+        "read_only",
+        "write_only",
+        "required",
+        "default",
+        "initial",
+        "source",
+        "label",
+        "help_text",
+        "style",
+        "error_messages",
+        "allow_empty",
+        "html_cutoff",
+        "html_cutoff_text",
+        "allow_null",
+    )
+
+    def __init__(self, *args, queryset=None, read_only=False, **kwargs):
+        self.field_type = kwargs.pop("field_type", WBCoreType.SELECT.value)
+        if callable(read_only) and queryset is not None:
+            self._queryset = queryset  # we unset any given queryset to be compliant with the RelatedField assertion
+            queryset = None
+        super().__init__(*args, queryset=queryset, read_only=read_only, **kwargs)
+
+    def __new__(cls, *args, **kwargs):
+        kwargs["style"] = {"base_template": "input.html"}
+        return super().__new__(cls, *args, **kwargs)
+
+    def bind(self, field_name, parent):
+        super().bind(field_name, parent)
+        # In case we had to unset the queryset attribute because read_only was a callable, we reinstate it here.
+        if not self.read_only and hasattr(self, "_queryset"):
+            setattr(self, "queryset", self._queryset)
+
+    @classmethod
+    def many_init(cls, *args, **kwargs):
+        list_kwargs = {"child_relation": cls(*args, **kwargs)}
+        for key in kwargs:
+            if key in cls.MANY_RELATION_KWARGS:
+                list_kwargs[key] = kwargs[key]
+        return WBCoreManyRelatedField(**list_kwargs)
+
+    def run_validation(self, data=empty):
+        if (data is empty) and (view := self.parent.context.get("view", None)):
+            parent_model_id = view.kwargs.get(f"{self.field_name}_id")
+            if parent_model_id:
+                data = parent_model_id
+
+        return super().run_validation(data)
+
+    def get_representation(self, request: Request, field_name: str) -> tuple[str, dict]:
+        key, representation = super().get_representation(request, field_name)
+        if default := representation.get("default", None):
+            if isinstance(default, list):
+                representation["default"] = [getattr(d, "id", d) for d in default]
+            elif id := getattr(default, "id", None):
+                representation["default"] = id
+        return key, representation
+
+    def to_representation(self, value):
+        # In case we annotate the representation, we need to ensure that the value is an object
+        if isinstance(value, (list, tuple, set)):
+            return [self.to_representation(d) for d in value]
+        try:
+            if isinstance(value, str):
+                try:
+                    value = int(value)
+                except ValueError:
+                    value = None
+            if isinstance(value, int):
+                value = PKOnlyObject(value)
+            return super().to_representation(value)
+        except Exception:
+            pass
+        return None
+
+    def get_queryset(self):
+        """
+        Allow queryset to be callable
+        """
+        if callable(self.queryset):
+            self.queryset = self.queryset()
+        qs = super().get_queryset()
+
+        # if limite_choices_to is defined on the model field, we use it to restrict the related queryset
+        with suppress(AttributeError, FieldDoesNotExist):
+            if limit_choices_to := getattr(
+                self.parent.Meta.model._meta.get_field(self.field_name), "_limit_choices_to", None
+            ):
+                if isinstance(limit_choices_to, dict):
+                    qs = qs.filter(**limit_choices_to)
+                else:
+                    qs = qs.filter(limit_choices_to)
+        return qs
+
+
+class ListSerializer(WBCoreSerializerFieldMixin, serializers.ListSerializer):
+    """
+    A Wrapper around the normal DRF ListSerializer which also return the child representation
+    """
+
+    def get_representation(self, request: Request, field_name: str) -> tuple[str, dict]:
+        _, representation = self.child.get_representation(request, field_name)
+        representation["multiple"] = True
+        related_key = self.get_related_key()
+        representation["related_key"] = related_key
+
+        # TODO: improve and don't monkeypatch
+        rv = related_key if "." not in related_key else related_key.replace(".", "__")
+        return rv, representation

wbcore/serializers/fields/text.py

@@ -0,0 +1,136 @@
+import re
+
+from django.core.exceptions import ValidationError
+from django.utils.translation import gettext as _
+from rest_framework import serializers
+from rest_framework.reverse import reverse
+
+from .mixins import WBCoreSerializerFieldMixin
+from .types import ReturnContentType, WBCoreType
+
+
+class CharField(WBCoreSerializerFieldMixin, serializers.CharField):
+    field_type = WBCoreType.TEXT.value
+
+    def __init__(self, *args, **kwargs):
+        self.secure = kwargs.pop("secure", False)
+        self.placeholder = kwargs.pop("placeholder", None)
+        super().__init__(*args, allow_null=kwargs.pop("allow_null", True), **kwargs)
+
+    def get_representation(self, request, field_name) -> tuple[str, dict]:
+        key, representation = super().get_representation(request, field_name)
+
+        if self.placeholder:
+            representation["placeholder"] = self.placeholder
+
+        # Add secure attribute if required
+        if self.secure:
+            representation["secure"] = True
+
+        return key, representation
+
+    def validate_empty_values(self, data):
+        if (self.allow_null or self.allow_blank) and data is None:
+            data = ""
+        return super().validate_empty_values(data)
+
+
+class TelephoneField(CharField):
+    field_type = WBCoreType.TELEPHONE.value
+
+
+class StringRelatedField(WBCoreSerializerFieldMixin, serializers.StringRelatedField):
+    field_type = WBCoreType.TEXT.value
+
+
+class TextAreaField(CharField):
+    field_type = WBCoreType.TEXTAREA.value
+
+
+class CodeField(CharField):
+    field_type = WBCoreType.TEXTAREA.value
+
+    def to_internal_value(self, data):
+        try:
+            compile(data, "", "exec")
+        except Exception as e:
+            raise ValidationError(_("Compiling script failed with the exception: {}".format(e)))
+        return super().to_internal_value(data)
+
+
+class TextField(CharField):
+    field_type = WBCoreType.TEXTEDITOR.value
+    texteditor_content_type = ReturnContentType.HTML.value
+
+    def __init__(self, *args, **kwargs):
+        """The constructor method.
+        This pops the 'plugin_configs' dict from the kwargs and calls the
+        parents init method.
+
+        Parameters
+        ----------
+        plugin_configs : dict, optional
+            A dictionary that contains a dictionary for each plugin of the
+            texteditor. The configuration for each plugin must be available
+            under a unique key.
+        """
+        self.plugin_configs = kwargs.pop("plugin_configs", None)
+        super().__init__(*args, **kwargs)
+
+    def get_representation(self, request, field_name) -> tuple[str, dict]:
+        key, representation = super().get_representation(request, field_name)
+        representation["content_type"] = self.texteditor_content_type
+        if not self.plugin_configs:
+            representation["plugin_configs"] = {}
+        else:
+            representation["plugin_configs"] = self.plugin_configs(request)
+        return key, representation
+
+
+class MarkdownTextField(TextField):
+    field_type = WBCoreType.MARKDOWNEDITOR.value
+    texteditor_content_type = ReturnContentType.MARKDOWN.value
+
+    def __init__(self, metadata_field=None, *args, **kwargs):
+        self.metadata_field = metadata_field
+        super().__init__(*args, **kwargs)
+
+    def get_representation(self, request, field_name) -> tuple[str, dict]:
+        key, representation = super().get_representation(request, field_name)
+        representation["image_upload"] = reverse("wbcore:markdown-asset-upload", request=request)
+        representation["tags"] = reverse("wbcore:markdown-tags", request=request)
+        if self.metadata_field:
+            representation["metadata_field"] = self.metadata_field
+        return key, representation
+
+
+class ColorPickerField(CharField):
+    field_type = WBCoreType.COLOR.value
+
+    def __init__(self, *args, **kwargs):
+        kwargs["copyable"] = True
+        super().__init__(*args, **kwargs)
+
+    def to_internal_value(self, data):
+        if not re.search(r"^#(?:[0-9a-fA-F]{3}){1,2}$", data):
+            raise ValidationError(_("Please provide a valid hexadecimal color."))
+        return super().to_internal_value(data)
+
+
+class URLField(CharField):
+    field_type = WBCoreType.URL.value
+
+    def __init__(self, open_internally: bool = False, *args, **kwargs):
+        """
+        Args:
+            open_internally: If true, notify the frontend to open the url as an internal widget
+        """
+        self.open_internally = open_internally
+        super().__init__(*args, **kwargs)
+
+    def get_representation(self, request, field_name) -> tuple[str, dict]:
+        key, representation = super().get_representation(request, field_name)
+        representation["open_internally"] = (
+            self.open_internally(self.view) if callable(self.open_internally) else self.open_internally
+        )
+        return key, representation

wbcore/serializers/fields/types.py

@@ -0,0 +1,41 @@
+from enum import Enum
+
+
+class WBCoreType(Enum):
+    TEXT = "text"
+    TELEPHONE = "tel"
+    TEXTEDITOR = "texteditor"
+    TEMPLATED_TEXTEDITOR = "templatedtexteditor"
+    TEXTAREA = "textarea"
+    MARKDOWNEDITOR = "markdowneditor"
+    NUMBER = "number"
+    DATETIME = "datetime"
+    DATE = "date"
+    DATERANGE = "daterange"
+    DURATION = "duration"
+    TIME = "time"
+    PRIMARY_KEY = "primary_key"
+    BOOLEAN = "boolean"
+    SELECT = "select"
+    IMAGE = "image"
+    FILE = "file"
+    LIST = "list"
+    PERCENT = "percent"
+    JSON = "json"
+    JSONTABLE = "table"
+    ICON = "iconselect"
+    COLOR = "color"
+    URL = "url"
+    SPARKLINE = "sparkline"
+
+
+class ReturnContentType(Enum):
+    HTML = "html"
+    JSON = "json"
+    MARKDOWN = "markdown"
+
+
+class DisplayMode(Enum):
+    DECIMAL = "decimal"
+    SHORTENED = "shortened"
+    SCIENTIFIC = "scientific"