GeneralManager 0.0.0__py3-none-any.whl

general_manager/permission/managerBasedPermission.py

@@ -0,0 +1,171 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Literal, Optional, Dict
+from general_manager.permission.basePermission import BasePermission
+
+if TYPE_CHECKING:
+    from general_manager.permission.permissionDataManager import (
+        PermissionDataManager,
+    )
+    from general_manager.manager.generalManager import GeneralManager
+    from django.contrib.auth.models import AbstractUser
+
+type permission_type = Literal[
+    "create",
+    "read",
+    "update",
+    "delete",
+]
+
+
+class ManagerBasedPermission(BasePermission):
+    __based_on__: Optional[str] = None
+    __read__: list[str] = ["public"]
+    __create__: list[str] = ["isAuthenticated"]
+    __update__: list[str] = ["isAuthenticated"]
+    __delete__: list[str] = ["isAuthenticated"]
+
+    def __init__(
+        self,
+        instance: PermissionDataManager | GeneralManager,
+        request_user: AbstractUser,
+    ) -> None:
+
+        self.__instance = instance
+        self.__request_user = request_user
+        self.__attribute_permissions = self.__getAttributePermissions()
+        self.__based_on_permission = self.__getBasedOnPermission()
+        self.__overall_results: Dict[permission_type, Optional[bool]] = {
+            "create": None,
+            "read": None,
+            "update": None,
+            "delete": None,
+        }
+
+    def __getBasedOnPermission(self) -> Optional[BasePermission]:
+        from general_manager.manager.generalManager import GeneralManager
+
+        __based_on__ = getattr(self, "__based_on__")
+        if __based_on__ is None:
+            return None
+
+        basis_object = getattr(self.instance, __based_on__, None)
+        if basis_object is None:
+            raise ValueError(
+                f"Based on object {__based_on__} not found in instance {self.__instance}"
+            )
+        if not isinstance(basis_object, GeneralManager) and not issubclass(
+            basis_object, GeneralManager
+        ):
+            raise TypeError(f"Based on object {__based_on__} is not a GeneralManager")
+
+        Permission = getattr(basis_object, "Permission", None)
+
+        if Permission is None or not issubclass(
+            Permission,
+            BasePermission,
+        ):
+            return None
+
+        return Permission(
+            instance=getattr(self.instance, __based_on__),
+            request_user=self.request_user,
+        )
+
+    @property
+    def instance(self) -> PermissionDataManager | GeneralManager:
+        return self.__instance
+
+    @property
+    def request_user(self) -> AbstractUser:
+        return self.__request_user
+
+    def __getAttributePermissions(
+        self,
+    ) -> dict[str, dict[permission_type, list[str]]]:
+        attribute_permissions = {}
+        for attribute in self.__class__.__dict__:
+            if not attribute.startswith("__"):
+                attribute_permissions[attribute] = getattr(self, attribute)
+        return attribute_permissions
+
+    def checkPermission(
+        self,
+        action: permission_type,
+        attriubte: str,
+    ) -> bool:
+        if (
+            self.__based_on_permission
+            and not self.__based_on_permission.checkPermission(action, attriubte)
+        ):
+            return False
+
+        if action == "create":
+            permissions = self.__create__
+        elif action == "read":
+            permissions = self.__read__
+        elif action == "update":
+            permissions = self.__update__
+        elif action == "delete":
+            permissions = self.__delete__
+        else:
+            raise ValueError(f"Action {action} not found")
+
+        has_attribute_permissions = (
+            attriubte in self.__attribute_permissions
+            and action in self.__attribute_permissions[attriubte]
+        )
+
+        if not has_attribute_permissions:
+            last_result = self.__overall_results.get(action)
+            if last_result is not None:
+                return last_result
+            attribute_permission = True
+        else:
+            attribute_permission = self.__checkSpecificPermission(
+                self.__attribute_permissions[attriubte][action]
+            )
+
+        permission = self.__checkSpecificPermission(permissions)
+        self.__overall_results[action] = permission
+        return permission and attribute_permission
+
+    def __checkSpecificPermission(
+        self,
+        permissions: list[str],
+    ) -> bool:
+        for permission in permissions:
+            if self.validatePermissionString(permission):
+                return True
+        return False
+
+    def getPermissionFilter(
+        self,
+    ) -> list[dict[Literal["filter", "exclude"], dict[str, str]]]:
+        """
+        Returns the filter for the permission
+        """
+        __based_on__ = getattr(self, "__based_on__")
+        filters: list[dict[Literal["filter", "exclude"], dict[str, str]]] = []
+
+        if self.__based_on_permission is not None:
+            base_permissions = self.__based_on_permission.getPermissionFilter()
+            for permission in base_permissions:
+                filter = permission.get("filter", {})
+                exclude = permission.get("exclude", {})
+                filters.append(
+                    {
+                        "filter": {
+                            f"{__based_on__}__{key}": value
+                            for key, value in filter.items()
+                        },
+                        "exclude": {
+                            f"{__based_on__}__{key}": value
+                            for key, value in exclude.items()
+                        },
+                    }
+                )
+
+        for permission in self.__read__:
+            filters.append(self._getPermissionFilter(permission))
+
+        return filters

