Encryptors 2.56__tar.gz → 2.58__tar.gz

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

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

{encryptors-2.56 → encryptors-2.58}/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.58",
     author="OSDental LLC",
     author_email="support@osdental.ai",
     description="End-to-end algorithm library",

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

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

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

@@ -27,6 +27,8 @@ src/Osdental/Encryptor/Jwt.py
 src/Osdental/Encryptor/Rsa.py
 src/Osdental/Encryptor/Sha512.py
 src/Osdental/Encryptor/__init__.py
+src/Osdental/Enums/AuditType.py
+src/Osdental/Enums/ErrorSource.py
 src/Osdental/Enums/FileType.py
 src/Osdental/Enums/GrahpqlOperation.py
 src/Osdental/Enums/Profile.py
@@ -45,6 +47,7 @@ src/Osdental/Graphql/_Helpers/_TenantPolicy.py
 src/Osdental/Graphql/_Helpers/_TokenService.py
 src/Osdental/Graphql/_Helpers/__init__.py
 src/Osdental/Helpers/AuditDispatcher.py
+src/Osdental/Helpers/AuditHelper.py
 src/Osdental/Helpers/AzureClassifier.py
 src/Osdental/Helpers/GrpcConnection.py
 src/Osdental/Helpers/JwtTokenHelper.py
@@ -60,12 +63,11 @@ 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/AuditContext.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
@@ -75,6 +77,7 @@ src/Osdental/Rest/Middlewares/__init__.py
 src/Osdental/Secrets/AzureKeyVaultProvider.py
 src/Osdental/Secrets/__init__.py
 src/Osdental/Services/JwtAuthTokenService.py
+src/Osdental/Services/ServiceBusAuditEmitter.py
 src/Osdental/Services/WebsocketClient.py
 src/Osdental/Services/__init__.py
 src/Osdental/Storage/AzureBlobStorage.py

{encryptors-2.56 → encryptors-2.58}/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.58}/src/Osdental/Decorators/SecureResolver.py

@@ -1,6 +1,6 @@
 import logging
 from functools import wraps
-from typing import Callable, Dict, Any
+from typing import Callable
 from graphql import GraphQLResolveInfo
 from Osdental.Models.Response import Response
 from Osdental.Graphql.Models import BaseGraphQLContext
@@ -15,29 +15,15 @@ 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.Models.AuditContext import AuditContext
+from Osdental.Helpers.AuditHelper import (
+    _build_success_payload, _build_error_payload, _build_unexpected_payload
+)
 
 
 logger = logging.getLogger(__name__)
 
 
-def __test(
-    dispatcher: AuditDispatcher, 
-    request,
-    request_payload: Dict[str, Any],
-    result: Response,
-    decrypted_key: str
-) -> None:
-
-    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):
 
@@ -61,7 +47,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
                     )
 
@@ -97,57 +83,46 @@ def resolver(public: bool = False, action=None):
                             error="User not allowed to perform this action"
                         )
 
-                # ── 5. EJECUTAR RESOLVER ──────────────────────────
+                # ── 5. CONTEXTO DE AUDITORÍA ──────────────
+                # Lo construimos antes del resolver para que siempre exista
+
+                audit_ctx = AuditContext.from_request(
+                    request=request,
+                    settings=settings,
+                    body=body,
+                    operation_type=info.operation.operation.value,
+                    token=token,
+                    decrypted_payload=decrypted_payload,
+                )
+
+                # ── 6. EJECUTAR RESOLVER ──────────────────
                 result = await func(obj, info, **kwargs)
 
                 if not isinstance(result, Response):
                     raise TypeError("Resolver must return a Response instance")
 
-                
-
-                request_payload = {
-                    "env": settings.environment,
-                    "ms_name": settings.microservice_name,
-                    "ms_version": settings.microservice_version,
-                    "is_auditable": settings.is_auditable,
-                    "operation_type": info.operation.operation.value,
-                    "operation_name": body.get("operationName", "UnknownOperation"),
-                    "query": body.get("query"),
-                    "variables": decrypted_payload,
-                    "user": (
-                        token.user_full_name 
-                        if token 
-                        else "Public"
-                    )
-                }
-
-                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,
-                    request_payload=request_payload,
-                    request=request,
-                    decrypted_key=decrypted_key,
-                    result=result
+                # ── 7. AUDITAR ÉXITO ──────────────────────
+                await container.audit_emitter.emit(
+                    _build_success_payload(audit_ctx, result)
                 )
 
                 return result
 
             except OSDException as e:
