Encryptors 2.31__tar.gz → 2.32__tar.gz

{encryptors-2.31 → encryptors-2.32}/PKG-INFO

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

{encryptors-2.31 → encryptors-2.32}/setup.py

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

{encryptors-2.31 → encryptors-2.32}/src/Encryptors.egg-info/PKG-INFO

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

{encryptors-2.31 → encryptors-2.32}/src/Encryptors.egg-info/SOURCES.txt

@@ -7,16 +7,10 @@ src/Encryptors.egg-info/entry_points.txt
 src/Encryptors.egg-info/requires.txt
 src/Encryptors.egg-info/top_level.txt
 src/Osdental/__init__.py
-src/Osdental/BlobStorage/Storage.py
-src/Osdental/BlobStorage/__init__.py
 src/Osdental/Cli/__init__.py
 src/Osdental/Database/BaseRepository.py
 src/Osdental/Database/Connection.py
-src/Osdental/Database/UnitOfWork.py
-src/Osdental/Database/UowFactory.py
 src/Osdental/Database/__init__.py
-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
@@ -31,50 +25,41 @@ src/Osdental/Encryptor/Sha512.py
 src/Osdental/Encryptor/__init__.py
 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/_Exceptions/__init__.py
 src/Osdental/Graphql/_Helpers/_AuditHelper.py
+src/Osdental/Graphql/_Helpers/_ExtractAuthToken.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
-src/Osdental/Grpc/Client/PortalClient.py
-src/Osdental/Grpc/Client/__init__.py
-src/Osdental/Grpc/Generated/Common_pb2.py
-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
-src/Osdental/InternalHttp/Response.py
-src/Osdental/InternalHttp/__init__.py
+src/Osdental/Http/APIClient.py
+src/Osdental/Http/_Exceptions.py
+src/Osdental/Http/__init__.py
 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
 src/Osdental/Models/Response.py
 src/Osdental/Models/Token.py
+src/Osdental/Models/_Audit.py
 src/Osdental/Models/__init__.py
 src/Osdental/RedisCache/Redis.py
 src/Osdental/RedisCache/__init__.py
-src/Osdental/ServicesBus/ServicesBus.py
-src/Osdental/ServicesBus/TaskQueue.py
-src/Osdental/ServicesBus/__init__.py
+src/Osdental/Rest/__init__.py
+src/Osdental/Rest/Context/RequestContext.py
+src/Osdental/Rest/Context/__init__.py
+src/Osdental/Rest/Middlewares/RequestContextMiddleware.py
+src/Osdental/Rest/Middlewares/__init__.py
 src/Osdental/Shared/Logger.py
 src/Osdental/Shared/__init__.py
-src/Osdental/Shared/Config/__init__.py
 src/Osdental/Shared/Enums/Code.py
 src/Osdental/Shared/Enums/Constant.py
 src/Osdental/Shared/Enums/FileType.py

encryptors-2.32/src/Osdental/Database/Connection.py

@@ -0,0 +1,66 @@
+import struct
+import urllib
+from typing import Dict
+from azure.identity import DefaultAzureCredential
+from sqlalchemy import event
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
+from sqlalchemy.orm import sessionmaker
+
+SQL_COPT_SS_ACCESS_TOKEN = 1256
+class Connection:
+
+    _instances: Dict[str, 'Connection'] = {}
+
+    def __new__(cls, db_url: str):
+        if db_url not in cls._instances:
+            cls._instances[db_url] = super(Connection, cls).__new__(cls)
+        return cls._instances[db_url]
+
+    def __init__(self, db_url: str):
+        if not hasattr(self, 'initialized'):
+            self.credential = DefaultAzureCredential()
+            raw_odbc_string = db_url
+            params = urllib.parse.quote_plus(raw_odbc_string)
+            sqlalchemy_url = f"mssql+aioodbc:///?odbc_connect={params}"
+            self.engine = create_async_engine(
+                sqlalchemy_url,
+                pool_size=20,          
+                max_overflow=40,       
+                pool_timeout=30,       
+                pool_recycle=1800,
+                pool_pre_ping=True   
+            )
+            self._attach_token_listener()
+            self.session_factory = sessionmaker(
+                bind=self.engine, 
+                class_=AsyncSession, 
+                expire_on_commit=False
+            )
+            self.initialized = True
+
+    def _attach_token_listener(self):
+
+        @event.listens_for(self.engine.sync_engine, "do_connect")
+        def provide_token(dialect, conn_rec, cargs, cparams):
+
+            token = self.credential.get_token(
+                "https://database.windows.net/.default"
+            ).token
+
+            token_bytes = token.encode("utf-16-le")
+
+            token_struct = struct.pack(
+                f"<I{len(token_bytes)}s",
+                len(token_bytes),
+                token_bytes
+            )
+
+            cparams["attrs_before"] = {
+                SQL_COPT_SS_ACCESS_TOKEN: token_struct
+            }
+
+    
+    async def close_engine(self) -> None:
+        """Dispose of the engine and remove instance."""
+        if self.engine:
+            await self.engine.dispose() 