general_manager/permission/permissionChecks.py

@@ -0,0 +1,53 @@
+from typing import Any, Callable, TYPE_CHECKING, TypedDict, Literal
+
+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
+
+
+type permission_filter = Callable[
+    [AbstractUser | AnonymousUser, list[str]],
+    dict[Literal["filter", "exclude"], dict[str, str]] | None,
+]
+
+type permission_method = Callable[
+    [
+        PermissionDataManager | GeneralManager | GeneralManagerMeta,
+        AbstractUser | AnonymousUser,
+        list[str],
+    ],
+    bool,
+]
+
+
+class PermissionDict(TypedDict):
+    permission_method: permission_method
+    permission_filter: permission_filter
+
+
+permission_functions: dict[str, PermissionDict] = {
+    "public": {
+        "permission_method": lambda instance, user, config: True,
+        "permission_filter": lambda user, config: None,
+    },
+    "ends_with": {
+        "permission_method": lambda instance, user, config: getattr(
+            instance, config[0]
+        ).endswith(config[1]),
+        "permission_filter": lambda user, config: {
+            "filter": {f"{config[0]}__endswith": config[1]}
+        },
+    },
+    "admin": {
+        "permission_method": lambda instance, user, config: user.is_staff,
+        "permission_filter": lambda user, config: None,
+    },
+    "isAuthenticated": {
+        "permission_method": lambda instance, user, config: user.is_authenticated,
+        "permission_filter": lambda user, config: None,
+    },
+}

general_manager/permission/permissionDataManager.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+from typing import Callable, Dict, Any, Optional, TypeVar, Generic
+from django.contrib.auth.models import AbstractUser
+
+from general_manager.manager.generalManager import GeneralManager
+
+GeneralManagerData = TypeVar("GeneralManagerData", bound=GeneralManager)
+
+
+class PermissionDataManager(Generic[GeneralManagerData]):
+    def __init__(
+        self,
+        permission_data: Dict[str, Any] | GeneralManagerData,
+        manager: Optional[type[GeneralManagerData]] = None,
+    ):
+        self.getData: Callable[[str], Any]
+        self._permission_data = permission_data
+        if isinstance(permission_data, GeneralManager):
+            self.getData = lambda name, permission_data=permission_data: getattr(
+                permission_data, name
+            )
+            self._manager = permission_data.__class__
+        elif isinstance(permission_data, dict):
+            self.getData = (
+                lambda name, permission_data=permission_data: permission_data.get(name)
+            )
+            if manager is None:
+                raise ValueError(
+                    "Manager must be provided if permission_data is a dict"
+                )
+            self._manager = manager
+        else:
+            raise TypeError(
+                "permission_data must be either a dict or an instance of GeneralManager"
+            )
+
+    @classmethod
+    def forUpdate(
+        cls,
+        base_data: GeneralManagerData,
+        update_data: Dict[str, Any],
+    ) -> PermissionDataManager:
+        merged_data = {**dict(base_data), **update_data}
+        return cls(merged_data, base_data.__class__)
+
+    @property
+    def permission_data(self) -> Dict[str, Any] | GeneralManagerData:
+        return self._permission_data
+
+    @property
+    def manager(self) -> type[GeneralManagerData]:
+        return self._manager
+
+    def __getattr__(self, name: str) -> Any:
+        return self.getData(name)

general_manager/rule/__init__.py

@@ -0,0 +1 @@
+from .rule import Rule

