Encryptors 2.28__tar.gz → 2.30__tar.gz

{encryptors-2.28 → encryptors-2.30}/PKG-INFO

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

{encryptors-2.28 → encryptors-2.30}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
  
 setup(
     name="Encryptors", 
-    version="2.28",
+    version="2.30",
     author="OSDental LLC",
     author_email="support@osdental.ai",
     description="End-to-end algorithm library",

{encryptors-2.28 → encryptors-2.30}/src/Encryptors.egg-info/PKG-INFO

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

{encryptors-2.28 → encryptors-2.30}/src/Encryptors.egg-info/SOURCES.txt

@@ -19,6 +19,7 @@ src/Osdental/Decorators/AuditLog.py
 src/Osdental/Decorators/DecryptedData.py
 src/Osdental/Decorators/Grpc.py
 src/Osdental/Decorators/Retry.py
+src/Osdental/Decorators/SecureResolver.py
 src/Osdental/Decorators/SqlDataNormalizer.py
 src/Osdental/Decorators/__init__.py
 src/Osdental/Encryptor/Aes.py
@@ -32,6 +33,13 @@ src/Osdental/Exception/ControlledException.py
 src/Osdental/Exception/__init__.py
 src/Osdental/ExternalHttp/Client.py
 src/Osdental/ExternalHttp/__init__.py
+src/Osdental/Graphql/__init__.py
+src/Osdental/Graphql/Extensions/AuditExtension.py
+src/Osdental/Graphql/Extensions/__init__.py
+src/Osdental/Graphql/_Helpers/_AuditHelper.py
+src/Osdental/Graphql/_Helpers/_TenantPolicy.py
+src/Osdental/Graphql/_Helpers/_TokenService.py
+src/Osdental/Graphql/_Helpers/__init__.py
 src/Osdental/Grpc/__init__.py
 src/Osdental/Grpc/Base/GrpcClientBase.py
 src/Osdental/Grpc/Base/__init__.py
@@ -42,6 +50,7 @@ src/Osdental/Grpc/Generated/Common_pb2_grpc.py
 src/Osdental/Grpc/Generated/Portal_pb2.py
 src/Osdental/Grpc/Generated/Portal_pb2_grpc.py
 src/Osdental/Grpc/Generated/__init__.py
+src/Osdental/Helpers/AuditDispatcher.py
 src/Osdental/Helpers/KeyVaultService.py
 src/Osdental/Helpers/__init__.py
 src/Osdental/InternalHttp/Request.py
@@ -51,6 +60,7 @@ src/Osdental/Messaging/AzureServiceBus.py
 src/Osdental/Messaging/Kafka.py
 src/Osdental/Messaging/RabbitMQ.py
 src/Osdental/Messaging/__init__.py
+src/Osdental/Models/AuditConfig.py
 src/Osdental/Models/CDataIntegration.py
 src/Osdental/Models/Catalog.py
 src/Osdental/Models/Legacy.py

encryptors-2.30/src/Osdental/Decorators/AuditLog.py

@@ -0,0 +1,87 @@
+import json
+import asyncio
+from typing import List, Dict, Any
+from functools import wraps
+from Osdental.InternalHttp.Request import CustomRequest
+from Osdental.InternalHttp.Response import CustomResponse
+from Osdental.Encryptor.Rsa import RSAEncryptor
+from Osdental.Exception.ControlledException import OSDException, RSAEncryptException, AESEncryptException
+from Osdental.Encryptor.Aes import AES
+from Osdental.Shared.Utils.TextProcessor import TextProcessor
+from Osdental.Shared.Logger import logger as custom_logger
+from Osdental.Models.Legacy import Legacy
+from Osdental.Grpc.Client.PortalClient import PortalClient
+from Osdental.Shared.Enums.Code import Code
+
+portal_client = PortalClient()
+aes = AES()
+
+
+
+def try_decrypt_or_return_raw(data: str, private_key_rsa: str, aes_key: str) -> str:
+    try:
+        return RSAEncryptor.decrypt(data, private_key_rsa, silent=True)
+    except RSAEncryptException:
+        try:
+            return aes.decrypt(aes_key, data, silent=True)
+        except AESEncryptException:
+            return data
+
+def enqueue_response(data: Any, headers: Dict[str,str], msg_info: str = None):
+    content = json.dumps(data) if isinstance(data, dict) else msg_info
+    custom_response = CustomResponse(content=content, headers=headers)
+    _ = asyncio.create_task(custom_response.send_to_service_bus())
+
+
+def handle_audit_and_exception():
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            headers = {}
+
+            
+            # Extract request and operation name before opening the span
+            try:
+                _, info = args[:2] 
+                request = info.context.get('request')
+                headers = info.context.get('headers') or {}
+                
+                if request:
+                    # Send audit of the request to Service Bus
+                    custom_request = CustomRequest(request)
+                    _ = asyncio.create_task(custom_request.send_to_service_bus())
+
+            except Exception as ex:
+                logger.warning(f"Failed to extract operationName: {ex}")
+
+            try:
+                # Get legacy
+                res = await portal_client.get_legacy()
+                data = json.loads(res.data)
+                legacy = Legacy.from_db(data) if res.status == Code.PROCESS_SUCCESS_CODE else None
+                # Run the resolver
+                response = await func(*args, **kwargs)
+                # Prepare data and message
+                msg_info = TextProcessor.concatenate(response.get('status'), '-', response.get('message'))
+                raw_data = response.get('data')
+                data_to_enqueue = None
+                if raw_data:
+                    data_to_enqueue = try_decrypt_or_return_raw(raw_data, legacy.private_key2, legacy.aes_key_auth)
+                # Enqueue response
+                enqueue_response(data_to_enqueue, headers, msg_info)
+                return response
+            except OSDException as ex:
+                # Controlled log
+                custom_logger.error(f'Controlled error: {str(ex)}')      
+                ex.headers = headers
+                _ = asyncio.create_task(ex.send_to_service_bus())
+                return ex.get_response()
+            except Exception as e:
+                # Unhandled exception log and span
+                custom_logger.error(f'Unexpected error: {str(e)}')      
+                ex = OSDException(error=str(e), headers=headers)
+                _ = asyncio.create_task(ex.send_to_service_bus())
+                return ex.get_response()
+
+        return wrapper
+    return decorator

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

@@ -0,0 +1,70 @@
+import inspect
+import asyncio
+from functools import wraps
+from typing import Callable, Dict, Any
+from graphql import GraphQLResolveInfo
+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
+from Osdental.Encryptor.Aes import AES
+
+
+aes = AES()
+def secure_resolver(action = None):
+    def decorator(func: Callable):
+
+        signature = inspect.signature(func)
+        accepts_data = "data" in signature.parameters
+
+        @wraps(func)
+        async def wrapper(obj: Any, info: GraphQLResolveInfo, **kwargs: Dict):
+            try:
+                token: AuthToken = info.context.token
+                payload = getattr(info.context, "decrypted_payload", None)
+                aes_key = getattr(info.context, "aes_key", None)
+
+                if action:
+                    if Profile(token.abbreviation) not in action.allowed_roles:
+                        raise OSDException("DB_ERROR_AUTH", "You are not authorized to perform this action.")
+
+                if accepts_data and payload:
+                    kwargs["data"] = payload
+
+                result: Response = await func(obj, info, **kwargs)
+
+                if result.data is not None:
+                    result.data = aes.encrypt(aes_key, result.data)
+
+                return result
+
+                # await info.context.audit_dispatcher.dispatch(
+                #     security=security,
+                #     result=result
+                # )
+
+                if result.data is not None:
+                    result.data = aes.encrypt(security.encryptor.aes_auth, result.data)
+                    
+
+                return result
+
+            except (Exception, OSDException) as e:
+                result = {
+                    "status": getattr(e, "status_code", "DB_ERROR_UNEXPECTED"),
+                    "message": getattr(e, "message", "Could not process request."),
+                    "error": getattr(e, "error", type(e).__name__),
+                    "data": None
+                }
+
+                # _ = asyncio.create_task(
+                #     info.context.audit_dispatcher.dispatch(
+                #         security=security,
+                #         result=result
+                #     )
+                # )
+
+                return result
+
+        return wrapper
+    return decorator

encryptors-2.30/src/Osdental/Graphql/Extensions/AuditExtension.py

@@ -0,0 +1,96 @@
+import time
+import json
+from graphql.pyutils import is_awaitable
+from ariadne.types import Extension
+from Osdental.Encryptor.Aes import AES
+from Osdental.Graphql._Helpers._TenantPolicy import TenantPolicy
+from Osdental.Models.Token import AuthToken
+
+class AuditExtension(Extension):
+
+    def request_started(self, context):
+        self.start_time = time.perf_counter()
+        self.errors = None
+        self.request_payload = None
+        self.result = None
+        self.aes = AES()
+
+    async def resolve(self, next_, root, info, **kwargs):
+
+        if not self.request_payload:
+            context = info.context
+
+            request = info.context.request
+            self.request = request
+
+            body = request.state.graphql_body
+
+            container = context.container
+
+            token_service = container.token_service
+
+            aes_key = request.app.state.aes_auth
+            if not aes_key:
+                raise ValueError("Could not find authorization key Aes.")
+
+            original_token = await token_service.authenticate(request)
+            
+            variables = body.get("variables") or {}
+            encrypted_payload = variables.get("data")
+
+            decrypted_payload = None
+
+            if encrypted_payload:
+                try:
+                    decrypted_payload = self.aes.decrypt(aes_key, encrypted_payload)
+
+                    try:
+                        decrypted_payload = json.loads(decrypted_payload)
+                    except Exception:
+                        pass
+
+                except Exception:
+                    decrypted_payload = None
+
+            token: AuthToken = TenantPolicy.resolve(
+                token=original_token,
+                headers=request.headers,
+                decrypted_payload=decrypted_payload,
+                operation_type=info.operation.operation.value
+            )
+            
+            self.request_payload = {
+                "operation_type": info.operation.operation.value,
+                "operation_name": body.get("operationName", "UnknownOperation"),
+                "query": body.get("query"),
+                "variables": decrypted_payload,
+                "user": token.user_full_name
+            }
+
+        context.decrypted_payload = decrypted_payload
+        context.token = token
+        context.aes_key = aes_key
+
+        result = next_(root, info, **kwargs)
+
+        if is_awaitable(result):
+            result = await result
+
+        if root is None:
+            self.result = result
+
+        return result
+
+    def has_errors(self, errors, context):
+        self.errors = errors
+
+    def request_finished(self, context):
+
+        dispatcher = context.request.app.state.audit_dispatcher
+
+        dispatcher.dispatch(
+            request=self.request,
+            request_payload=self.request_payload,
+            result=self.result,
+            errors=self.errors
+        )

encryptors-2.30/src/Osdental/Graphql/_Helpers/_AuditHelper.py

@@ -0,0 +1,64 @@
+import json
+from typing import Dict, Literal, Any, Optional
+from fastapi import Request
+from Osdental.Models.AuditConfig import AuditConfig
+
+class AuditHelper:
+        
+    @staticmethod
+    async def build_request_payload(
+        request: Request, 
+        audit_config: AuditConfig,
+        payload: Any = {},
+        operation_name: str = "Unknown",
+        full_name: str = "Joe Doe"
+    ) -> Dict:
+        
+        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": audit_config.environment,
+            "header": json.dumps(headers),
+            "microServiceUrl": str(request.url),
+            "microServiceName": audit_config.microservice_name,
+            "microServiceVersion": audit_config.microservice_version,
+            "serviceName": operation_name,
+            "machineNameUser": request.headers.get("Machinenameuser", default_value),
+            "ipUser": user_ip or default_value,
+            "userName": full_name,
+            "localitation": default_value,
+            "httpMethod": request.method,
+            "messageIn": json.dumps(payload) if payload else default_value,
+            "auditLog": "MESSAGE_LOG_INTERNAL"
+        }
+    
+    @staticmethod
+    def build_final_payload(
+        _type: Literal["RESPONSE", "ERROR"],
+        status_code: Any,
+        result: Optional[Any] = "*",
+        error: Optional[Any] = "*"
+    ):
+        return {
+            "type": _type,
+            "httpResponseCode": status_code,
+            "messageOut": json.dumps(result) if isinstance(result, dict) else result,
+            "errorProducer": error
+        }