{encryptors-2.31 → encryptors-2.32}/src/Osdental/Encryptor/Bcrypt.py

@@ -1,6 +1,6 @@
 import bcrypt
 from Osdental.Exception.ControlledException import OSDException
-from Osdental.Shared.Constant import Constant
+from Osdental.Shared.Enums.Constant import Constant
 
 class BcryptPasswordManager:
     def __init__(self, rounds: int = 12):

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

@@ -0,0 +1,142 @@
+from typing import Any
+from Osdental.Shared.Enums.Code import Code
+from Osdental.Shared.Enums.Message import Message
+
+class OSDException(Exception):
+    """ Base class for all custom exceptions. """
+    def __init__(
+        self, 
+        message: str = Message.UNEXPECTED_ERROR_MSG, 
+        error: str = None, 
+        status_code: Any = Code.APP_ERROR_CODE
+    ):
+        super().__init__(error)
+        self.message = message
+        self.error = error
+        self.status_code = status_code
+    
+class UnauthorizedException(OSDException):
+    def __init__(
+        self, 
+        message: str = Message.PORTAL_ACCESS_RESTRICTED_MSG, 
+        error: str = None, 
+        status_code: str = Code.UNAUTHORIZATED_CODE
+    ):
+        super().__init__(message=message, error=error, status_code=status_code)
+
+class RequestDataException(OSDException):
+    def __init__(
+        self, 
+        message: str = Message.INVALID_REQUEST_PARAMS_MSG, 
+        error: str = None, 
+        status_code: str = Code.INVALID_REQUEST_PARAMS_CODE
+    ):
+        super().__init__(message=message, error=error, status_code=status_code)
+
+class DatabaseConnectionException(OSDException):
+    def __init__(
+        self,
+        message: str = Message.INVALID_FORMAT_MSG,
+        error: str = None,
+        status_code: str = Code.DATABASE_CONNECTION_ERROR_CODE
+    ):
+        super().__init__(message=message, error=error, status_code=status_code)
+
+class DatabaseException(OSDException):
+    def __init__(
+        self, 
+        message: str = Message.UNEXPECTED_ERROR_MSG, 
+        error: str = None, 
+        status_code: str = Code.DATABASE_ERROR_CODE
+    ):
+        super().__init__(message=message, error=error, status_code=status_code)
+
+class RSAEncryptException(OSDException):
+    def __init__(
+        self, 
+        message: str = Message.UNEXPECTED_ERROR_MSG, 
+        error: str = None, 
+        status_code: str = Code.RSA_ERROR_CODE
+    ):
+        super().__init__(message=message, error=error, status_code=status_code)
+
+class AESEncryptException(OSDException):
+    def __init__(
+        self, 
+        message: str = Message.UNEXPECTED_ERROR_MSG, 
+        error: str = None, 
+        status_code: str = Code.AES_ERROR_CODE
+    ):
+        super().__init__(message=message, error=error, status_code=status_code)
+
+class JWTokenException(OSDException):
+    def __init__(
+        self, 
+        message: str = Message.UNEXPECTED_ERROR_MSG, 
+        error: str = None, 
+        status_code: str = Code.JWT_ERROR_CODE
+    ):
+        super().__init__(message=message, error=error, status_code=status_code)
+
+class AzureException(OSDException):
+    def __init__(
+        self, 
+        message: str = Message.UNEXPECTED_ERROR_MSG, 
+        error: str = None, 
+        status_code: str = Code.AZURE_ERROR_CODE
+    ):
+        super().__init__(message=message, error=error, status_code=status_code)
+
+class RedisException(OSDException):
+    def __init__(
+        self, 
+        message: str = Message.UNEXPECTED_ERROR_MSG, 
+        error: str = None, 
+        status_code: str = Code.REDIS_ERROR_CODE
+    ):
+        super().__init__(message=message, error=error, status_code=status_code)
+
+class ValidationDataException(OSDException):
+    def __init__(
+        self, 
+        message: str = Message.UNEXPECTED_ERROR_MSG, 
+        error: str = None, 
+        status_code: str = Code.REQUEST_VALIDATION_ERROR_CODE
+    ):
+        super().__init__(message=message, error=error, status_code=status_code)
+
+class UnexpectedException(OSDException):
+    def __init__(
+        self, 
+        message: str = Message.UNEXPECTED_ERROR_MSG, 
+        error: str = None, 
+        status_code: str = Code.UNEXPECTED_ERROR_CODE
+    ):
+        super().__init__(message=message, error=error, status_code=status_code)
+
+class MissingFieldException(OSDException):
+    def __init__(
+        self, 
+        message: str = Message.MISSING_FIELD_ERROR_MSG, 
+        error: str = None, 
+        status_code: str = Code.MISSING_FIELD_ERROR_CODE
+    ):
+        super().__init__(message=message, error=error, status_code=status_code)
+
+class ProfilePermissionDeniedException(OSDException):
+    def __init__(
+        self,
+        message: str = Message.PROFILE_PERMISSION_DENIED_MSG,
+        error: str = None,
+        status_code: str = Code.PROFILE_PERMISSION_DENIED_CODE
+    ):
+        super().__init__(message=message, error=error, status_code=status_code)
+
+class InvalidFormatException(OSDException):
+    def __init__(
+        self,
+        message: str = Message.INVALID_FORMAT_MSG,
+        error: str = None,
+        status_code: str = Code.INVALID_FORMAT_CODE
+    ):
+        super().__init__(message=message, error=error, status_code=status_code)