general_manager/rule/handler.py

@@ -0,0 +1,122 @@
+# generalManager/src/rule/handlers.py
+
+from __future__ import annotations
+import ast
+from typing import Dict, Optional, TYPE_CHECKING, cast
+
+if TYPE_CHECKING:
+    # Forward-Reference auf Rule mit beliebigem Generic-Parameter
+    from general_manager.rule.rule import Rule
+    from general_manager.manager import GeneralManager
+
+
+class BaseRuleHandler:
+    """Schnittstelle für Rule-Handler."""
+
+    function_name: str  # ClassVar, der Name, unter dem dieser Handler registriert wird
+
+    def handle(
+        self,
+        node: ast.AST,
+        left: Optional[ast.expr],
+        right: Optional[ast.expr],
+        op: Optional[ast.cmpop],
+        var_values: Dict[str, Optional[object]],
+        rule: Rule,
+    ) -> Dict[str, str]:
+        """
+        Erstelle Fehlermeldungen für den Vergleichs- oder Funktionsaufruf.
+        """
+        raise NotImplementedError
+
+
+class LenHandler(BaseRuleHandler):
+    function_name = "len"
+
+    def handle(
+        self,
+        node: ast.AST,
+        left: Optional[ast.expr],
+        right: Optional[ast.expr],
+        op: Optional[ast.cmpop],
+        var_values: Dict[str, Optional[object]],
+        rule: Rule,
+    ) -> Dict[str, str]:
+        # Wir erwarten hier einen Compare-Knoten
+        if not isinstance(node, ast.Compare):
+            return {}
+        compare_node = node
+
+        left_node = compare_node.left
+        right_node = compare_node.comparators[0]
+        op_symbol = rule._get_op_symbol(op)
+
+        # Argument von len(...)
+        if not (isinstance(left_node, ast.Call) and left_node.args):
+            raise ValueError("Invalid left node for len function")
+        arg_node = left_node.args[0]
+
+        var_name = rule._get_node_name(arg_node)
+        var_value = var_values.get(var_name)
+
+        # --- Hier der Typ-Guard für right_value ---
+        raw = rule._eval_node(right_node)
+        if not isinstance(raw, (int, float)):
+            raise ValueError("Invalid arguments for len function")
+        right_value: int | float = raw
+
+        # Schwellenwert je nach Operator
+        if op_symbol == ">":
+            threshold = right_value + 1
+        elif op_symbol == ">=":
+            threshold = right_value
+        elif op_symbol == "<":
+            threshold = right_value - 1
+        elif op_symbol == "<=":
+            threshold = right_value
+        else:
+            threshold = right_value
+
+        # Fehlermeldung formulieren
+        if op_symbol in (">", ">="):
+            msg = f"[{var_name}] ({var_value}) is too short (min length {threshold})!"
+        elif op_symbol in ("<", "<="):
+            msg = f"[{var_name}] ({var_value}) is too long (max length {threshold})!"
+        else:
+            msg = f"[{var_name}] ({var_value}) must be {op_symbol} {right_value}!"
+
+        return {var_name: msg}
+
+
+class IntersectionCheckHandler(BaseRuleHandler):
+    function_name = "intersectionCheck"
+
+    def handle(
+        self,
+        node: ast.AST,
+        left: Optional[ast.expr],
+        right: Optional[ast.expr],
+        op: Optional[ast.cmpop],
+        var_values: Dict[str, Optional[object]],
+        rule: Rule[GeneralManager],
+    ) -> Dict[str, str]:
+        # Der Aufruf steht in `left`, nicht in `node`
+        call_node = cast(ast.Call, left)
+        if not isinstance(call_node, ast.Call):
+            return {"error": "Invalid arguments for intersectionCheck"}
+
+        args = call_node.args
+        if len(args) < 2:
+            return {"error": "Invalid arguments for intersectionCheck"}
+
+        start_node, end_node = args[0], args[1]
+        start_name = rule._get_node_name(start_node)
+        end_name = rule._get_node_name(end_node)
+        start_val = var_values.get(start_name)
+        end_val = var_values.get(end_name)
+
+        msg = (
+            f"[{start_name}] ({start_val}) and "
+            f"[{end_name}] ({end_val}) must not overlap with existing ranges."
+        )
+        return {start_name: msg, end_name: msg}