encryptors-2.30/src/Osdental/Graphql/_Helpers/_TenantPolicy.py

@@ -0,0 +1,33 @@
+from Osdental.Encryptor.Aes import AES
+from uuid import UUID
+from graphql import OperationType
+
+class TenantPolicy:
+
+    @staticmethod
+    def resolve(token, headers, decrypted_payload, operation_type: str):
+        aes = AES()
+        # Solo aplicamos cambios si es QUERY
+        if operation_type != OperationType.QUERY.value:
+            return token  # devolver token tal cual
+
+        # SUPER ADMIN / OSDEL ADMIN -> UUID 0
+        if token.abbreviation.startswith(("SPAU", "OSDA")):
+            token.id_external_enterprise = str(UUID(int=0))
+            return token
+
+        # Marketing -> tomar dynamicClientId del header
+        if token.abbreviation.startswith("OSDMK"):
+            dynamic_client_id = headers.get("dynamicClientId")
+            if dynamic_client_id:
+                decrypted_mk_id = aes.decrypt(token.aes_key_auth, dynamic_client_id)
+                token.id_external_enterprise = decrypted_mk_id
+                token.mk_id_external_enterprise = decrypted_mk_id
+                return token
+
+        # If it comes by request, it is taken as priority
+        external_enterprise_req = decrypted_payload.get('idExternalEnterprise')
+        if external_enterprise_req and token:
+            token.id_external_enterprise = external_enterprise_req
+
+        return token

