Encryptors 2.81.2__tar.gz → 2.81.4__tar.gz

{encryptors-2.81.2 → encryptors-2.81.4}/PKG-INFO

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

{encryptors-2.81.2 → encryptors-2.81.4}/setup.py

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

{encryptors-2.81.2 → encryptors-2.81.4}/src/Encryptors.egg-info/PKG-INFO

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

{encryptors-2.81.2 → encryptors-2.81.4}/src/Encryptors.egg-info/SOURCES.txt

@@ -28,16 +28,23 @@ src/Osdental/Encryptor/Jwt.py
 src/Osdental/Encryptor/Rsa.py
 src/Osdental/Encryptor/Sha512.py
 src/Osdental/Encryptor/__init__.py
+src/Osdental/Enums/FileType.py
+src/Osdental/Enums/GrahpqlOperation.py
+src/Osdental/Enums/GrpcStatusCode.py
+src/Osdental/Enums/Profile.py
+src/Osdental/Enums/StatusCode.py
+src/Osdental/Enums/__init__.py
 src/Osdental/Exception/ControlledException.py
 src/Osdental/Exception/__init__.py
+src/Osdental/Helpers/AuthorizationHelpers.py
 src/Osdental/Helpers/AzureClassifier.py
 src/Osdental/Helpers/GrpcConnection.py
+src/Osdental/Helpers/Logger.py
+src/Osdental/Helpers/RequestDecryption.py
 src/Osdental/Helpers/Resilience.py
 src/Osdental/Helpers/ResponseDecryptor.py
+src/Osdental/Helpers/TokenValidationService.py
 src/Osdental/Helpers/__init__.py
-src/Osdental/Helpers/extract_auth_token.py
-src/Osdental/Helpers/tenant_policy.py
-src/Osdental/Helpers/token_validation_service.py
 src/Osdental/Http/Constants.py
 src/Osdental/Http/Exceptions.py
 src/Osdental/Http/HttpxClient.py
@@ -54,28 +61,19 @@ src/Osdental/Models/__init__.py
 src/Osdental/Models/base_graphql_context.py
 src/Osdental/Secrets/KeyVaultService.py
 src/Osdental/Secrets/__init__.py
-src/Osdental/Shared/Logger.py
-src/Osdental/Shared/__init__.py
-src/Osdental/Shared/Enums/Code.py
-src/Osdental/Shared/Enums/Constant.py
-src/Osdental/Shared/Enums/FileType.py
-src/Osdental/Shared/Enums/GrahpqlOperation.py
-src/Osdental/Shared/Enums/Message.py
-src/Osdental/Shared/Enums/Profile.py
-src/Osdental/Shared/Enums/__init__.py
-src/Osdental/Shared/Utils/CaseConverter.py
-src/Osdental/Shared/Utils/CodeGenerator.py
-src/Osdental/Shared/Utils/DataNormalizer.py
-src/Osdental/Shared/Utils/DataUtils.py
-src/Osdental/Shared/Utils/DateUtils.py
-src/Osdental/Shared/Utils/FileMetaData.py
-src/Osdental/Shared/Utils/HashValidator.py
-src/Osdental/Shared/Utils/Mapper.py
-src/Osdental/Shared/Utils/PasswordGenerator.py
-src/Osdental/Shared/Utils/QueryGenerator.py
-src/Osdental/Shared/Utils/RsaUtils.py
-src/Osdental/Shared/Utils/TextProcessor.py
-src/Osdental/Shared/Utils/__init__.py
 src/Osdental/Storage/AzureBlobStorage.py
 src/Osdental/Storage/S3Storage.py
-src/Osdental/Storage/__init__.py
+src/Osdental/Storage/__init__.py
+src/Osdental/Utils/CaseConverter.py
+src/Osdental/Utils/CodeGenerator.py
+src/Osdental/Utils/DataNormalizer.py
+src/Osdental/Utils/DataUtils.py
+src/Osdental/Utils/DateUtils.py
+src/Osdental/Utils/FileMetaData.py
+src/Osdental/Utils/HashValidator.py
+src/Osdental/Utils/Mapper.py
+src/Osdental/Utils/PasswordGenerator.py
+src/Osdental/Utils/QueryGenerator.py
+src/Osdental/Utils/RsaUtils.py
+src/Osdental/Utils/TextProcessor.py
+src/Osdental/Utils/__init__.py

{encryptors-2.81.2 → encryptors-2.81.4}/src/Osdental/Cli/__init__.py

