Encryptors 2.30__tar.gz → 2.32__tar.gz

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

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

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

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

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

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

{encryptors-2.30 → 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.30 → encryptors-2.32}/src/Osdental/Decorators/SecureResolver.py

@@ -1,5 +1,5 @@
 import inspect
-import asyncio
+import copy
 from functools import wraps
 from typing import Callable, Dict, Any
 from graphql import GraphQLResolveInfo
@@ -33,38 +33,21 @@ def secure_resolver(action = None):
 
                 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
-                # )
+                info.context.audit_plain_response = copy.deepcopy(result)
 
                 if result.data is not None:
-                    result.data = aes.encrypt(security.encryptor.aes_auth, result.data)
-                    
+                    result.data = aes.encrypt(aes_key, result.data)
 
-                return result
+                return result.send()
 
             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
+                result = Response(
+                    status=getattr(e, "status_code", "DB_ERROR_UNEXPECTED"),
+                    message=getattr(e, "message", "Could not process request."),
+                    error=f"{type(e).__name__}: {str(e)}"
+                )
+                info.context.audit_plain_response = result
+                return result.send()
 
         return wrapper
     return decorator

{encryptors-2.30 → 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.30 → encryptors-2.32}/src/Osdental/Graphql/Extensions/AuditExtension.py

@@ -1,15 +1,13 @@
-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
+from Osdental.Graphql._Exceptions import AESKeyNotFound
 
 class AuditExtension(Extension):
 
     def request_started(self, context):
-        self.start_time = time.perf_counter()
         self.errors = None
         self.request_payload = None
         self.result = None
@@ -31,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)
             
@@ -52,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,
@@ -67,9 +65,9 @@ class AuditExtension(Extension):
                 "user": token.user_full_name
             }
 
-        context.decrypted_payload = decrypted_payload
-        context.token = token
-        context.aes_key = aes_key
+            context.decrypted_payload = decrypted_payload
+            context.token = token
+            context.aes_key = aes_key
 
         result = next_(root, info, **kwargs)
 
@@ -85,12 +83,16 @@ 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
 
         dispatcher.dispatch(
             request=self.request,
             request_payload=self.request_payload,
-            result=self.result,
+            result=context.audit_plain_response,
             errors=self.errors
         )

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.30 → 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.30 → 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.30 → 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