encryptors-2.30/src/Osdental/Graphql/_Helpers/_TokenService.py

@@ -0,0 +1,34 @@
+from Osdental.Encryptor.Aes import AES
+from Osdental.Encryptor.Jwt import JWT
+from Osdental.Models.Token import AuthToken
+
+class TokenService:
+
+    def __init__(self, jwt_user_key: str, auth_validator):
+        self.jwt_user_key = jwt_user_key
+        self.auth_validator = auth_validator
+        self.aes = AES()
+
+    async def authenticate(self, request):
+        authorization = request.headers.get("authorization")
+        if not authorization or not authorization.startswith("Bearer "):
+            raise ValueError("Missing Bearer token")
+
+        encrypted_token = authorization.split(" ")[1]
+
+        aes_user = request.app.state.aes_user
+
+        user_token = self.aes.decrypt(aes_user, encrypted_token)
+        payload = JWT.extract_payload(user_token, self.jwt_user_key)
+        token = AuthToken(**payload)
+
+        # Validate via RPC
+        request = {
+            'idToken': token.id_token,
+            'idUser': token.id_user
+        }
+        is_valid = await self.auth_validator.validate_auth_token(request)
+        if not is_valid:
+            raise ValueError("You are not authorized to access this portal.")
+
+        return token

encryptors-2.30/src/Osdental/Helpers/AuditDispatcher.py

