Encryptors 2.54__tar.gz → 2.57__tar.gz

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

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

{encryptors-2.54 → 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.54",
+    version="2.57",
     author="OSDental LLC",
     author_email="support@osdental.ai",
     description="End-to-end algorithm library",

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

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

{encryptors-2.54 → 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.54 → 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.57/src/Osdental/Decorators/SecureResolver.py

@@ -0,0 +1,250 @@
+import logging
+from functools import wraps
+from typing import Callable, Dict, Any
+from graphql import GraphQLResolveInfo
+from Osdental.Models.Response import Response
+from Osdental.Graphql.Models import BaseGraphQLContext
+from Osdental.Models.TokenClaims import UserTokenClaims
+from Osdental.Models.Token import AuthToken
+from Osdental.Enums.Profile import Profile
+from Osdental.Exception.ControlledException import (
+    OSDException, AccessDeniedException
+)
+from Osdental.Services import IAuthTokenService
+from Osdental.Helpers._AuthTokenProcessor import (
+    extract_bearer_token, build_auth_token, decrypt_and_parse_payload
+)
+from Osdental.Enums.StatusCode import StatusCode
+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__)
+
+
+async def __test(
+    messaging: IMessageQueue,
+    storage: IStorageService,
+    request_payload: Dict[str, Any],
+    request,
+    result: Response,
+    decrypted_key: str,
+    audit_type: str
+) -> None:
+    
+    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,
+        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):
+        func._is_public = public
+
+        @wraps(func)
+        async def wrapper(obj, info: GraphQLResolveInfo, **kwargs):
+            try:
+                context: BaseGraphQLContext = info.context
+                container = context.container
+                request = context.request
+                headers = request.headers
+                settings = container.settings
+
+                token: type[AuthToken] | None = None
+
+                # ── 1. AUTENTICACIÓN ──────────────────────────────
+                if not public:
+
+                    token_service: IAuthTokenService = container.auth_token_service
+                    user_token = extract_bearer_token(headers)
+                    
+                    claims: UserTokenClaims = await token_service.validate_internal_access_token(
+                        user_token
+                    )
+
+                # ── 2. DECRYPT DEL PAYLOAD ────────────────────────
+                body = await request.json()
+                variables = body.get("variables") or {}
+                encrypted_payload = kwargs.get("data") or variables.get("data")
+                decrypted_payload = None
+
+                if not public and encrypted_payload is not None:
+                    decrypted_payload = decrypt_and_parse_payload(
+                        aes_key_auth=claims.aes_key_auth,
+                        encrypted_payload=encrypted_payload
+                    )
+
+                    kwargs["data"] = decrypted_payload
+
+                # ── 3. TENANT POLICY ──────────────────────────────
+                if not public:
+
+                    token = build_auth_token(
+                        claims=claims,
+                        headers=request.headers,
+                        decrypted_payload=decrypted_payload,
+                        operation_type=info.operation.operation.value
+                    )
+
+                # ── 4. CONTROL DE ACCESO POR ROL ─────────────────
+                if not public and action:
+                    if Profile(token.abbreviation) not in action.allowed_roles:
+                        raise AccessDeniedException(
+                            status_code=StatusCode.BUSINESS_RULE_WARNING,
+                            error="User not allowed to perform this action"
+                        )
+
+                # ── 5. 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
+                
+                await __test(
+                    messaging=container.az_sb_audit,
+                    storage=container.az_blob_storage,
+                    request_payload=request_payload,
+                    request=request,
+                    decrypted_key=decrypted_key,
+                    result=result,
+                    audit_type="MESSAGE_LOG_INTERNAL"
+                )
+
+                return result
+
+            except OSDException as 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)}")
+                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.",
+                    error=str(e)
+                )
+
+        return wrapper
+    return decorator

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.54 → 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.54 → encryptors-2.57}/src/Osdental/Graphql/_Helpers/_AuditHelper.py

@@ -1,14 +1,14 @@
 import json
 from typing import Dict, Literal, Any, Optional
-from Osdental.Models._Audit import Audit
 
 class AuditHelper:
         
     @staticmethod
