GeneralManager 0.0.0__py3-none-any.whl

general_manager/measurement/measurement.py

@@ -0,0 +1,233 @@
+# units.py
+from __future__ import annotations
+from typing import Any, Callable
+import pint
+from decimal import Decimal, getcontext, InvalidOperation
+from operator import eq, ne, lt, le, gt, ge
+
+
+# Set precision for Decimal
+getcontext().prec = 28
+
+# Create a new UnitRegistry
+ureg = pint.UnitRegistry(auto_reduce_dimensions=True)
+
+# Define currency units
+currency_units = ["EUR", "USD", "GBP", "JPY", "CHF", "AUD", "CAD"]
+for currency in currency_units:
+    # Define each currency as its own dimension
+    ureg.define(f"{currency} = [{currency}]")
+
+
+class Measurement:
+    def __init__(self, value: Decimal | float | int | str, unit: str):
+        if not isinstance(value, (Decimal, float, int)):
+            try:
+                value = Decimal(str(value))
+            except Exception:
+                raise TypeError("Value must be a Decimal, float, int or compatible.")
+        if not isinstance(value, Decimal):
+            value = Decimal(str(value))
+        self.__quantity = self.formatDecimal(value) * ureg.Quantity(1, unit)
+
+    def __getstate__(self):
+        state = {
+            "magnitude": str(self.quantity.magnitude),
+            "unit": str(self.quantity.units),
+        }
+        return state
+
+    def __setstate__(self, state):
+        value = Decimal(state["magnitude"])
+        unit = state["unit"]
+        self.__quantity = self.formatDecimal(value) * ureg.Quantity(1, unit)
+
+    @property
+    def quantity(self) -> pint.Quantity:
+        return self.__quantity
+
+    @classmethod
+    def from_string(cls, value: str) -> Measurement:
+        value, unit = value.split(" ")
+        return cls(value, unit)
+
+    @staticmethod
+    def formatDecimal(value: Decimal) -> Decimal:
+        value = value.normalize()
+        if value == value.to_integral_value():
+            try:
+                return value.quantize(Decimal("1"))
+            except InvalidOperation:
+                return value
+        else:
+            return value
+
+    def to(self, target_unit: str, exchange_rate: float | None = None):
+        if self.is_currency():
+            if self.quantity.units == ureg(target_unit):
+                return self  # Same currency, no conversion needed
+            elif exchange_rate is not None:
+                # Convert using the provided exchange rate
+                value = self.quantity.magnitude * Decimal(str(exchange_rate))
+                return Measurement(value, target_unit)
+            else:
+                raise ValueError(
+                    "Conversion between currencies requires an exchange rate."
+                )
+        else:
+            # Standard conversion for physical units
+            converted_quantity: pint.Quantity = self.quantity.to(target_unit)  # type: ignore
+            value = Decimal(str(converted_quantity.magnitude))
+            unit = str(converted_quantity.units)
+            return Measurement(value, unit)
+
+    def is_currency(self):
+        # Check if the unit is a defined currency
+        return str(self.quantity.units) in currency_units
+
+    def __add__(self, other: Any) -> Measurement:
+        if not isinstance(other, Measurement):
+            raise TypeError("Addition is only allowed between Measurement instances.")
+        if self.is_currency() and other.is_currency():
+            # Both are currencies
+            if self.quantity.units != other.quantity.units:
+                raise ValueError(
+                    "Addition between different currencies is not allowed."
+                )
+            result_quantity = self.quantity + other.quantity
+            if not isinstance(result_quantity, pint.Quantity):
+                raise ValueError("Units are not compatible for addition.")
+            return Measurement(
+                Decimal(str(result_quantity.magnitude)), str(result_quantity.units)
+            )
+        elif not self.is_currency() and not other.is_currency():
+            # Both are physical units
+            if self.quantity.dimensionality != other.quantity.dimensionality:
+                raise ValueError("Units are not compatible for addition.")
+            result_quantity = self.quantity + other.quantity
+            if not isinstance(result_quantity, pint.Quantity):
+                raise ValueError("Units are not compatible for addition.")
+            return Measurement(
+                Decimal(str(result_quantity.magnitude)), str(result_quantity.units)
+            )
+        else:
+            raise TypeError(
+                "Addition between currency and physical unit is not allowed."
+            )
+
+    def __sub__(self, other: Any) -> Measurement:
+        if not isinstance(other, Measurement):
+            raise TypeError(
+                "Subtraction is only allowed between Measurement instances."
+            )
+        if self.is_currency() and other.is_currency():
+            # Both are currencies
+            if self.quantity.units != other.quantity.units:
+                raise ValueError(
+                    "Subtraction between different currencies is not allowed."
+                )
+            result_quantity = self.quantity - other.quantity
+            return Measurement(
+                Decimal(str(result_quantity.magnitude)), str(self.quantity.units)
+            )
+        elif not self.is_currency() and not other.is_currency():
+            # Both are physical units
+            if self.quantity.dimensionality != other.quantity.dimensionality:
+                raise ValueError("Units are not compatible for subtraction.")
+            result_quantity = self.quantity - other.quantity
+            return Measurement(
+                Decimal(str(result_quantity.magnitude)), str(self.quantity.units)
+            )
+        else:
+            raise TypeError(
+                "Subtraction between currency and physical unit is not allowed."
+            )
+
+    def __mul__(self, other: Any) -> Measurement:
+        if isinstance(other, Measurement):
+            if self.is_currency() or other.is_currency():
+                raise TypeError(
+                    "Multiplication between two currency amounts is not allowed."
+                )
+            result_quantity = self.quantity * other.quantity
+            return Measurement(
+                Decimal(str(result_quantity.magnitude)), str(result_quantity.units)
+            )
+        elif isinstance(other, (Decimal, float, int)):
+            if not isinstance(other, Decimal):
+                other = Decimal(str(other))
+            result_quantity = self.quantity * other
+            return Measurement(
+                Decimal(str(result_quantity.magnitude)), str(self.quantity.units)
+            )
+        else:
+            raise TypeError(
+                "Multiplication is only allowed with Measurement or numeric values."
+            )
+
+    def __truediv__(self, other: Any) -> Measurement:
+        if isinstance(other, Measurement):
+            if self.is_currency() and other.is_currency():
+                raise TypeError("Division between two currency amounts is not allowed.")
+            result_quantity = self.quantity / other.quantity
+            return Measurement(
+                Decimal(str(result_quantity.magnitude)), str(result_quantity.units)
+            )
+        elif isinstance(other, (Decimal, float, int)):
+            if not isinstance(other, Decimal):
+                other = Decimal(str(other))
+            result_quantity = self.quantity / other
+            return Measurement(
+                Decimal(str(result_quantity.magnitude)), str(self.quantity.units)
+            )
+        else:
+            raise TypeError(
+                "Division is only allowed with Measurement or numeric values."
+            )
+
+    def __str__(self):
+        if not str(self.quantity.units) == "dimensionless":
+            return f"{self.quantity.magnitude} {self.quantity.units}"
+        return f"{self.quantity.magnitude}"
+
+    def __repr__(self):
+        return f"Measurement({self.quantity.magnitude}, '{self.quantity.units}')"
+
+    def _compare(self, other: Any, operation: Callable[..., bool]) -> bool:
+        if isinstance(other, str):
+            other = Measurement.from_string(other)
+
+        # Überprüfen, ob `other` ein Measurement-Objekt ist
+        if not isinstance(other, Measurement):
+            return NotImplemented
+        try:
+            # Convert `other` to the same units as `self`
+            other_converted: pint.Quantity = other.quantity.to(self.quantity.units)  # type: ignore
+            # Apply the comparison operation
+            return operation(self.quantity.magnitude, other_converted.magnitude)
+        except pint.DimensionalityError:
+            raise ValueError("Cannot compare measurements with different dimensions.")
+
+    def __radd__(self, other: Any) -> Measurement:
+        if other == 0:
+            return self
+        return self.__add__(other)
+
+    # Comparison Operators
+    def __eq__(self, other: Any) -> bool:
+        return self._compare(other, eq)
+
+    def __ne__(self, other: Any) -> bool:
+        return self._compare(other, ne)
+
+    def __lt__(self, other: Any) -> bool:
+        return self._compare(other, lt)
+
+    def __le__(self, other: Any) -> bool:
+        return self._compare(other, le)
+
+    def __gt__(self, other: Any) -> bool:
+        return self._compare(other, gt)
+
+    def __ge__(self, other: Any) -> bool:
+        return self._compare(other, ge)