{encryptors-2.31 → encryptors-2.32}/src/Osdental/Graphql/Extensions/AuditExtension.py

@@ -3,7 +3,7 @@ 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
+from Osdental.Graphql._Exceptions import AESKeyNotFound
 
 class AuditExtension(Extension):
 
@@ -29,7 +29,7 @@ class AuditExtension(Extension):
 
             aes_key = request.app.state.aes_auth
             if not aes_key:
-                raise ValueError("Could not find authorization key Aes.")
+                raise AESKeyNotFound("Could not find authorization key Aes.")
 
             original_token = await token_service.authenticate(request)
             
@@ -50,7 +50,7 @@ class AuditExtension(Extension):
                 except Exception:
                     decrypted_payload = None
 
-            token: AuthToken = TenantPolicy.resolve(
+            token = TenantPolicy.resolve(
                 token=original_token,
                 headers=request.headers,
                 decrypted_payload=decrypted_payload,
@@ -83,6 +83,10 @@ class AuditExtension(Extension):
         self.errors = errors
 
     def request_finished(self, context):
+        query = self.request_payload.get("query", "")
+        if "__schema" in query or "__type" in query: return
+    
+        if not hasattr(context, "audit_plain_response"): return
 
         dispatcher = context.request.app.state.audit_dispatcher
 

encryptors-2.32/src/Osdental/Graphql/_Exceptions/__init__.py

@@ -0,0 +1,8 @@
+from Osdental.Exception.ControlledException import OSDException
+
+class AESKeyNotFound(OSDException):
+    def __init__(
+        self, 
+        error: str = None,
+    ):
+        super().__init__(error=error)

{encryptors-2.31 → encryptors-2.32}/src/Osdental/Graphql/_Helpers/_AuditHelper.py

@@ -1,19 +1,15 @@
 import json
 from typing import Dict, Literal, Any, Optional
-from fastapi import Request
-from Osdental.Models.AuditConfig import AuditConfig
+from Osdental.Models._Audit import Audit
 
 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:
-        
+    async def build_request_payload(audit: Audit) -> Dict:
+        request = audit.request
+        audit_config = audit.audit_config
+        payload = audit.payload
+
         default_value = "*"
 
         user_ip = request.headers.get("X-Forwarded-For")
@@ -39,14 +35,14 @@ class AuditHelper:
             "microServiceUrl": str(request.url),
             "microServiceName": audit_config.microservice_name,
             "microServiceVersion": audit_config.microservice_version,
-            "serviceName": operation_name,
+            "serviceName": audit.operation_name,
             "machineNameUser": request.headers.get("Machinenameuser", default_value),
             "ipUser": user_ip or default_value,
-            "userName": full_name,
+            "userName": audit.full_name,
             "localitation": default_value,
             "httpMethod": request.method,
             "messageIn": json.dumps(payload) if payload else default_value,
-            "auditLog": "MESSAGE_LOG_INTERNAL"
+            "auditLog": audit.audit_type
         }
     
     @staticmethod

encryptors-2.32/src/Osdental/Graphql/_Helpers/_ExtractAuthToken.py

@@ -0,0 +1,11 @@
+from fastapi import Request
+
+class ExtractAuthToken:
+
+    @staticmethod
+    async def get_auth_token(request: Request) -> str:
+        authorization = request.headers.get("authorization")
+        if not authorization or not authorization.startswith("Bearer "):
+            raise ValueError("Missing Bearer token")
+        
+        return authorization.split(" ")[1]

{encryptors-2.31 → encryptors-2.32}/src/Osdental/Graphql/_Helpers/_TenantPolicy.py

@@ -1,11 +1,19 @@
-from Osdental.Encryptor.Aes import AES
+from typing import Dict, Any
 from uuid import UUID
 from graphql import OperationType
+from starlette.datastructures import Headers
+from Osdental.Encryptor.Aes import AES
+from Osdental.Models.Token import AuthToken
 
 class TenantPolicy:
 
     @staticmethod
-    def resolve(token, headers, decrypted_payload, operation_type: str):
+    def resolve(
+        token: AuthToken, 
+        headers: Headers, 
+        decrypted_payload: Dict[str, Any], 
+        operation_type: str
+    ) -> AuthToken:
         aes = AES()
         # Solo aplicamos cambios si es QUERY
         if operation_type != OperationType.QUERY.value:

{encryptors-2.31 → encryptors-2.32}/src/Osdental/Graphql/_Helpers/_TokenService.py

@@ -1,6 +1,8 @@
+from fastapi import Request
 from Osdental.Encryptor.Aes import AES
 from Osdental.Encryptor.Jwt import JWT
 from Osdental.Models.Token import AuthToken
+from Osdental.Graphql._Helpers._ExtractAuthToken import ExtractAuthToken
 
 class TokenService:
 
@@ -9,12 +11,8 @@ class TokenService:
         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]