-    async def build_request_payload(audit: Audit) -> Dict[str, Any]:
-        request = audit.request
-        audit_config = audit.audit_config
-        payload = audit.payload
+    def build_request_payload(
+        request, 
+        payload: Dict[str, Any], 
+        audit_type: str
+    ) -> Dict[str, Any]:
 
         default_value = "*"
 
@@ -30,19 +30,19 @@ class AuditHelper:
 
         return {
             "idMessageLog": request.headers.get("Idmessagelog"),
-            "environment": audit_config.environment,
+            "environment": payload.get("env"),
             "header": json.dumps(headers),
             "microServiceUrl": str(request.url),
-            "microServiceName": audit_config.microservice_name,
-            "microServiceVersion": audit_config.microservice_version,
-            "serviceName": audit.operation_name,
+            "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": audit.full_name,
+            "userName": payload.get("user"),
             "localitation": default_value,
             "httpMethod": request.method,
             "messageIn": json.dumps(payload) if payload else default_value,
-            "auditLog": audit.audit_type
+            "auditLog": audit_type,
         }
     
     @staticmethod
@@ -64,4 +64,4 @@ class AuditHelper:
             "httpResponseCode": status_code,
             "messageOut": result,
             "errorProducer": error
-        }
+        }

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

@@ -2,12 +2,10 @@ import logging
 import asyncio
 from typing import Dict, Any, Optional
 from fastapi import Request
-from Osdental.Models.AuditConfig import AuditConfig
 from Osdental.Messaging import IMessageQueue
 from Osdental.Graphql._Helpers._AuditHelper import AuditHelper
 from Osdental.Storage import IStorageService
 from Osdental.Helpers.ResponseDecryptor import decryptor_data, VALID_TYPES
-from Osdental.Models._Audit import Audit
 from Osdental.Models.Response import Response
 from Osdental.Models.ApiResponse import ApiResponse
 from Osdental.Constants.Constant import Constant
@@ -21,19 +19,14 @@ class AuditDispatcher:
         self, 
         messaging: IMessageQueue, 
         storage: IStorageService,
-        audit_config: AuditConfig, 
         max_queue_size: int = 5000
     ):
         self._messaging = messaging
         self._storage = storage
-        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
@@ -56,6 +49,9 @@ class AuditDispatcher:
         audit_type: str = None
     ):
         try:
