Encryptors 2.41__tar.gz → 2.43__tar.gz

{encryptors-2.41 → encryptors-2.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Encryptors
-Version: 2.41
+Version: 2.43
 Summary: End-to-end algorithm library
 Author: OSDental LLC
 Author-email: support@osdental.ai

{encryptors-2.41 → encryptors-2.43}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 # ANDERSON ESTO YA SE SUBIO Y ESTA ESTABLE, AUN TE QUEDA PENDIENTE LA AUDITORIA CON RSA Y AES DE ACCESSTOKEN
 setup(
     name="Encryptors", 
-    version="2.41",
+    version="2.43",
     author="OSDental LLC",
     author_email="support@osdental.ai",
     description="End-to-end algorithm library",

{encryptors-2.41 → encryptors-2.43}/src/Encryptors.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: Encryptors
-Version: 2.41
+Version: 2.43
 Summary: End-to-end algorithm library
 Author: OSDental LLC
 Author-email: support@osdental.ai

encryptors-2.43/src/Osdental/Decorators/SecureResolver.py

@@ -0,0 +1,61 @@
+from functools import wraps
+from typing import Callable
+from Osdental.Models.Response import Response
+from Osdental.Shared.Enums.Profile import Profile
+from Osdental.Exception.ControlledException import OSDException, AccessDeniedException
+from Osdental.Shared.Logger import logger
+
+def resolver(public: bool = False, action=None):
+
+    def decorator(func: Callable):
+
+        @wraps(func)
+        async def wrapper(obj, info, **kwargs):
+            try:
+                context = info.context
+                token = getattr(context, "token", None)
+
+                # 🔐 AUTH
+                if not public:
+                    if not token:
+                        raise AccessDeniedException(
+                            error="Authorization required"
+                        )
+
+                    # 🎯 AUTHORIZATION (roles)
+                    if action:
+                        if Profile(token.abbreviation) not in action.allowed_roles:
+                            raise AccessDeniedException(
+                                error="User not allowed to perform this action"
+                            )
+
+                result = await func(obj, info, **kwargs)
+
+                if not isinstance(result, Response):
+                    raise TypeError("Resolver must return a Response instance")
+
+                return result
+
+            except OSDException as e:
+                logger.warning(f"Business error: {str(e)}")
+
+                return Response(
+                    status=e.status_code,
+                    message=e.message,
+                    error=None
+                ).send()
+
+            except Exception as e:
+                logger.exception(f"Unexpected error: {str(e)}")
+
+                return Response(
+                    status="DB_ERROR_UNEXPECTED",
+                    message="Could not process request.",
+                    error=str(e)
+                ).send()
+
+        wrapper._is_public = public
+
+        return wrapper
+
+    return decorator

{encryptors-2.41 → encryptors-2.43}/src/Osdental/Graphql/Extensions/AuditExtension.py

@@ -8,6 +8,7 @@ from Osdental.Rest.Context.RequestContext import (
     current_context,
     RequestContext
 )
+from Osdental.Models.Response import Response
 from Osdental.Graphql.Models import BaseGraphQLContext
 from Osdental.Shared.Enums.Constant import Constant
 
@@ -37,8 +38,7 @@ class AuditExtension(Extension):
         request = context.request
 
         # cache body
-        if not hasattr(context, "_cached_body"):
-            context._cached_body = await request.json()
+        context._cached_body = getattr(context, "_cached_body", None) or await request.json()
 
         body = context._cached_body
 
@@ -119,7 +119,7 @@ class AuditExtension(Extension):
                                 decrypted_payload = None
 
             if decrypted_payload is not None:
-                context.decrypted_payload = decrypted_payload
+                kwargs["data"] = decrypted_payload
             
             if not is_public:
                 token = TenantPolicy.resolve(
@@ -153,9 +153,6 @@ class AuditExtension(Extension):
         if is_root and self.result is None:
             self.result = result
 
-            if not getattr(context, "audit_plain_response", None):
-                context.audit_plain_response = result
-
         return result
 
     def has_errors(self, errors, context):
@@ -168,13 +165,18 @@ class AuditExtension(Extension):
 
         query = self.request_payload.get("query", "")
 
-        if "__schema" in query or "__type" in query:
+        if self._should_skip({"query": query}):
+            return
+        
+        if self.result is None:
             return
 
-        final_result = context.audit_plain_response or self.result
+        decrypted_key = None
 
-        if final_result is None:
-            return
+        if isinstance(self.result, Response):
+            decrypted_key = self.result.key or context.aes_auth
+        else:
+            decrypted_key = context.aes_auth
 
         dispatcher = context.request.app.state.audit_dispatcher
 
@@ -182,8 +184,11 @@ class AuditExtension(Extension):
             dispatcher.dispatch(
                 request=self.request,
                 request_payload=self.request_payload,
-                result=final_result,
+                result=self.result,
+                metadata={
+                    "decrypted_key": decrypted_key
+                },
                 audit_type=Constant.MESSAGE_LOG_INTERNAL
             )
         except Exception as e:
-            logger(f"[AUDIT ERROR]: {str(e)}")
+            logger.warning(f"[AUDIT ERROR]: {str(e)}")

{encryptors-2.41 → encryptors-2.43}/src/Osdental/Helpers/AuditDispatcher.py

@@ -40,6 +40,7 @@ class AuditDispatcher:
         request: Request, 
         request_payload: Dict[str, Any], 
         result: Response,
+        metadata: Dict[str, Any],
         audit_type: str = None
     ):
         try:
@@ -47,6 +48,7 @@ class AuditDispatcher:
                 "request": request,
                 "request_payload": request_payload,
                 "result": result,
+                "metadata": metadata,
                 "audit_type": audit_type
             }
 
@@ -77,6 +79,7 @@ class AuditDispatcher:
         request_payload = payload["request_payload"]
         result: Response = payload["result"]
         audit_type = payload["audit_type"]
+        metadata = payload["metadata"]
 
         operation_name = request_payload.get("operation_name")
         if operation_name == 'UnknownOperation':
@@ -100,9 +103,8 @@ class AuditDispatcher:
 
         # Obtencion de campos adicionales cuando es otro tipo de encriptacion o clave
         encryption_type = result.encryption_type
-        key = result.key
+        decrypted_key = metadata["decrypted_key"]
 
-        
         if audit_type == Constant.MESSAGE_LOG_INTERNAL:
 
             ERROR_PREFIXES = ("DB_ERROR", "DB_WARNING")
@@ -116,7 +118,6 @@ class AuditDispatcher:
             except ValueError:
                 is_error = True
     
-
         if is_error:
             payload = AuditHelper.build_final_payload(
                 _type="ERROR",
@@ -127,8 +128,8 @@ class AuditDispatcher:
             audit_message = request_audit_payload | payload
 
         else:
-            if encryption_type in VALID_TYPES and key is not None:
-                data = decryptor_data(encryption_type, key, data)
+            if encryption_type in VALID_TYPES and decrypted_key:
+                data = decryptor_data(encryption_type, decrypted_key, data)
 
             payload = AuditHelper.build_final_payload(
                 _type="RESPONSE",

encryptors-2.43/src/Osdental/Helpers/ResponseDecryptor.py

@@ -0,0 +1,33 @@
+from typing import Dict, Any
+from Osdental.Encryptor.Aes import AES
+from Osdental.Encryptor.Rsa import RSAEncryptor
+from Osdental.Shared.Logger import logger
+
+VALID_TYPES = {"RSA", "AES"}
+
+def encryptor_data(encryption_type: str, key: str, data: Dict[str, Any] | str) -> Any:
+    match encryption_type:
+
+        case "AES":
+            return AES.encrypt(key, data)
+
+        case "RSA":
+            return RSAEncryptor.encrypt(data, key)
+        
+        case _:
+            logger.warning(f"Encryption type '{encryption_type}' not supported.")
+            return data
+        
+def decryptor_data(encryption_type: str, key: str, data: Dict[str, Any] | str) -> Any:
+    
+    match encryption_type:
+
+        case "AES":
+            return AES.decrypt(key, data)
+
+        case "RSA":
+            return RSAEncryptor.decrypt(data, key)
+        
+        case _:
+            logger.warning(f"Encryption type '{encryption_type}' not supported.")
+            return data

encryptors-2.41/src/Osdental/Decorators/SecureResolver.py

@@ -1,56 +0,0 @@
-import inspect
-import copy
-from functools import wraps
-from typing import Callable, Dict, Any
-from Osdental.Models.Token import AuthToken
-from Osdental.Models.Response import Response
-from Osdental.Shared.Enums.Profile import Profile
-from Osdental.Exception.ControlledException import OSDException, AccessDeniedException
-from Osdental.Encryptor.Aes import AES
-from Osdental.Graphql.Models import BaseGraphQLContext
-from Osdental.Shared.Logger import logger
-
-def secure_resolver(action = None):
-    def decorator(func: Callable):
-
-        signature = inspect.signature(func)
-        params = signature.parameters
-
-        @wraps(func)
-        async def wrapper(obj: Any, context: BaseGraphQLContext, **kwargs: Dict[str, Any]):
-            try:
-                token: AuthToken = context.token
-                payload = getattr(context, "decrypted_payload", None)
-                aes_auth = getattr(context, "aes_auth", None)
-
-                if action:
-                    if Profile(token.abbreviation) not in action.allowed_roles:
-                        raise AccessDeniedException(error="The user's profile is not allowed to perform this action.")
-
-                if "token" in params:
-                    kwargs["token"] = token
-
-                if "data" in params:
-                    kwargs["data"] = payload
-
-                result: Response = await func(obj, **kwargs)
-
-                context.audit_plain_response = copy.deepcopy(result)
-
-                if result.data is not None and result.encryption_type == "AES" and result.key is None:
-                    result.data = AES.encrypt(aes_auth, result.data)
-
-                return result.send()
-
-            except (Exception, OSDException) as e:
-                logger.exception(f"An error has occurred: {str(e)}")
-                result = Response(
-                    status=getattr(e, "status_code", "DB_ERROR_UNEXPECTED"),
-                    message=getattr(e, "message", "Could not process request."),
-                    error=f"{type(e).__name__}: {str(e)}"
-                )
-                context.audit_plain_response = result
-                return result.send()
-
-        return wrapper
-    return decorator

encryptors-2.41/src/Osdental/Helpers/ResponseDecryptor.py

@@ -1,15 +0,0 @@
-from typing import Dict, Any
-from Osdental.Encryptor.Aes import AES
-from Osdental.Encryptor.Rsa import RSAEncryptor
-
-VALID_TYPES = {"RSA", "AES"}
-
-def decryptor_data(encryption_type: str, key: str, data: Dict[str, Any] | str) -> Any:
-    
-    match encryption_type:
-
-        case "AES":
-            return AES.decrypt(key, data)
-
-        case "RSA":
-            return RSAEncryptor.decrypt(data, key)