+    async def authenticate(self, request: Request) -> AuthToken:
+        encrypted_token = ExtractAuthToken.get_auth_token(request)
 
         aes_user = request.app.state.aes_user
 

{encryptors-2.31 → encryptors-2.32}/src/Osdental/Helpers/AuditDispatcher.py

@@ -1,8 +1,13 @@
 import asyncio
-import logging
+from typing import Dict, Any
+from fastapi import Request
 from Osdental.Models.AuditConfig import AuditConfig
 from Osdental.Messaging import IMessageQueue
 from Osdental.Graphql._Helpers._AuditHelper import AuditHelper
+from Osdental.Models._Audit import Audit
+from Osdental.Models.Response import Response
+from Osdental.Shared.Enums.Constant import Constant
+from Osdental.Shared.Logger import logger
 
 class AuditDispatcher:
 
@@ -29,19 +34,25 @@ class AuditDispatcher:
             await self._worker_task
 
     # Ultra rápido, no bloquea
-    def dispatch(self, request, request_payload, result, errors = None):
+    def dispatch(
+        self, 
+        request: Request, 
+        request_payload: Dict[str, Any], 
+        result: Response,
+        audit_type: str = None
+    ):
         try:
             payload = {
                 "request": request,
                 "request_payload": request_payload,
                 "result": result,
-                "errors": errors
+                "audit_type": audit_type
             }
 
             self._queue.put_nowait(payload)
 
         except asyncio.QueueFull:
-            logging.error("Audit queue full. Dropping message.")
+            logger.error("Audit queue full. Dropping message.")
 
     # Worker real
     async def _worker(self):        
@@ -55,39 +66,56 @@ class AuditDispatcher:
             try:
                 await self._process(payload)
             except Exception:
-                logging.exception("Audit processing failed")
+                logger.exception("Audit processing failed")
             finally:
                 self._queue.task_done()
 
     # Logica
-    async def _process(self, payload):
+    async def _process(self, payload: Dict[str, Any]):
         request = payload["request"]
         request_payload = payload["request_payload"]
         result = payload["result"]
+        audit_type = payload["audit_type"]
 
         operation_name = request_payload.get("operation_name")
         if operation_name == 'UnknownOperation':
-            logging.info("Skipping audit: no data in GraphQL response")
+            logger.info("Skipping audit: no data in GraphQL response")
             return
         
-        request_audit_payload = await AuditHelper.build_request_payload(
+        audit = Audit(
+            audit_type=audit_type,
             request=request,
             audit_config=self._audit_config,
             operation_name=operation_name,
             full_name=request_payload.get("user"),
             payload=request_payload.get("variables")
         )
+        request_audit_payload = await AuditHelper.build_request_payload(audit=audit)
 
-        status = result.get("status")
-        message = result.get("message")
-        data = result.get("data")
+        status_code = result.status
+        message = result.message
+        data = result.data
+        error = result.error if result.error else message
         
-        ERROR_PREFIXES = ("DB_ERROR", "DB_WARNING")
-        if status.upper().startswith(ERROR_PREFIXES):
+        if audit_type == Constant.MESSAGE_LOG_INTERNAL:
+
+            ERROR_PREFIXES = ("DB_ERROR", "DB_WARNING")
+
+            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:
             payload = AuditHelper.build_final_payload(
                 _type="ERROR",
-                status_code=status,
-                error=message
+                status_code=status_code,
+                error=error
             )
 
             audit_message = request_audit_payload | payload
@@ -95,10 +123,10 @@ class AuditDispatcher:
         else:
             payload = AuditHelper.build_final_payload(
                 _type="RESPONSE",
-                status_code="200",
+                status_code=status_code,
                 result=data
             )
 
             audit_message = request_audit_payload | payload
         
-        await self._messaging.enqueue(audit_message)
+        await self._messaging.send_message(audit_message)