@@ -3,8 +3,7 @@ import sys
 import subprocess
 import platform
 import click
-from Osdental.Shared.Logger import logger
-from Osdental.Shared.Enums.Message import Message
+from Osdental.Helpers.Logger import logger
 
 
 @click.group()
@@ -20,7 +19,7 @@ def clean():
     else:
         subprocess.run("find . -name '__pycache__' -type d -exec rm -rf {} +", shell=True)
 
-    logger.info(Message.PYCACHE_CLEANUP_SUCCESS_MSG)
+    logger.info("All __pycache__ have been removed.")
 
 @cli.command()
 @click.argument('port')
@@ -29,7 +28,7 @@ def start(port: int):
     try:
         subprocess.run(['uvicorn', 'app:app', '--port', str(port), '--reload'], check=True)
     except subprocess.CalledProcessError as e:
-        logger.error(f'{Message.SERVER_NETWORK_ACCESS_ERROR_MSG}: {e}')
+        logger.error(f"Error making the server accessible on the network. | {e}")
 
 @cli.command()
 @click.argument('port')
@@ -38,7 +37,7 @@ def serve(port: int):
     try:
         subprocess.run(['uvicorn', 'app:app', '--host', '0.0.0.0', '--port', str(port), '--reload'], check=True)
     except subprocess.CalledProcessError as e:
-        logger.error(f'{Message.SERVER_NETWORK_ACCESS_ERROR_MSG}: {e}')
+        logger.error(f"Error making the server accessible on the network. | {e}")
 
 @cli.command("clean-redis")
 @click.argument('redis_env')
@@ -52,9 +51,9 @@ async def clean_redis(redis_env: str):
         
         redis = RedisCacheAsync(redis_url=redis_url)
         await redis.flush()
-        logger.info(Message.REDIS_CLEANUP_SUCCESS_MSG)
+        logger.info("Redis cleanup completed successfully.")
     except Exception as e:
-        logger.error(f'{Message.REDIS_CLEANUP_ERROR_MSG}: {e}')
+        logger.error(f"An error occurred while attempting to clean up Redis. | {e}")
 
 @cli.command(name='proto-files')
 @click.argument('name')
@@ -81,7 +80,7 @@ def proto_files(name: str):
 ]
 
     subprocess.run(cmd, shell=False, check=True)
-    logger.info(Message.PROTO_FILES_GENERATED_MSG)
+    logger.info("Proto files have been successfully generated.")
 
 @cli.command('run-server')
 @click.option('--host', default="0.0.0.0", help='Host where to set up the server')

{encryptors-2.81.2 → encryptors-2.81.4}/src/Osdental/Database/BaseRepository.py

@@ -15,7 +15,7 @@ from Osdental.Database.SqlTransientDetector import SqlTransientDetector
 from Osdental.Database.StoredProcedureResultValidator import (
     StoredProcedureResultValidator,
 )
-from Osdental.Shared.Utils.DataNormalizer import normalize
+from Osdental.Utils.DataNormalizer import normalize
 
 
 class BaseRepository:

{encryptors-2.81.2 → encryptors-2.81.4}/src/Osdental/Database/SqlExceptionTranslator.py

@@ -9,11 +9,9 @@ from sqlalchemy.exc import (
 )
 
 from Osdental.Exception.ControlledException import DatabaseException
-from Osdental.Shared.Enums.Message import Message
 
 logger = logging.getLogger(__name__)
 
-
 class SqlExceptionTranslator:
 
     _ERRORS = {
@@ -39,7 +37,7 @@ class SqlExceptionTranslator:
         ),
 
         DBAPIError: (
-            Message.UNEXPECTED_ERROR_MSG,
+            "Something went wrong while processing your request. Please try again later.",
             "DB_ERROR",
         ),
     }
@@ -64,7 +62,7 @@ class SqlExceptionTranslator:
                 )
 
         return DatabaseException(
-            message=Message.UNEXPECTED_ERROR_MSG,
+            message="Something went wrong while processing your request. Please try again later.",
             error=detail,
             status_code="UNEXPECTED_ERROR",
         )

{encryptors-2.81.2 → encryptors-2.81.4}/src/Osdental/Database/StoredProcedureResultValidator.py

@@ -2,7 +2,6 @@ from collections.abc import Iterable
 from typing import Any
 
 from Osdental.Exception.ControlledException import DatabaseException