@@ -0,0 +1,104 @@
+import asyncio
+import logging
+from Osdental.Models.AuditConfig import AuditConfig
+from Osdental.Messaging import IMessageQueue
+from Osdental.Graphql._Helpers._AuditHelper import AuditHelper
+
+class AuditDispatcher:
+
+    def __init__(self, messaging: IMessageQueue, audit_config: AuditConfig, max_queue_size: int = 5000):
+        self._messaging = messaging
+        self._audit_config = audit_config
+        self._queue = asyncio.Queue(maxsize=max_queue_size)
+        self._worker_task = None
+
+    # Se llama en startup
+    def start(self):
+        self._worker_task = asyncio.create_task(self._worker())
+
+    # Se llama en shutdown
+    async def stop(self):
+        # Esperar a que la cola se vacíe
+        await self._queue.join()
+
+        # Enviar sentinel para cerrar worker
+        await self._queue.put(None)
+
+        # Esperar a que el worker termine
+        if self._worker_task:
+            await self._worker_task
+
+    # Ultra rápido, no bloquea
+    def dispatch(self, request, request_payload, result, errors = None):
+        try:
+            payload = {
+                "request": request,
+                "request_payload": request_payload,
+                "result": result,
+                "errors": errors
+            }
+
+            self._queue.put_nowait(payload)
+
+        except asyncio.QueueFull:
+            logging.error("Audit queue full. Dropping message.")
+
+    # Worker real
+    async def _worker(self):        
+        while True:
+            payload = await self._queue.get()
+            # Sentinel detectado → salir limpio
+            if payload is None:
+                self._queue.task_done()
+                break
+
+            try:
+                await self._process(payload)
+            except Exception:
+                logging.exception("Audit processing failed")
+            finally:
+                self._queue.task_done()
+
+    # Logica
+    async def _process(self, payload):
+        request = payload["request"]
+        request_payload = payload["request_payload"]
+        result = payload["result"]
+
+        operation_name = request_payload.get("operation_name")
+        if operation_name == 'UnknownOperation':
+            logging.info("Skipping audit: no data in GraphQL response")
+            return
+        
+        request_audit_payload = await AuditHelper.build_request_payload(
+            request=request,
+            audit_config=self._audit_config,
+            operation_name=operation_name,
+            full_name=request_payload.get("user"),
+            payload=request_payload.get("variables")
+        )
+
+        status = result.get("status")
+        message = result.get("message")
+        data = result.get("data")
+        
+        ERROR_PREFIXES = ("DB_ERROR", "DB_WARNING")
+        if status.upper().startswith(ERROR_PREFIXES):
+            payload = AuditHelper.build_final_payload(
+                type="ERROR",
+                status_code=status,
+                error=message
+            )
+
+            audit_message = request_audit_payload | payload
+
+        else:
+            payload = AuditHelper.build_final_payload(
+                type="RESPONSE",
+                status_code="200",
+                result=data
+            )
+
+            audit_message = request_audit_payload | payload
+        
+        await self._messaging.enqueue(audit_message)

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