-                logger.warning(f"Business error: {str(e)}")
+                # logger.warning(f"Business error: {str(e)}")
+                await container.audit_emitter.emit(
+                    _build_error_payload(audit_ctx, e)
+                )
                 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)}")
+                await container.audit_emitter.emit(
+                    _build_unexpected_payload(audit_ctx, e)
+                )
                 return Response(
                     status=StatusCode.INTERNAL_SERVER_ERROR,
                     message="Could not process request.",

encryptors-2.58/src/Osdental/Enums/AuditType.py

@@ -0,0 +1,5 @@
+from enum import StrEnum
+
+class AuditType(StrEnum):
+    INTERNAL = "MESSAGE_LOG_INTERNAL"
+    EXTERNAL = "MESSAGE_LOG_EXTERNAL"

encryptors-2.58/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.58}/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.58}/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.58}/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.58/src/Osdental/Helpers/AuditHelper.py

@@ -0,0 +1,118 @@
+import json
+from fastapi import Request
+from typing import Optional, Dict, Any, Literal
+from Osdental.Models.AuditContext import AuditContext
+from Osdental.Models.Response import Response
+from Osdental.Exception.ControlledException import OSDException
+from Osdental.Enums.StatusCode import StatusCode
+from Osdental.Enums.AuditType import AuditType
+
+def build_request_payload(
+    request: Request, 
+    payload: Dict[str, Any], 
+    audit_type: str
+) -> Dict[str, Any]:
+
+    default_value = "*"
+
+    user_ip = request.headers.get("X-Forwarded-For")
+    if user_ip:
+        user_ip = user_ip.split(",")[0]
+    else:
+        user_ip = getattr(request.client, "host", "*")
+
+    SAFE_HEADERS = {
+        "user-agent",
+        "host",
+        "origin",
+        "referer",
+        "content-type"
+    }
+
+    headers = {
+        k: v 
+        for k, v in request.headers.items() 
+        if k.lower() in SAFE_HEADERS
+    }
+
+    return {
+        "idMessageLog": request.headers.get("Idmessagelog"),
+        "environment": payload.get("env"),
+        "header": json.dumps(headers),
+        "microServiceUrl": str(request.url),
+        "microServiceName": payload.get("ms_name"),
+        "microServiceVersion": payload.get("ms_version"),
+        "serviceName": payload.get("operation_name"),
+        "machineNameUser": request.headers.get("Machinenameuser", default_value),
+        "ipUser": user_ip or default_value,
+        "userName": payload.get("user"),
+        "localitation": default_value,
+        "httpMethod": request.method,
+        "messageIn": json.dumps(payload) if payload else default_value,
+        "auditLog": audit_type,
+    }
+
+def _build_final_payload(
+    type_: Literal["RESPONSE", "ERROR"],
+    status_code: int,
+    result: Optional[Any] = None,
+    error: Optional[Any] = None
+) -> Dict[str, Any]:
+
+    result = "*" if result is None else result
+    error = "*" if error is None else error
+
+    if isinstance(result, (dict, list)):
+        result = json.dumps(result)
+
+    return {
+        "type": type_,
+        "httpResponseCode": status_code,
+        "messageOut": result,
+        "errorProducer": error
+    }
+
+def _build_success_payload(ctx: Optional[AuditContext], result: Response) -> Dict[str, Any]:
+    base = _base_payload(ctx, AuditType.INTERNAL)
+    return base | _build_final_payload(
+        type_="RESPONSE",
+        status_code=result.status,
+        result=result.data
+    )
+
+def _build_error_payload(ctx: Optional[AuditContext], exc: OSDException) -> Dict[str, Any]:
+    base = _base_payload(ctx, AuditType.INTERNAL)
+    return base | _build_final_payload(
+        type_="ERROR",
+        status_code=exc.audit_status_code,
+        error=exc.error or exc.message
+    )
+
+def _build_unexpected_payload(ctx: Optional[AuditContext], exc: Exception) -> Dict[str, Any]:
+    base = _base_payload(ctx, AuditType.INTERNAL)
+    return base | _build_final_payload(
+        type_="ERROR",
+        status_code=StatusCode.INTERNAL_SERVER_ERROR,
+        error=str(exc)
+    )
+
+def _base_payload(ctx: Optional[AuditContext], audit_type: AuditType = AuditType.INTERNAL) -> Dict[str, Any]:
+    if not ctx:
+        return {"user": "unknown", "operation_name": "unknown"}
+    
+    return {
+        "idMessageLog": ctx.message_log_id,
+        "environment": ctx.env,
+        "header": json.dumps(ctx.headers or {}),
+        "microServiceUrl": ctx.url,
+        "microServiceName": ctx.ms_name,
+        "microServiceVersion": ctx.ms_version,
+        "serviceName": ctx.operation_name,
+        "machineNameUser": "*",
+        "ipUser": ctx.user_ip or "*",
+        "userName": ctx.user,
+        "localitation": "*",
+        "httpMethod": ctx.http_method,
+        "messageIn": json.dumps(ctx.variables) if ctx.variables else "*",
+        "auditLog": audit_type,
+    }