-from Osdental.Shared.Enums.Message import Message
 
 
 class StoredProcedureResultValidator:
@@ -44,7 +43,6 @@ class StoredProcedureResultValidator:
             if status_code is None:
 
                 raise DatabaseException(
-                    message="Status code missing.",
                     error="Stored Procedure did not return a status code.",
                     status_code="DB_STATUS_CODE_MISSING",
                 )
@@ -56,8 +54,7 @@ class StoredProcedureResultValidator:
         if status_code not in success_codes:
 
             raise DatabaseException(
-                message=status_message or Message.UNEXPECTED_ERROR_MSG,
-                error=status_message or Message.UNEXPECTED_ERROR_MSG,
+                error=status_message,
                 status_code=status_code,
             )
 

{encryptors-2.81.2 → encryptors-2.81.4}/src/Osdental/Decorators/Grpc.py

@@ -1,6 +1,6 @@
 import json
 from functools import wraps
-from Osdental.Shared.Logger import logger
+from Osdental.Helpers.Logger import logger
 
 def parse_rpc_request_payload(func):
 

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

@@ -0,0 +1,88 @@
+from functools import wraps
+from typing import Callable
+from Osdental.Models.Response import Response
+from Osdental.Enums.Profile import Profile
+from Osdental.Exception.ControlledException import (
+    OSDException, AccessDeniedException
+)
+from Osdental.Models.base_graphql_context import BaseGraphQLContext
+from Osdental.Helpers.AuthorizationHelpers import tenant_context_resolver
+from Osdental.Helpers.RequestDecryption import decrypt_payload
+from Osdental.Secrets import ISecretProvider
+from Osdental.Helpers.Logger import logger
+
+_AES_KEY_USER = "AES-KEY-USER"
+_AES_KEY_AUTH = "AES-KEY-AUTH"
+_JWT_USER_KEY = "AUTH-JWT-USER-KEY"
+
+def resolver(action=None):
+
+    def decorator(func: Callable):
+
+        @wraps(func)
+        async def wrapper(obj, info, **kwargs):
+            try:
+                context: BaseGraphQLContext = info.context
+                request = context.request
+                token_service = context.container.token_service
+    
+                secret_service: ISecretProvider = context.container.secret_service
+                secrets = await secret_service.get_many(
+                    [_AES_KEY_AUTH, _AES_KEY_USER, _JWT_USER_KEY]
+                )
+                
+                decrypted_payload = decrypt_payload(
+                    encrypted_payload=kwargs.get("data"),
+                    aes_auth_aes_key=secrets[_AES_KEY_AUTH]
+                )
+                            
+                if decrypted_payload is not None:
+                    kwargs["data"] = decrypted_payload
+
+
+                original_token = await token_service.authenticate(
+                    request.headers,
+                    secrets[_JWT_USER_KEY],
+                    secrets[_AES_KEY_USER],
+                )
+
+                token = tenant_context_resolver(
+                    token=original_token,
+                    headers=request.headers,
+                    decrypted_payload=decrypted_payload,
+                    operation_type=info.operation.operation.value
+                )
+
+                if action and Profile(token.abbreviation) not in action.allowed_roles:
+                    raise AccessDeniedException(
+                        error="User not allowed to perform this action."
+                    )
+                
+                context.token = token
+
+                result = await func(obj, info, **kwargs)
+
+                if not isinstance(result, Response):
+                    raise TypeError("Resolver must return a Response instance.")
+
+                return result
+
+            except OSDException as e:
+                logger.warning(msg=str(e))
+
+                return Response(
+                    status=e.status_code,
+                    message=e.message,
+                )
+
+            except Exception as e:
+                logger.exception(msg=str(e))
+
+                return Response(
+                    status="DB_ERROR_UNEXPECTED",
+                    message="Could not process request.",
+                )
+
+        return wrapper
+
+    return decorator

encryptors-2.81.4/src/Osdental/Encryptor/Aes.py