@@ -0,0 +1,7 @@
+from dataclasses import dataclass
+
+@dataclass(frozen=True)
+class AuditConfig:
+    environment: str
+    microservice_name: str
+    microservice_version: str

{encryptors-2.28 → encryptors-2.30}/src/Osdental/Models/Response.py

@@ -1,5 +1,4 @@
 from dataclasses import dataclass, field, asdict
-from enum import Enum
 from Osdental.Shared.Enums.Code import Code
 from Osdental.Shared.Enums.Message import Message
 
@@ -9,12 +8,5 @@ class Response:
     message: str = field(default=Message.PROCESS_SUCCESS_MSG)
     data: str = field(default=None)
 
-    def __post_init__(self):
-        # Asegura que status y message sean str si son Enum
-        if isinstance(self.status, Enum):
-            self.status = str(self.status)
-        if isinstance(self.message, Enum):
-            self.message = str(self.message)
-
     def send(self):
         return asdict(self)

encryptors-2.30/src/Osdental/Models/Token.py

@@ -0,0 +1,25 @@
+from typing import Optional
+from pydantic import BaseModel, Field
+from Osdental.Models.Legacy import Legacy
+
+class AuthToken(BaseModel):
+    
+    id_token: str = Field(alias="idToken")
+    id_user: str = Field(alias="idUser")
+    id_external_enterprise: str = Field(alias="idExternalEnterprise")
+    id_profile: str = Field(alias="idProfile")
+    id_legacy: str = Field(alias="idLegacy")
+    id_authorization: str = Field(default=None, alias="idAuthorization")
+    id_item_report: str = Field(alias="idItemReport")
+    id_enterprise: str = Field(alias="idEnterprise")
+    user_full_name: str = Field(alias="userFullName")
+    abbreviation: str = Field(alias="abbreviation")
+    aes_key_auth: str = Field(alias="aesKeyAuth")
+    access_token: Optional[str] = Field(default=None, alias="accessToken")
+    base_id_external_enterprise: Optional[str] = Field(default=None, alias="baseIdExternalEnterprise")
+    mk_id_external_enterprise: Optional[str] = Field(default=None, alias="mkIdExternalEnterprise")
+    jwt_user_key: Optional[str] = Field(default=None, alias="jwtUserKey")
+    legacy: Optional[Legacy] = Field(default=None, alias="legacy")
+
+    class ConfigDict:
+        populate_by_name = True

encryptors-2.28/src/Osdental/Decorators/AuditLog.py