{encryptors-2.56 → encryptors-2.58}/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.58}/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.58/src/Osdental/Models/AuditContext.py

@@ -0,0 +1,61 @@
+from dataclasses import dataclass
+from typing import Optional, Dict, Any
+from fastapi import Request
+
+
+@dataclass
+class AuditContext:
+    env: str
+    ms_name: str
+    ms_version: str
+    is_auditable: bool
+    operation_type: str
+    operation_name: str
+    query: Optional[str]
+    variables: Optional[Dict[str, Any]]
+    user: str
+    message_log_id: Optional[str]
+    decrypted_key: Optional[str] = None
+    user_ip: Optional[str] = None
+    headers: Optional[Dict[str, str]] = None
+    url: Optional[str] = None
+    http_method: Optional[str] = None
+
+    SAFE_HEADERS = {"user-agent", "host", "origin", "referer", "content-type"}
+
+    @classmethod
+    def from_request(
+        cls,
+        request: Request,
+        settings,
+        body: Dict,
+        operation_type: str,
+        token=None,
+        decrypted_payload=None,
+    ) -> "AuditContext":
+        
+        user_ip = request.headers.get("X-Forwarded-For")
+        user_ip = user_ip.split(",")[0] if user_ip else getattr(request.client, "host", "*")
+
+        safe_headers = {
+            k: v for k, v in request.headers.items()
+            if k.lower() in cls.SAFE_HEADERS
+        }
+
+        return cls(
+            env=settings.environment,
+            ms_name=settings.microservice_name,
+            ms_version=settings.microservice_version,
+            is_auditable=settings.is_auditable,
+            operation_type=operation_type,
+            operation_name=body.get("operationName", "UnknownOperation"),
+            query=body.get("query"),
+            variables=decrypted_payload,
+            user=token.user_full_name if token else "Public",
+            message_log_id=request.headers.get("Idmessagelog"),
+            decrypted_key=token.aes_key_auth if token else None,
+            user_ip=user_ip,
+            headers=safe_headers,
+            url=str(request.url),
+            http_method=request.method,
+        )

encryptors-2.58/src/Osdental/Services/ServiceBusAuditEmitter.py

@@ -0,0 +1,17 @@
+import json
+from typing import Dict, Any
+from Osdental.Messaging import IMessageQueue
+from Osdental.Storage import IStorageService
+
+class ServiceBusAuditEmitter:
+    
+    def __init__(self, messaging: IMessageQueue, storage: IStorageService):
+        self._messaging = messaging
+        self._storage = storage
+
+    async def emit(self, payload: Dict[str, Any]) -> None:
+        message_log_id = payload.get("idMessageLog")
+        data = json.dumps(payload)
+        blob_name = f"audits/{message_log_id}.text"
+        await self._storage.upload(blob_name, data)
+        await self._messaging.send_message(blob_name)

{encryptors-2.56 → encryptors-2.58}/src/Osdental/Services/__init__.py

@@ -1,4 +1,5 @@
 from abc import ABC, abstractmethod
+from typing import Protocol, Any, Dict
 from Osdental.Models.Notification import Notification
 
 class INotificationPublisher(ABC):
@@ -44,4 +45,9 @@ class IAuthTokenService(ABC):
         self,
         token: str,
     ) -> ActionTokenClaims:
-        pass
+        pass
+
+
+class IAuditEmitter(Protocol):
+    async def emit(self, payload: Dict[str, Any]) -> None:
+        ...

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"