@@ -0,0 +1,61 @@
+import os
+import json
+import base64
+from typing import Any
+from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
+
+class AES:
+
+    IV_LENGTH = 32
+    TAG_LENGTH = 16
+
+    @staticmethod
+    def generate_key() -> str:
+        """Generates a random 256-bit AES key and returns it Base64 encoded."""
+        key = os.urandom(32)
+        return base64.b64encode(key).decode("utf-8")
+    
+    @classmethod
+    def encrypt(
+        cls,
+        aes_key: str,
+        data: str | dict[str, Any] | list[dict[str, Any]]
+    ) -> str:
+
+        if not isinstance(data, (dict, str, list)):
+            raise ValueError("Invalid data type: expected dict, str, or list.")
+
+        key = base64.b64decode(aes_key)
+        iv = os.urandom(cls.IV_LENGTH)
+
+        if isinstance(data, (dict, list)):
+            json_data = json.dumps(data)
+        else:
+            json_data = data
+
+        cipher = Cipher(algorithms.AES(key), modes.GCM(iv))
+        encryptor = cipher.encryptor()
+        ciphertext = encryptor.update(json_data.encode("utf-8")) + encryptor.finalize()
+        tag = encryptor.tag
+        encrypted_data = iv + ciphertext + tag
+
+        return base64.b64encode(encrypted_data).decode("utf-8")
+
+ 
+    @classmethod
+    def decrypt(cls, aes_key: str, encrypted_data: str):
+
+        key = base64.b64decode(aes_key)
+        encrypted_data = base64.b64decode(encrypted_data)
+        iv = encrypted_data[:cls.IV_LENGTH]
+        tag = encrypted_data[-cls.TAG_LENGTH:]
+        ciphertext = encrypted_data[cls.IV_LENGTH:-cls.TAG_LENGTH]
+        cipher = Cipher(algorithms.AES(key), modes.GCM(iv, tag))
+        decryptor = cipher.decryptor()
+        plaintext = decryptor.update(ciphertext) + decryptor.finalize()
+
+        try:
+            decrypted_data = json.loads(plaintext.decode("utf-8"))
+            return decrypted_data
+        except json.JSONDecodeError:
+            return plaintext.decode("utf-8")

{encryptors-2.81.2 → encryptors-2.81.4}/src/Osdental/Encryptor/Bcrypt.py

@@ -1,6 +1,6 @@
 import bcrypt
 from Osdental.Exception.ControlledException import OSDException
-from Osdental.Shared.Enums.Constant import Constant
+
 
 class BcryptPasswordManager:
     def __init__(self, rounds: int = 12):
@@ -21,8 +21,8 @@ class BcryptPasswordManager:
         :return: string hash
         """
         salt = bcrypt.gensalt(rounds=self.rounds)
-        hashed = bcrypt.hashpw(password.encode(Constant.DEFAULT_ENCODING), salt)
-        return hashed.decode(Constant.DEFAULT_ENCODING)
+        hashed = bcrypt.hashpw(password.encode("utf-8"), salt)
+        return hashed.decode("utf-8")
 
     def verify(self, hashed_password: str, plain_password: str) -> bool:
         """
