Encryptors 2.56__tar.gz → 2.57__tar.gz

{encryptors-2.56 → encryptors-2.57}/PKG-INFO

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

{encryptors-2.56 → encryptors-2.57}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 # ANDERSON REVISAR EL CACHE LOCAL DEL KEYVAULT PARA VALIDAR SI FUNCIONA
 setup(
     name="Encryptors", 
-    version="2.56",
+    version="2.57",
     author="OSDental LLC",
     author_email="support@osdental.ai",
     description="End-to-end algorithm library",

{encryptors-2.56 → encryptors-2.57}/src/Encryptors.egg-info/PKG-INFO

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

{encryptors-2.56 → encryptors-2.57}/src/Encryptors.egg-info/SOURCES.txt

@@ -27,6 +27,7 @@ src/Osdental/Encryptor/Jwt.py
 src/Osdental/Encryptor/Rsa.py
 src/Osdental/Encryptor/Sha512.py
 src/Osdental/Encryptor/__init__.py
+src/Osdental/Enums/ErrorSource.py
 src/Osdental/Enums/FileType.py
 src/Osdental/Enums/GrahpqlOperation.py
 src/Osdental/Enums/Profile.py
@@ -60,12 +61,10 @@ src/Osdental/Messaging/Kafka.py
 src/Osdental/Messaging/RabbitMQ.py
 src/Osdental/Messaging/__init__.py
 src/Osdental/Models/ApiResponse.py
-src/Osdental/Models/AuditConfig.py
 src/Osdental/Models/Notification.py
 src/Osdental/Models/Response.py
 src/Osdental/Models/Token.py
 src/Osdental/Models/TokenClaims.py
-src/Osdental/Models/_Audit.py
 src/Osdental/Models/__init__.py
 src/Osdental/Rest/__init__.py
 src/Osdental/Rest/Context/RequestContext.py

{encryptors-2.56 → encryptors-2.57}/src/Osdental/Constants/Message.py

@@ -31,8 +31,6 @@ class Message:
     UNEXPECTED_DECRYPTED_DATA_FORMAT_MSG = "Unexpected format in decrypted data."
     
     
-    DATABASE_EXECUTION_ERROR_MSG = "An unexpected error occurred while executing a database operation."
-    DATABASE_INTEGRITY_ERROR_MSG = "A database integrity constraint was violated during execution."
     QUERY_NOT_PROVIDED_MSG = "Query not provided. Please include a valid query in your request."
     FILE_PATH_NOT_PROVIDED_MSG = "File path not provided."
     

{encryptors-2.56 → encryptors-2.57}/src/Osdental/Decorators/SecureResolver.py

@@ -15,30 +15,108 @@ from Osdental.Helpers._AuthTokenProcessor import (
     extract_bearer_token, build_auth_token, decrypt_and_parse_payload
 )
 from Osdental.Enums.StatusCode import StatusCode
-from Osdental.Helpers.AuditDispatcher import AuditDispatcher
-
+from Osdental.Storage import IStorageService
+from Osdental.Messaging import IMessageQueue
+from Osdental.Graphql._Helpers._AuditHelper import AuditHelper
+from Osdental.Constants.Constant import Constant
+from Osdental.Helpers.ResponseDecryptor import decryptor_data, VALID_TYPES
 
 logger = logging.getLogger(__name__)
 
 
-def __test(
-    dispatcher: AuditDispatcher, 
-    request,
+async def __test(
+    messaging: IMessageQueue,
+    storage: IStorageService,
     request_payload: Dict[str, Any],
+    request,
     result: Response,
-    decrypted_key: str
+    decrypted_key: str,
+    audit_type: str
 ) -> None:
-
-    dispatcher.dispatch(
+    
+    import json
+
+    if not request_payload.get("is_auditable"):
+        logger.info("Auditing is disabled. Skipping audit processing.")
+        return
+        
+    operation_name = request_payload.get("operation_name")
+    if operation_name == 'UnknownOperation':
+        logger.info("Skipping audit: no data in GraphQL response")
+        return
+    
+    request_audit_payload = AuditHelper.build_request_payload(
         request=request,
-        request_payload=request_payload,
-        result=result,
-        metadata={
-            "decrypted_key": decrypted_key
-        },
-        audit_type="MESSAGE_LOG_INTERNAL"
+        payload=request_payload,
+        audit_type=audit_type
     )
 
+    status_code = result.status
+    message = result.message
+    data = result.data
+    error = result.error if result.error else message
+
+    if audit_type == Constant.MESSAGE_LOG_INTERNAL:
+        ERROR_PREFIXES = ("ERROR", "WARNING")
+        if isinstance(status_code, int):
+            is_error = not (200 <= status_code < 300)
+        elif isinstance(status_code, str):
+            is_error = status_code.upper().startswith(ERROR_PREFIXES)
+    else:
+        try:
+            is_error = not (200 <= status_code < 300)
+        except ValueError:
+            is_error = True
+
+    if is_error:
+        err_payload = AuditHelper.build_final_payload(
+            _type="ERROR",
+            status_code=status_code,
+            error=error
+        )
+        audit_message = request_audit_payload | err_payload
+    else:
+        if isinstance(result, Response):
+            
+            encryption_type = result.encryption_type
+            
+        
+            if encryption_type in VALID_TYPES and decrypted_key and data:
+                data = decryptor_data(encryption_type, decrypted_key, data)
+
+        res_payload = AuditHelper.build_final_payload(
+            _type="RESPONSE",
+            status_code=status_code,
+            result=data
+        )
+        audit_message = request_audit_payload | res_payload
+
+    message_log_id = request.headers.get("Idmessagelog")
+    if not message_log_id:
+        logger.warning("No Idmessagelog header found. Skipping audit storage.")
+        return
+    
+    data = json.dumps(audit_message)
+    # print(f"data: {data}")
+    # blob_name = f"audits/{message_log_id}.text"
+    # success = await storage.upload(blob_name, data)
+    
+    # if not success:
+    #     logger.error("Failed to upload audit log to storage. Skipping message dispatch.")
+    #     return
+    
+    # await messaging.send_message(blob_name)
+    
+    # dispatcher.dispatch(
+    #     request=request,
+    #     request_payload=request_payload,
+    #     result=result,
+    #     metadata={
+    #         "decrypted_key": decrypted_key
+    #     },
+    #     audit_type="MESSAGE_LOG_INTERNAL"
+    # )
+
 def resolver(public: bool = False, action=None):
 
     def decorator(func: Callable):
@@ -61,7 +139,7 @@ def resolver(public: bool = False, action=None):
                     token_service: IAuthTokenService = container.auth_token_service
                     user_token = extract_bearer_token(headers)
                     
-                    claims: UserTokenClaims = token_service.validate_internal_access_token(
+                    claims: UserTokenClaims = await token_service.validate_internal_access_token(
                         user_token
                     )
 
@@ -123,31 +201,45 @@ def resolver(public: bool = False, action=None):
 
                 if isinstance(result, Response):
                     decrypted_key = result.key if not token else token.aes_key_auth
-
-                dispatcher = AuditDispatcher(
-                    messaging=container.az_sb_audit,
-                    storage=container.az_blob_storage
-                )
                 
-                __test(
-                    dispatcher=dispatcher,
+                await __test(
+                    messaging=container.az_sb_audit,
+                    storage=container.az_blob_storage,
                     request_payload=request_payload,
                     request=request,
                     decrypted_key=decrypted_key,
-                    result=result
+                    result=result,
+                    audit_type="MESSAGE_LOG_INTERNAL"
                 )
 
                 return result
 
             except OSDException as e:
-                logger.warning(f"Business error: {str(e)}")
+                # logger.warning(f"Business error: {str(e)}")
+                if e.is_external:
+                    err_payload = AuditHelper.build_final_payload(
+                        _type="ERROR",
+                        status_code=e.status_code,
+                        error=result.error if result.error else e.message
+                    )
+                else:
+                    err_payload = AuditHelper.build_final_payload(
+                        _type="ERROR",
+                        status_code=e.audit_status_code,
+                        error=result.error if result.error else e.message
+                    )
                 return Response(
                     status=e.status_code,
                     message=e.message,
                     error=e.error
                 )
             except Exception as e:
-                logger.exception(f"Unexpected error: {str(e)}")
+                # logger.exception(f"Unexpected error: {str(e)}")
+                err_payload = AuditHelper.build_final_payload(
+                    _type="ERROR",
+                    status_code=StatusCode.INTERNAL_SERVER_ERROR,
+                    error=str(e)
+                )
                 return Response(
                     status=StatusCode.INTERNAL_SERVER_ERROR,
                     message="Could not process request.",

encryptors-2.57/src/Osdental/Enums/ErrorSource.py

@@ -0,0 +1,5 @@
+from enum import Enum
+
+class ErrorSource(str, Enum):
+    INTERNAL = "internal"
+    EXTERNAL = "external"

{encryptors-2.56 → encryptors-2.57}/src/Osdental/Exception/ControlledException.py

@@ -1,6 +1,7 @@
 from typing import Any
 from Osdental.Enums.StatusCode import StatusCode
 from Osdental.Constants.Message import Message
+from Osdental.Enums.ErrorSource import ErrorSource
 
 class OSDException(Exception):
     """ Base class for all custom exceptions. """
@@ -9,16 +10,28 @@ class OSDException(Exception):
         message: str = Message.UNEXPECTED_ERROR_MSG, 
         error: str = None, 
         status_code: Any = StatusCode.INTERNAL_SERVER_ERROR,
+        source: ErrorSource = ErrorSource.INTERNAL,
+        raw_status_code: Any = None,
     ):
         super().__init__(error)
         self.message = message
         self.error = error
         self.status_code = status_code
-
+        self.source = source
+        self.raw_status_code = raw_status_code
 
     def __str__(self):
         error_detail = self.error if self.error else "None"
-        return f"[{self.status_code}] {self.message} | {error_detail}"
+        return f"[{self.source} | {self.status_code}] {self.message} | {error_detail}]"
+    
+    @property
+    def is_external(self) -> bool:
+        return self.source == ErrorSource.EXTERNAL
+    
+    @property
+    def audit_status_code(self) -> Any:
+        """El que va a la auditoría: real si existe, propio si no."""
+        return self.raw_status_code if self.raw_status_code is not None else self.status_code
     
 class UnauthorizedException(OSDException):
     def __init__(
@@ -29,6 +42,8 @@ class UnauthorizedException(OSDException):
     ):
         super().__init__(message=message, error=error, status_code=status_code)
 
+    
+    
 class AccessDeniedException(OSDException):
     def __init__(
         self, 
@@ -119,5 +134,13 @@ class HttpClientException(OSDException):
         message: str = Message.UNEXPECTED_ERROR_MSG, 
         error: str = None, 
         status_code: str = StatusCode.INTERNAL_SERVER_ERROR,
+        source: ErrorSource = ErrorSource.EXTERNAL,
+        raw_status_code: Any = None,
     ):
-        super().__init__(message=message, error=error, status_code=status_code)
+        super().__init__(
+            message=message,
+            error=error,
+            status_code=status_code,
+            source=source,
+            raw_status_code=raw_status_code
+        )

{encryptors-2.56 → encryptors-2.57}/src/Osdental/Graphql/_Helpers/_AuditHelper.py

@@ -4,10 +4,10 @@ from typing import Dict, Literal, Any, Optional
 class AuditHelper:
         
     @staticmethod
-    async def build_request_payload(
+    def build_request_payload(
         request, 
         payload: Dict[str, Any], 
-        audit_type
+        audit_type: str
     ) -> Dict[str, Any]:
 
         default_value = "*"

{encryptors-2.56 → encryptors-2.57}/src/Osdental/Helpers/AuditDispatcher.py

@@ -91,8 +91,6 @@ class AuditDispatcher:
         result: Response | ApiResponse = payload["result"]
         audit_type = payload["audit_type"]
 
-        print(request_payload)
-
         if not request_payload.get("is_auditable"):
             logger.info("Auditing is disabled. Skipping audit processing.")
             return

{encryptors-2.56 → encryptors-2.57}/src/Osdental/Helpers/_AuthTokenProcessor.py

@@ -17,7 +17,6 @@ def extract_bearer_token(headers: Headers) -> str:
     return authorization.removeprefix("Bearer ").strip()
     
 
-
 def build_auth_token(
     claims: UserTokenClaims, 
     headers: Headers, 
@@ -31,6 +30,7 @@ def build_auth_token(
         decrypted_payload.get("idExternalEnterprise")
         if decrypted_payload else None
     )
+    mk_id_external_enterprise = None
 
     if external_enterprise_req:
         final_id = external_enterprise_req
@@ -50,7 +50,6 @@ def build_auth_token(
         
         final_id = str(UUID(int=0))
 
-
     token = AuthToken(
         id_token=claims.id_token,
         id_user=claims.id_user,

{encryptors-2.56 → encryptors-2.57}/src/Osdental/Http/APIClient.py

@@ -53,7 +53,8 @@ class APIClient:
             audit_http_error(exc.response, method, url, kwargs)
             raise HttpClientException(
                 status_code=StatusCode.BAD_GATEWAY,
-                error=exc.response.text
+                error=exc.response.text,
+                raw_status_code=exc.response.status_code,
             ) from exc
         
         except httpx.RequestError as exc:
@@ -61,7 +62,7 @@ class APIClient:
             audit_exception_error(exc, method, url, kwargs)
             raise HttpClientException(
                 status_code=StatusCode.GATEWAY_TIMEOUT,
-                error=str(exc)
+                error=str(exc),
             ) from exc
         
         except Exception as exc:

encryptors-2.56/src/Osdental/Models/AuditConfig.py

@@ -1,9 +0,0 @@
-from typing import Optional
-from dataclasses import dataclass
-
-@dataclass(frozen=True)
-class AuditConfig:
-    environment: str
-    microservice_name: str
-    microservice_version: str
-    is_auditable: Optional[bool] = True

encryptors-2.56/src/Osdental/Models/_Audit.py

@@ -1,14 +0,0 @@
-from dataclasses import dataclass, field
-from typing import Any, Optional
-from fastapi import Request
-from Osdental.Models.AuditConfig import AuditConfig
-
-
-@dataclass
-class Audit:
-    request: Request
-    audit_config: AuditConfig
-    payload: Any = field(default_factory=dict)
-    audit_type: str = field(default="MESSAGE_LOG_INTERNAL")
-    operation_name: Optional[str] = "Unknown"
-    full_name: Optional[str] = "Joe Doe"