@@ -1,158 +0,0 @@
-import json
-import asyncio
-import logging
-import time
-from typing import List, Dict, Any
-from functools import wraps
-from azure.monitor.opentelemetry import configure_azure_monitor
-from opentelemetry import trace
-from Osdental.InternalHttp.Request import CustomRequest
-from Osdental.InternalHttp.Response import CustomResponse
-from Osdental.Encryptor.Rsa import RSAEncryptor
-from Osdental.Exception.ControlledException import OSDException, RSAEncryptException, AESEncryptException
-from Osdental.Encryptor.Aes import AES
-from Osdental.Shared.Utils.TextProcessor import TextProcessor
-from Osdental.Shared.Logger import logger as custom_logger
-from Osdental.Models.Legacy import Legacy
-from Osdental.Grpc.Client.PortalClient import PortalClient
-from Osdental.Shared.Enums.Code import Code
-from Osdental.Shared.Config import Config
-from Osdental.Shared.Enums.Constant import Constant
-
-portal_client = PortalClient()
-aes = AES()
-
-# Configuration Azure Monitor
-configure_azure_monitor(
-    connection_string=Config.APPLICATIONINSIGHTS_CONNECTION_STRING
-)
-# Logger
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger('graphql')
-logger.setLevel(logging.INFO)
-# Tracer for spans
-tracer = trace.get_tracer(__name__)
-
-def split_into_batches(data: List[Any], batch:int = 250):
-    for i in range(0, len(data), batch):
-        yield data[i:i + batch]
-
-def try_decrypt_or_return_raw(data: str, private_key_rsa: str, aes_key: str) -> str:
-    try:
-        return RSAEncryptor.decrypt(data, private_key_rsa, silent=True)
-    except RSAEncryptException:
-        try:
-            return aes.decrypt(aes_key, data, silent=True)
-        except AESEncryptException:
-            return data
-
-def enqueue_response(data: Any, batch: int, headers: Dict[str,str], msg_info: str = None):
-    if data and isinstance(data, list):
-        if batch > 0 and len(data) > batch:
-            batches = split_into_batches(data, batch)
-            for idx, data_batch in enumerate(batches, start=1):
-                custom_response = CustomResponse(content=json.dumps(data_batch), headers=headers, batch=idx)
-                _ = asyncio.create_task(custom_response.send_to_service_bus())
-        else:
-            custom_response = CustomResponse(content=json.dumps(data), headers=headers)
-            _ = asyncio.create_task(custom_response.send_to_service_bus())
-    else:
-        content = json.dumps(data) if isinstance(data, dict) else msg_info
-        custom_response = CustomResponse(content=content, headers=headers)
-        _ = asyncio.create_task(custom_response.send_to_service_bus())
-
-
-def handle_audit_and_exception(batch: int = 0):
-    def decorator(func):
-        @wraps(func)
-        async def wrapper(*args, **kwargs):
-            headers = {}
-            operation_name = 'UnknownOperation'
-            
-            # Extract request and operation name before opening the span
-            try:
-                _, info = args[:2] 
-                request = info.context.get('request')
-                headers = info.context.get('headers') or {}
-                
-                if request:
-                    body = await request.body()
-                    try:
-                        body_data = json.loads(body.decode("utf-8"))
-                        operation_name = body_data.get('operationName', 'UnknownOperation')
-                    except Exception:
-                        pass
-                    
-                    # Send audit of the request to Service Bus
-                    custom_request = CustomRequest(request)
-                    _ = asyncio.create_task(custom_request.send_to_service_bus())
-
-            except Exception as ex:
-                logger.warning(f"Failed to extract operationName: {ex}")
-
-            # Open the span with the correct operation name
-            with tracer.start_as_current_span(f"GraphQL.{operation_name}") as span:
-                start_time = time.time()
-                try:
-                    # Get legacy
-                    res = await portal_client.get_legacy()
-                    data = json.loads(res.data)
-                    legacy = Legacy.from_db(data) if res.status == Code.PROCESS_SUCCESS_CODE else None
-
-                    # Run the resolver
-                    response = await func(*args, **kwargs)
-
-                    # Prepare data and message
-                    msg_info = TextProcessor.concatenate(response.get('status'), '-', response.get('message'))
-                    raw_data = response.get('data')
-                    data_to_enqueue = None
-                    if raw_data:
-                        data_to_enqueue = try_decrypt_or_return_raw(raw_data, legacy.private_key2, legacy.aes_key_auth)
-
-                    # Enqueue response
-                    enqueue_response(data_to_enqueue, batch, headers, msg_info)
-
-                    # Measure duration
-                    duration = (time.time() - start_time) * 1000
-
-                    # Span attributes
-                    span.set_attribute(Constant.GRAPHQL_OPERATION_NAME, operation_name)
-                    span.set_attribute(Constant.GRAPHQL_STATUS, response.get('status'))
-                    span.set_attribute(Constant.GRAPHQL_MESSAGE, response.get('message'))
-                    span.set_attribute(Constant.GRAPHQL_DURATION_MS, duration)
-
-                    return response
-
-                except OSDException as ex:
-                    # Controlled log
-                    custom_logger.error(f'Controlled error: {str(ex)}')      
-                    duration = (time.time() - start_time) * 1000
-                    msg = str(ex) if str(ex) else getattr(ex, 'message', 'OSDException')
-                    span.set_attribute(Constant.GRAPHQL_OPERATION_NAME, operation_name)
-                    span.set_attribute(Constant.GRAPHQL_STATUS, ex.status_code)
-                    span.set_attribute(Constant.GRAPHQL_MESSAGE, msg)
-                    span.set_attribute(Constant.GRAPHQL_DURATION_MS, duration)
-                    ex.headers = headers
-                    span.record_exception(ex)
-
-                    _ = asyncio.create_task(ex.send_to_service_bus())
-                    return ex.get_response()
-
-                except Exception as e:
-                    # Unhandled exception log and span
-                    custom_logger.error(f'Unexpected error: {str(e)}')      
-                    ex = OSDException(error=str(e), headers=headers)
-                    msg = str(e) if str(e) else getattr(ex, 'message', 'Unknown Exception')
-                    duration = (time.time() - start_time) * 1000
-                    span.set_attribute(Constant.GRAPHQL_OPERATION_NAME, operation_name)
-                    span.set_attribute(Constant.GRAPHQL_STATUS, ex.status_code)
-                    span.set_attribute(Constant.GRAPHQL_MESSAGE, msg)
-                    span.record_exception(e)
-                    span.set_status(trace.status.Status(trace.status.StatusCode.ERROR))
-                    span.set_attribute(Constant.GRAPHQL_DURATION_MS, duration)
-                    
-                    _ = asyncio.create_task(ex.send_to_service_bus())
-                    return ex.get_response()
-
-        return wrapper
-    return decorator