general_manager/measurement/measurementField.py

@@ -0,0 +1,152 @@
+# fields.py
+from __future__ import annotations
+from django.db import models
+from django.core.exceptions import ValidationError
+from decimal import Decimal
+from general_manager.measurement.measurement import Measurement, ureg, currency_units
+import pint
+from typing import Any
+
+
+class MeasurementField(models.Field):  # type: ignore
+    description = (
+        "A field that stores a measurement value, both in base unit and original unit"
+    )
+
+    def __init__(
+        self,
+        base_unit: str,
+        null: bool = False,
+        blank: bool = False,
+        editable: bool = True,
+        *args: list[Any],
+        **kwargs: dict[str, Any],
+    ):
+        self.base_unit = base_unit  # E.g., 'meter' for length units
+        # Determine the dimensionality of the base unit
+        self.base_dimension = ureg.parse_expression(self.base_unit).dimensionality
+        # Internal fields
+        null_blank_kwargs = {}
+        if null is True:
+            null_blank_kwargs["null"] = True
+        if blank is True:
+            null_blank_kwargs["blank"] = True
+        self.editable = editable
+        self.value_field: models.DecimalField[Decimal] = models.DecimalField(
+            max_digits=30,
+            decimal_places=10,
+            db_index=True,
+            **null_blank_kwargs,
+            editable=editable,
+        )
+        self.unit_field: models.CharField[str] = models.CharField(
+            max_length=30, **null_blank_kwargs, editable=editable
+        )
+        super().__init__(null=null, blank=blank, *args, **kwargs)
+
+    def contribute_to_class(
+        self, cls: type, name: str, private_only: bool = False, **kwargs: dict[str, Any]
+    ) -> None:
+        self.name = name
+        self.value_attr = f"{name}_value"
+        self.unit_attr = f"{name}_unit"
+        self.value_field.attname = self.value_attr
+        self.unit_field.attname = self.unit_attr
+        self.value_field.name = self.value_attr
+        self.unit_field.name = self.unit_attr
+        self.value_field.column = self.value_attr
+        self.unit_field.column = self.unit_attr
+
+        self.value_field.model = cls
+        self.unit_field.model = cls
+
+        self.value_field.contribute_to_class(cls, self.value_attr)
+        self.unit_field.contribute_to_class(cls, self.unit_attr)
+
+        setattr(cls, self.name, self)
+
+    def __get__(self, instance: Any, owner: Any) -> Any:
+        if instance is None:
+            return self
+        value = getattr(instance, self.value_attr)
+        unit = getattr(instance, self.unit_attr)
+        if value is None or unit is None:
+            return None
+        # Create a Measurement object with the value in the original unit
+        quantity_in_base_unit = Decimal(value) * ureg(self.base_unit)
+        # Convert back to the original unit
+        try:
+            quantity_in_original_unit: pint.Quantity = quantity_in_base_unit.to(unit)  # type: ignore
+        except pint.errors.DimensionalityError:
+            # If the unit is not compatible, return the value in base unit
+            quantity_in_original_unit = quantity_in_base_unit
+        return Measurement(
+            quantity_in_original_unit.magnitude, str(quantity_in_original_unit.units)
+        )
+
+    def __set__(self, instance: Any, value: Any) -> None:
+        if self.editable is False:
+            raise ValidationError(f"{self.name} is not editable.")
+        if value is None:
+            setattr(instance, self.value_attr, None)
+            setattr(instance, self.unit_attr, None)
+            return
+        elif isinstance(value, str):
+            try:
+                value = Measurement.from_string(value)
+            except ValueError:
+                raise ValidationError(
+                    {self.name: ["Value must be a Measurement instance or None."]}
+                )
+        if isinstance(value, Measurement):
+            if str(self.base_unit) in currency_units:
+                # Base unit is a currency
+                if not value.is_currency():
+                    raise ValidationError(
+                        {
+                            self.name: [
+                                f"The unit must be a currency ({', '.join(currency_units)})."
+                            ]
+                        }
+                    )
+            else:
+                # Physical unit
+                if value.is_currency():
+                    raise ValidationError(
+                        {self.name: ["The unit cannot be a currency."]}
+                    )
+                elif value.quantity.dimensionality != self.base_dimension:
+                    raise ValidationError(
+                        {
+                            self.name: [
+                                f"The unit must be compatible with '{self.base_unit}'."
+                            ]
+                        }
+                    )
+            # Store the value in the base unit
+            try:
+                value_in_base_unit: Any = value.quantity.to(self.base_unit).magnitude  # type: ignore
+            except pint.errors.DimensionalityError:
+                raise ValidationError(
+                    {
+                        self.name: [
+                            f"The unit must be compatible with '{self.base_unit}'."
+                        ]
+                    }
+                )
+            setattr(instance, self.value_attr, Decimal(str(value_in_base_unit)))
+            # Store the original unit
+            setattr(instance, self.unit_attr, str(value.quantity.units))
+        else:
+            raise ValidationError(
+                {self.name: ["Value must be a Measurement instance or None."]}
+            )
+
+    def get_prep_value(self, value: Any) -> Any:
+        # Not needed since we use internal fields
+        pass
+
+    def deconstruct(self):
+        name, path, args, kwargs = super().deconstruct()
+        kwargs["base_unit"] = self.base_unit
+        return name, path, args, kwargs