@@ -32,7 +32,7 @@ class BcryptPasswordManager:
         :return: True if matched, False if not
         """
         return bcrypt.checkpw(
-            plain_password.encode(Constant.DEFAULT_ENCODING), hashed_password.encode(Constant.DEFAULT_ENCODING)
+            plain_password.encode("utf-8"), hashed_password.encode("utf-8")
         )
 
     def needs_rehash(self, hashed_password: str) -> bool:

encryptors-2.81.4/src/Osdental/Encryptor/Jwt.py

@@ -0,0 +1,34 @@
+import jwt
+from typing import Any
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.backends import default_backend
+
+class JWT:
+
+    @staticmethod
+    def generate_token(
+        payload: dict[str, Any], jwt_secret_key: str, algorithm="HS256"
+    ) -> str:
+        return jwt.encode(
+            payload=payload, 
+            key=jwt_secret_key,
+            algorithm=algorithm,
+        )
+
+
+    @staticmethod
+    def extract_payload(jwt_token: str, jwt_secret_key: str) -> dict[str, Any]:
+       return jwt.decode(
+           jwt=jwt_token,
+           key=jwt_secret_key,
+           algorithms=["HS256"],
+        )
+
+
+    @staticmethod
+    def generate_private_key(private_rsa: str):
+        return serialization.load_pem_private_key(
+            private_rsa.encode(),
+            password=None,
+            backend=default_backend(),
+        )

encryptors-2.81.4/src/Osdental/Encryptor/Rsa.py

@@ -0,0 +1,47 @@
+import json
+from base64 import b64decode, b64encode
+from typing import Any
+from cryptography.hazmat.primitives import serialization
+from cryptography.hazmat.primitives.asymmetric import padding
+from cryptography.hazmat.primitives import hashes
+
+class RSAEncryptor:
+
+    @staticmethod
+    def encrypt(data: str | dict[str, Any], public_key_rsa: str) -> str:
+
+        if isinstance(data, dict):
+            data = json.dumps(data)
+
+        public_key = serialization.load_pem_public_key(public_key_rsa.encode("utf-8"))
+        data_bytes = data.encode("utf-8")
+        encrypted_bytes = public_key.encrypt(
+            data_bytes,
+            padding.OAEP(
+                mgf=padding.MGF1(algorithm=hashes.SHA256()),
+                algorithm=hashes.SHA256(),
+                label=None
+            )
+        )
+
+        return b64encode(encrypted_bytes).decode("utf-8")
+
+
+    @staticmethod
+    def decrypt(data: str, private_key_rsa: str) -> str:
+
+        encrypted_bytes = b64decode(data)
+        private_key = serialization.load_pem_private_key(
+            private_key_rsa.encode("utf-8"),
+            password=None
+        )
+        decrypted_bytes = private_key.decrypt(
+            encrypted_bytes,
+            padding.OAEP(
+                mgf=padding.MGF1(algorithm=hashes.SHA256()),
+                algorithm=hashes.SHA256(),
+                label=None
+            )
+        )
+
+        return decrypted_bytes.decode("utf-8")

{encryptors-2.81.2 → encryptors-2.81.4}/src/Osdental/Encryptor/Sha512.py

@@ -1,12 +1,11 @@
 import hashlib
-from Osdental.Shared.Enums.Constant import Constant
 
 class SHA512:
 
     @staticmethod
     def hash_password(password: str) -> str:
         """Generates the SHA-512 hash of a password."""
-        hash_object = hashlib.sha512(password.encode(Constant.DEFAULT_ENCODING))
+        hash_object = hashlib.sha512(password.encode("utf-8"))
         hashed_password = hash_object.hexdigest()
         return hashed_password
 

encryptors-2.81.4/src/Osdental/Enums/FileType.py

@@ -0,0 +1,9 @@
+from enum import StrEnum
+
+class FileType(StrEnum):
+    IMAGE = "image"
+    VIDEO = "video"
+    AUDIO = "audio"
+    DOCUMENT = "document"
+    ARCHIVE = "archive"
+    OTHER = "other"

{encryptors-2.81.2/src/Osdental/Shared → encryptors-2.81.4/src/Osdental}/Enums/GrahpqlOperation.py

@@ -1,5 +1,5 @@
 from enum import StrEnum
 
 class GraphqlOperation(StrEnum):
-    QUERY = 'query'
-    MUTATION = 'mutation'
+    QUERY = "query"
+    MUTATION = "mutation"

encryptors-2.81.4/src/Osdental/Enums/GrpcStatusCode.py

@@ -0,0 +1,25 @@
+from enum import StrEnum
+
+class GrpcStatusCode(StrEnum):
+    # --- Éxito ---
+    OK = "OK"  # Código 0: Operación exitosa.
+
+    # --- Errores del Cliente (4xx equivalentes) ---
+    CANCELLED = "CANCELLED"  # Código 1: La operación fue cancelada por el cliente.
+    UNKNOWN = "UNKNOWN"  # Código 2: Error desconocido (ej. una excepción no controlada).
+    INVALID_ARGUMENT = "INVALID_ARGUMENT"  # Código 3: El cliente envió datos inválidos (parámetros mutados/vacíos).
+    DEADLINE_EXCEEDED = "DEADLINE_EXCEEDED = "  # Código 4: El tiempo de espera (Timeout) expiró antes de terminar.
+    NOT_FOUND = "NOT_FOUND"  # Código 5: El recurso solicitado no fue encontrado.
+    ALREADY_EXISTS = "ALREADY_EXISTS"  # Código 6: El recurso que se intentó crear ya existe.
+    PERMISSION_DENIED = "PERMISSION_DENIED"  # Código 7: Elige este si el usuario está autenticado pero NO tiene permisos para este recurso.
+    RESOURCE_EXHAUSTED = "RESOURCE_EXHAUSTED"  # Código 8: Se agotaron los recursos (Rate limit, cuotas de disco, etc.).
+    FAILED_PRECONDITION = "FAILED_PRECONDITION"  # Código 9: El sistema no está en el estado requerido (ej. borrar un directorio que no está vacío).
+    ABORTED = "ABORTED"  # Código 10: Operación abortada por un conflicto de concurrencia (ej. transacciones de BD).
+    OUT_OF_RANGE = "OUT_OF_RANGE"  # Código 11: Operación pasada del rango válido (ej. un offset de paginación inválido).
+    UNAUTHENTICATED = "UNAUTHENTICATED"  # Código 16: El usuario no está autenticado (Falta token, token expirado).
+
+    # --- Errores del Servidor (5xx equivalentes) ---
+    UNIMPLEMENTED = "UNIMPLEMENTED"  # Código 12: El método o servicio no está implementado en el server.
+    INTERNAL = "INTERNAL"  # Código 13: Errores graves internos del servidor (Bug en código, caída de BD principal).
+    UNAVAILABLE = "UNAVAILABLE"  # Código 14: El microservicio o dependencia no está disponible (Servicio caído).
+    DATA_LOSS = "DATA_LOSS"  # Código 15: Pérdida o corrupción de datos irrecuperable.

encryptors-2.81.4/src/Osdental/Enums/StatusCode.py

@@ -0,0 +1,40 @@
+from enum import StrEnum
+
+class StatusCode(StrEnum):
+
+    # --- 2xx Éxito ---
+    OK = "SUCCESS_200"
+    CREATED = "SUCCESS_201"
+    ACCEPTED = "SUCCESS_202"
+    NO_CONTENT = "SUCCESS_204"
+
+    # --- 4xx Errores del Cliente ---
+    BAD_REQUEST = "ERROR_400"
+    UNAUTHORIZED = "ERROR_401"
+    FORBIDDEN = "ERROR_403"
+    NOT_FOUND = "ERROR_404"
+    CONFLICT = "ERROR_409"
+    UNPROCESSABLE_ENTITY = "ERROR_422"
+
+    # --- 5xx Errores del Servidor ---
+    INTERNAL_SERVER_ERROR = "ERROR_500"
+    BAD_GATEWAY = "ERROR_502"
+    SERVICE_UNAVAILABLE = "ERROR_503"
+    GATEWAY_TIMEOUT = "ERROR_504"
+
+    # --- Alertas de Negocio / Excepciones de Control ---
+    # NOTA: A diferencia de los 'ERROR_XXX' (que representan fallos técnicos o de integración), 
+    # los 'WARNING_XXX' indican que el sistema operó correctamente pero el flujo fue detenido 
+    # de forma controlada por reglas, validaciones o el estado del dominio.
+
+    # Formato inválido o datos de entrada que no cumplen con criterios lógicos
+    VALIDATION_WARNING = "WARNING_400"
+
+    # Recurso secundario, configuración o data externa requerida que no fue encontrada
+    DATA_NOT_FOUND_WARNING = "WARNING_404" 
+
+    # Inviolabilidad del dominio (Ej: Usuario bloqueado, saldo insuficiente, cuenta inactiva)
+    BUSINESS_RULE_WARNING = "WARNING_422"
+
+    # Conflicto con el estado actual de la entidad (Ej: Intentar activar un registro ya activo)
+    STATE_CONFLICT_WARNING = "WARNING_409"

encryptors-2.81.4/src/Osdental/Exception/ControlledException.py

@@ -0,0 +1,49 @@
+from typing import Any
+
+class OSDException(Exception):
+    """ Base class for all custom exceptions. """
+    def __init__(
+        self, 
+        message: str = None, 
+        error: str = None, 
+        status_code: Any = "DB_ERROR_CONTROLLED",
+    ):
+        super().__init__(error)
+        self.message = message
+        self.error = error
+        self.status_code = status_code
+
+
+    def __str__(self):
+        error_detail = self.error if self.error else "None"
+        return f"[{self.status_code}] {self.message} | {error_detail}"
+
+
+
+class UnauthorizedException(OSDException):
+    def __init__(
+        self, 
+        message: str = "You are not authorized to access this portal.", 
+        error: str = None, 
+        status_code: str = None,
+    ):
+        super().__init__(message=message, error=error, status_code=status_code)
+
+class AccessDeniedException(OSDException):
+    def __init__(
+        self, 
+        message: str = "You do not have the necessary privileges for this operation.", 
+        error: str = None, 
+        status_code: str = None,
+    ):
+        super().__init__(message=message, error=error, status_code=status_code)
+
+
+class DatabaseException(OSDException):
+    def __init__(
+        self, 
+        message: str = "Something went wrong while processing your request. Please try again later.", 
+        error: str = None, 
+        status_code: str = None,
+    ):
+        super().__init__(message=message, error=error, status_code=status_code)