encryptors-2.28/src/Osdental/Models/Token.py

@@ -1,43 +0,0 @@
-from __future__ import annotations
-from dataclasses import dataclass
-from typing import Optional, Dict
-from Osdental.Models.Legacy import Legacy
-from Osdental.Shared.Utils.CaseConverter import CaseConverter
-from Osdental.Exception.ControlledException import MissingFieldException
-
-@dataclass
-class AuthToken:
-    id_token: str
-    id_user: str
-    id_external_enterprise: str
-    id_profile: str
-    id_legacy: str
-    id_item_report: str
-    id_enterprise: str
-    id_authorization: str
-    user_full_name: str
-    abbreviation: str
-    aes_key_auth: str
-    access_token: Optional[str] = None
-    base_id_external_enterprise: Optional[str] = None
-    mk_id_external_enterprise: Optional[str] = None
-    jwt_user_key: Optional[str] = None
-    legacy: Optional[Legacy] = None
-
-    def __post_init__(self):
-        required_fields = [
-            'id_token', 'id_user', 'id_external_enterprise', 'id_profile',
-            'id_legacy', 'id_item_report', 'id_enterprise', 'id_authorization',
-            'user_full_name', 'abbreviation', 'aes_key_auth'
-        ]
-        missing = [f for f in required_fields if not getattr(self, f)]
-        if missing:
-            raise MissingFieldException(error=f"Missing required fields: {', '.join(missing)}")
-
-        
-    @classmethod
-    def from_jwt(cls, payload: Dict[str,str]) -> AuthToken:
-        mapped = {CaseConverter.case_to_snake(key): value for key, value in payload.items()}
-        valid_fields = cls.__dataclass_fields__.keys()
-        clean = {k: v for k, v in mapped.items() if k in valid_fields}
-        return cls(**clean)