+            if self._worker_task is None:
+                self._worker_task = asyncio.create_task(self._worker())
+        
             payload = {
                 "request": request,
                 "request_payload": request_payload,
@@ -87,31 +83,28 @@ class AuditDispatcher:
 
     # Logica
     async def _process(self, payload: Dict[str, Any]) -> None:
-        if not self._audit_config.is_auditable:
-            logger.info("Auditing is disabled. Skipping audit processing.")
-            return
-        
+
         import json
-        
+
         request = payload["request"]
         request_payload = payload["request_payload"]
         result: Response | ApiResponse = payload["result"]
         audit_type = payload["audit_type"]
+
+        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
         
-        audit = Audit(
-            audit_type=audit_type,
+        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", "Joe Doe"),
-            payload=request_payload.get("variables")
+            payload=request_payload,
+            audit_type=audit_type
         )
-        request_audit_payload = await AuditHelper.build_request_payload(audit=audit)
 
         status_code = result.status
         message = result.message
@@ -168,6 +161,7 @@ class AuditDispatcher:
         data = json.dumps(audit_message)
         blob_name = f"audits/{message_log_id}.text"
         success = await self._storage.upload(blob_name, data)
+        
         if not success:
             logger.error("Failed to upload audit log to storage. Skipping message dispatch.")
             return

{encryptors-2.54 → 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.54 → 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.54 → encryptors-2.57}/src/Osdental/Services/JwtAuthTokenService.py

@@ -79,7 +79,6 @@ class JwtAuthTokenService(IAuthTokenService):
         claims = self._jwt.validate_token(
             token=token,
             options=TokenValidationOptions(
-                validate_expiration=True,
                 validate_issuer=False,
                 validate_audience=False,
             )
@@ -103,7 +102,6 @@ class JwtAuthTokenService(IAuthTokenService):
         claims = self._jwt.validate_token(
             token=token,
             options=TokenValidationOptions(
-                validate_expiration=True,
                 validate_issuer=False,
                 validate_audience=False,
             )
@@ -127,7 +125,6 @@ class JwtAuthTokenService(IAuthTokenService):
             options=TokenValidationOptions(
                 issuer=self._issuer,
                 audience=self._audience,
-                validate_expiration=True,
                 validate_issuer=True,
                 validate_audience=True,
             )

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

@@ -1,139 +0,0 @@
-import logging
-from functools import wraps
-from typing import Callable
-from graphql import GraphQLResolveInfo
-from Osdental.Models.Response import Response
-from Osdental.Graphql.Models import BaseGraphQLContext
-from Osdental.Models.TokenClaims import UserTokenClaims
-from Osdental.Models.Token import AuthToken
-from Osdental.Enums.Profile import Profile
-from Osdental.Exception.ControlledException import (
-    OSDException, AccessDeniedException
-)
-from Osdental.Services import IAuthTokenService
-from Osdental.Helpers._AuthTokenProcessor import (
-    extract_bearer_token, build_auth_token, decrypt_and_parse_payload
-)
-from Osdental.Enums.StatusCode import StatusCode
-
-
-logger = logging.getLogger(__name__)
-
-
-def __test(dispatcher, request, request_payload, result, decrypted_key):
-    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):
-        func._is_public = public
-
-        @wraps(func)
-        async def wrapper(obj, info: GraphQLResolveInfo, **kwargs):
-            try:
-                context: BaseGraphQLContext = info.context
-                request = context.request
-                token: type[AuthToken] | None = None
-
-                # ── 1. AUTENTICACIÓN ──────────────────────────────
-                if not public:
-
-                    headers = request.headers
-                    container = context.container
-                    token_service: IAuthTokenService = container.auth_token_service
-                    user_token = extract_bearer_token(headers)
-                    
-                    claims: UserTokenClaims = token_service.validate_internal_access_token(
-                        user_token
-                    )
-
-                # ── 2. DECRYPT DEL PAYLOAD ────────────────────────
-                body = await request.json()
-                variables = body.get("variables") or {}
-                encrypted_payload = kwargs.get("data") or variables.get("data")
-                decrypted_payload = None
-
-                if not public and encrypted_payload is not None:
-                    decrypted_payload = decrypt_and_parse_payload(
-                        aes_key_auth=claims.aes_key_auth,
-                        encrypted_payload=encrypted_payload
-                    )
-
-                    kwargs["data"] = decrypted_payload
-
-                # ── 3. TENANT POLICY ──────────────────────────────
-                if not public:
-
-                    token = build_auth_token(
-                        claims=claims,
-                        headers=request.headers,
-                        decrypted_payload=decrypted_payload,
-                        operation_type=info.operation.operation.value
-                    )
-
-                # ── 4. CONTROL DE ACCESO POR ROL ─────────────────
-                if not public and action:
-                    if Profile(token.abbreviation) not in action.allowed_roles:
-                        raise AccessDeniedException(
-                            status_code=StatusCode.BUSINESS_RULE_WARNING,
-                            error="User not allowed to perform this action"
-                        )
-
-                # ── 5. EJECUTAR RESOLVER ──────────────────────────
-                result = await func(obj, info, **kwargs)
-
-                if not isinstance(result, Response):
-                    raise TypeError("Resolver must return a Response instance")
-
-                dispatcher = request.app.state.audit_dispatcher
-
-                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 
-                        if token 
-                        else "Public"
-                    )
-                }
-
-                if isinstance(result, Response):
-                    decrypted_key = result.key if not token else token.aes_key_auth
-
-                __test(
-                    dispatcher=dispatcher,
-                    request_payload=request_payload,
-                    request=request,
-                    decrypted_key=decrypted_key,
-                    result=result
-                )
-
-                return result
-
-            except OSDException as e:
-                logger.warning(f"Business error: {str(e)}")
-                return Response(
-                    status=e.status_code,
-                    message=e.message,
-                    error=e.error
-                )
-            except Exception as e:
-                logger.exception(f"Unexpected error: {str(e)}")
-                return Response(
-                    status=StatusCode.INTERNAL_SERVER_ERROR,
-                    message="Could not process request.",
-                    error=str(e)
-                )
-
-        return wrapper
-    return decorator

encryptors-2.54/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.54/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"