general_manager/permission/__init__.py

@@ -0,0 +1 @@
+from .managerBasedPermission import ManagerBasedPermission

general_manager/permission/basePermission.py

@@ -0,0 +1,178 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any, Literal
+from general_manager.permission.permissionChecks import (
+    permission_functions,
+    permission_filter,
+)
+
+
+if TYPE_CHECKING:
+    from django.contrib.auth.models import AbstractUser, AnonymousUser
+    from general_manager.permission.permissionDataManager import (
+        PermissionDataManager,
+    )
+    from general_manager.manager.generalManager import GeneralManager
+    from general_manager.manager.meta import GeneralManagerMeta
+
+
+class BasePermission(ABC):
+
+    def __init__(
+        self,
+        instance: PermissionDataManager | GeneralManager | GeneralManagerMeta,
+        request_user: AbstractUser | AnonymousUser,
+    ) -> None:
+        self._instance = instance
+        self._request_user = request_user
+
+    @property
+    def instance(self) -> PermissionDataManager | GeneralManager | GeneralManagerMeta:
+        return self._instance
+
+    @property
+    def request_user(self) -> AbstractUser | AnonymousUser:
+        return self._request_user
+
+    @classmethod
+    def checkCreatePermission(
+        cls,
+        data: dict[str, Any],
+        manager: type[GeneralManager],
+        request_user: AbstractUser | AnonymousUser | Any,
+    ) -> None:
+        request_user = cls.getUserWithId(request_user)
+        errors = []
+        permission_data = PermissionDataManager(permission_data=data, manager=manager)
+        Permission = cls(permission_data, request_user)
+        for key in data.keys():
+            is_allowed = Permission.checkPermission("create", key)
+            if not is_allowed:
+                errors.append(
+                    f"Permission denied for {key} with value {data[key]} for user {request_user}"
+                )
+        if errors:
+            raise PermissionError(
+                f"Permission denied for user {request_user} with errors: {errors}"
+            )
+
+    @classmethod
+    def checkUpdatePermission(
+        cls,
+        data: dict[str, Any],
+        old_manager_instance: GeneralManager,
+        request_user: AbstractUser | AnonymousUser | Any,
+    ) -> None:
+        request_user = cls.getUserWithId(request_user)
+
+        errors = []
+        permission_data = PermissionDataManager[GeneralManager].forUpdate(
+            base_data=old_manager_instance, update_data=data
+        )
+        Permission = cls(permission_data, request_user)
+        for key in data.keys():
+            is_allowed = Permission.checkPermission("update", key)
+            if not is_allowed:
+                errors.append(
+                    f"Permission denied for {key} with value {data[key]} for user {request_user}"
+                )
+        if errors:
+            raise PermissionError(
+                f"Permission denied for user {request_user} with errors: {errors}"
+            )
+
+    @classmethod
+    def checkDeletePermission(
+        cls,
+        manager_instance: GeneralManager,
+        request_user: AbstractUser | AnonymousUser | Any,
+    ) -> None:
+        request_user = cls.getUserWithId(request_user)
+
+        errors = []
+        permission_data = PermissionDataManager[GeneralManager](manager_instance)
+        Permission = cls(permission_data, request_user)
+        for key in manager_instance.__dict__.keys():
+            is_allowed = Permission.checkPermission("delete", key)
+            if not is_allowed:
+                errors.append(
+                    f"Permission denied for {key} with value {getattr(manager_instance, key)} for user {request_user}"
+                )
+        if errors:
+            raise PermissionError(
+                f"Permission denied for user {request_user} with errors: {errors}"
+            )
+
+    @staticmethod
+    def getUserWithId(
+        user: Any | AbstractUser | AnonymousUser,
+    ) -> AbstractUser | AnonymousUser:
+        """
+        Returns the user with the given id
+        """
+        from django.contrib.auth.models import User
+
+        if isinstance(user, (AbstractUser, AnonymousUser)):
+            return user
+        try:
+            return User.objects.get(id=user)
+        except User.DoesNotExist:
+            return AnonymousUser()
+
+    @abstractmethod
+    def checkPermission(
+        self,
+        action: Literal["create", "read", "update", "delete"],
+        attriubte: str,
+    ) -> bool:
+        raise NotImplementedError
+
+    def getPermissionFilter(
+        self,
+    ) -> list[dict[Literal["filter", "exclude"], dict[str, str]]]:
+        """
+        Returns the filter for the permission
+        """
+        raise NotImplementedError
+
+    def _getPermissionFilter(
+        self, permission: str
+    ) -> dict[Literal["filter", "exclude"], dict[str, str]]:
+        """
+        Returns the filter for the permission
+        """
+        permission_function, *config = permission.split(":")
+        if permission_function not in permission_functions:
+            raise ValueError(f"Permission {permission} not found")
+        permission_filter = permission_functions[permission_function][
+            "permission_filter"
+        ](self.request_user, config)
+        if permission_filter is None:
+            return {"filter": {}, "exclude": {}}
+        return permission_filter
+
+    def validatePermissionString(
+        self,
+        permission: str,
+    ) -> bool:
+        # permission can be a combination of multiple permissions
+        # separated by "&" (e.g. "isAuthenticated&isMatchingKeyAccount")
+        # this means that all sub_permissions must be true
+        return all(
+            [
+                self.__validateSinglePermission(sub_permission)
+                for sub_permission in permission.split("&")
+            ]
+        )
+
+    def __validateSinglePermission(
+        self,
+        permission: str,
+    ) -> bool:
+        permission_function, *config = permission.split(":")
+        if permission_function not in permission_functions:
+            raise ValueError(f"Permission {permission} not found")
+
+        return permission_functions[permission_function]["permission_method"](
+            self.instance, self.request_user, config
+        )