Encryptors 2.0__tar.gz → 2.1__tar.gz

{encryptors-2.0 → encryptors-2.1}/PKG-INFO

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

{encryptors-2.0 → encryptors-2.1}/setup.py

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

{encryptors-2.0 → encryptors-2.1}/src/Encryptors.egg-info/PKG-INFO

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

{encryptors-2.0 → encryptors-2.1}/src/Encryptors.egg-info/SOURCES.txt

@@ -30,15 +30,14 @@ src/Osdental/Exception/__init__.py
 src/Osdental/ExternalHttp/Client.py
 src/Osdental/ExternalHttp/__init__.py
 src/Osdental/Grpc/__init__.py
-src/Osdental/Grpc/Adapter/SharedLegacyGrpcAdapter.py
-src/Osdental/Grpc/Adapter/SharedResourcesGrpcAdapter.py
+src/Osdental/Grpc/Adapter/AuthGrpcAdapter.py
+src/Osdental/Grpc/Adapter/SharedGrpcAdapter.py
 src/Osdental/Grpc/Adapter/__init__.py
 src/Osdental/Grpc/Base/GrpcClientBase.py
 src/Osdental/Grpc/Base/__init__.py
 src/Osdental/Grpc/Client/AuthGrpcClient.py
 src/Osdental/Grpc/Client/GrpcConnection.py
-src/Osdental/Grpc/Client/SharedLegacyGrpcClient.py
-src/Osdental/Grpc/Client/SharedResourcesGrpcClient.py
+src/Osdental/Grpc/Client/SharedGrpcClient.py
 src/Osdental/Grpc/Client/__init__.py
 src/Osdental/Grpc/Dtos/GrpcResponse.py
 src/Osdental/Grpc/Dtos/__init__.py
@@ -52,6 +51,7 @@ src/Osdental/Grpc/Generated/__init__.py
 src/Osdental/Helpers/AuditLogHelper.py
 src/Osdental/Helpers/AuditQueueHelper.py
 src/Osdental/Helpers/DecryptedHelper.py
+src/Osdental/Helpers/EncryptorHelper.py
 src/Osdental/Helpers/RequestHelper.py
 src/Osdental/Helpers/__init__.py
 src/Osdental/InternalHttp/Request.py
@@ -62,6 +62,7 @@ src/Osdental/Messaging/AzureServiceBus.py
 src/Osdental/Messaging/Kafka.py
 src/Osdental/Messaging/RabbitMQ.py
 src/Osdental/Messaging/__init__.py
+src/Osdental/Models/Encryptor.py
 src/Osdental/Models/Legacy.py
 src/Osdental/Models/Response.py
 src/Osdental/Models/ShardResource.py

{encryptors-2.0 → encryptors-2.1}/src/Osdental/Decorators/AuditLog.py

@@ -3,6 +3,7 @@ import time
 from functools import wraps
 from opentelemetry import trace
 from Osdental.Helpers.AuditLogHelper import AuditLogHelper
+from Osdental.Helpers.EncryptorHelper import EncryptorHelper
 from Osdental.Helpers.AuditQueueHelper import AuditQueueHelper
 from Osdental.InternalHttp.Request import CustomRequest
 from Osdental.Exception.ControlledException import OSDException
@@ -21,8 +22,8 @@ def handle_audit_and_exception(batch: int = 0):
             operation_name = "UnknownOperation"
 
             try:
-                # Load legacy with cache
-                legacy = await AuditLogHelper.get_cached_legacy()
+                # Load encryptor with cache
+                encryptor = await EncryptorHelper.get_cached_encryptors()
 
                 _, info = args[:2]
                 headers = info.context.get("headers") or {}
@@ -46,12 +47,12 @@ def handle_audit_and_exception(batch: int = 0):
                 if request:
                     AuditLogHelper.fire_and_forget(
                         AuditQueueHelper.send(
-                            CustomRequest(request, legacy.aes_key_user).send_to_service_bus()
+                            CustomRequest(request, encryptor.aes_user).send_to_service_bus()
                         )
                     )
 
             except Exception as e:
-                logger.warning(f"Failed to prepare auditing: {e}")
+                logger.exception("Failed to prepare auditing")
 
             # Perform the main logic inside span
             with tracer.start_as_current_span(f"GraphQL.{operation_name}") as span:
@@ -63,7 +64,7 @@ def handle_audit_and_exception(batch: int = 0):
                     # decrypt data if needed
                     raw_data = response.get("data")
                     if raw_data:
-                        decrypted = AuditLogHelper.try_decrypt_or_return_raw(raw_data, legacy.private_key2, legacy.aes_key_auth)
+                        decrypted = AuditLogHelper.try_decrypt_or_return_raw(raw_data, encryptor.private_key_2, encryptor.aes_auth)
                     else:
                         decrypted = None
 
@@ -81,7 +82,7 @@ def handle_audit_and_exception(batch: int = 0):
                     return response
 
                 except OSDException as ex:
-                    logger.error(f'Controlled error: {ex}')
+                    logger.exception("Controlled error")
                     duration = (time.time() - start) * 1000
 
                     msg = str(ex) or getattr(ex, 'message', 'OSDException')
@@ -101,7 +102,7 @@ def handle_audit_and_exception(batch: int = 0):
                     return ex.get_response()
 
                 except Exception as e:
-                    logger.error(f'Unexpected error: {e}')
+                    logger.exception("Unexpected error")
                     ex = OSDException(error=str(e), headers=headers)
                     duration = (time.time() - start) * 1000
 

{encryptors-2.0 → encryptors-2.1}/src/Osdental/Decorators/DecryptedData.py

@@ -2,6 +2,7 @@ import asyncio
 from functools import wraps
 from typing import Callable, Tuple, Optional, Union, Dict, Any
 from graphql import GraphQLResolveInfo
+from Osdental.Helpers.EncryptorHelper import EncryptorHelper
 from Osdental.Helpers.DecryptedHelper import DecryptedHelper
 from Osdental.Exception.ControlledException import ProfilePermissionDeniedException
 from Osdental.Shared.Enums.Message import Message
@@ -10,7 +11,7 @@ from Osdental.Shared.Enums.Message import Message
 def process_encrypted_data(mutate: bool = True, allowed_permissions: Optional[Union[str, Tuple[str, ...]]] = None):
     """
     Decorator to:
-      - get cached legacy (fast & safe)
+      - get cached encryptor (fast & safe)
       - decrypt and validate token (async)
       - decrypt aes_data (CPU-bound small op)
       - perform profile permission checks
@@ -21,8 +22,8 @@ def process_encrypted_data(mutate: bool = True, allowed_permissions: Optional[Un
 
         @wraps(func)
         async def wrapper(self, info: GraphQLResolveInfo = None, aes_data: str = None, **rest_kwargs):
-            # 1) Get legacy (fast cached path)
-            legacy = await DecryptedHelper.get_cached_legacy()
+            # 1) Get encryptor (fast cached path)
+            encryptor = await EncryptorHelper.get_cached_encryptors()
 
             # 2) Extract context & headers safely
             token_task = None
@@ -36,15 +37,15 @@ def process_encrypted_data(mutate: bool = True, allowed_permissions: Optional[Un
             headers = info.context.get('headers', {}) or {}
 
             # 3) Start tasks in parallel where possible
-            # decrypted_token requires legacy + info
-            token_coro = DecryptedHelper.decrypted_token(info, legacy, mutate) if param_mask["token"] else None
-            # decrypted_data requires aes_key_auth and token (token not yet available)
-            # we can start decrypting aes_data because aes decrypt only needs aes_key_auth (from legacy)
+            # decrypted_token requires encryptor + info
+            token_coro = DecryptedHelper.decrypted_token(info, encryptor, mutate) if param_mask["token"] else None
+            # decrypted_data requires aes_auth and token (token not yet available)
+            # we can start decrypting aes_data because aes decrypt only needs aes_auth (from encryptor)
             data_coro = None
             if param_mask["data"] and aes_data is not None:
                 # decrypt is sync in our lib -> wrap in loop.run_in_executor to avoid blocking event loop if heavy
                 loop = asyncio.get_running_loop()
-                data_coro = loop.run_in_executor(None, DecryptedHelper.decrypted_data, aes_data, legacy.aes_key_auth, None)
+                data_coro = loop.run_in_executor(None, DecryptedHelper.decrypted_data, aes_data, encryptor.aes_auth, None)
 
             # run token and data decrypt in parallel (token will run validate_token internally)
             results = await asyncio.gather(*[c for c in (token_coro, data_coro) if c is not None], return_exceptions=True)
@@ -70,7 +71,7 @@ def process_encrypted_data(mutate: bool = True, allowed_permissions: Optional[Un
             if token_result and data_result is None and aes_data is not None and param_mask["data"]:
                 # decrypt using executor to avoid blocking (sync operation)
                 loop = asyncio.get_running_loop()
-                data_result = await loop.run_in_executor(None, DecryptedHelper.decrypted_data, aes_data, legacy.aes_key_auth, token_result)
+                data_result = await loop.run_in_executor(None, DecryptedHelper.decrypted_data, aes_data, encryptor.aes_auth, token_result)
 
             # If we have both token and data and we decrypted data before token (token finished later),
             # ensure token id_external_enterprise override is applied:

{encryptors-2.0 → encryptors-2.1}/src/Osdental/ExternalHttp/Client.py

@@ -4,12 +4,13 @@ import httpx
 from datetime import datetime
 from typing import Dict, Optional
 from Osdental.Decorators.Retry import rest_retry
-from Osdental.Shared.Logger import logger
+from Osdental.Helpers.AuditLogHelper import AuditLogHelper
+from Osdental.Helpers.AuditQueueHelper import AuditQueueHelper
 from Osdental.Shared.Enums.Constant import Constant
 from Osdental.Shared.Enums.App import App
 from Osdental.Shared.Instance import Instance
 
-# Limita concurrencia hacia Service Bus (evita saturación)
+# Limits attendance towards Service Bus (avoids saturation)
 _SERVICE_BUS_SEMAPHORE = asyncio.Semaphore(100)
 
 
@@ -29,20 +30,6 @@ class APIClient(httpx.AsyncClient):
         )
 
 
-    @staticmethod
-    def fire_and_forget(coro):
-        task = asyncio.create_task(coro)
-
-        def _callback(t: asyncio.Task):
-            try:
-                t.result()
-            except Exception as e:
-                logger.error(f"[APIClient] background task error: {e}")
-
-        task.add_done_callback(_callback)
-        return task
-
-
     def _handle_response(self, response: httpx.Response):
         response.raise_for_status()
 
@@ -66,19 +53,23 @@ class APIClient(httpx.AsyncClient):
     ):
         headers = kwargs.get("headers", {})
 
-        APIClient.fire_and_forget(
-            self.send_request_to_service_bus(
-                endpoint=url,
-                body=kwargs.get("body"),
-                headers=headers,
-                http_method=method
+        AuditLogHelper.fire_and_forget(
+            AuditQueueHelper.send(
+                self.send_request_to_service_bus(
+                    endpoint=url,
+                    body=kwargs.get("body"),
+                    headers=headers,
+                    http_method=method
+                )
             )
         )
 
         response = await self.request(method, url, *args, **kwargs)
 
-        APIClient.fire_and_forget(
-            self.send_response_to_service_bus(response, headers)
+        AuditLogHelper.fire_and_forget(
+            AuditQueueHelper.send(
+                self.send_response_to_service_bus(response, headers)
+            )
         )
 
         return self._handle_response(response)
@@ -94,12 +85,14 @@ class APIClient(httpx.AsyncClient):
     ):
         headers = headers or {}
 
-        APIClient.fire_and_forget(
-            self.send_request_to_service_bus(
-                endpoint=url,
-                body=variables,
-                headers=headers,
-                http_method="POST"
+        AuditLogHelper.fire_and_forget(
+            AuditQueueHelper.send(
+                self.send_request_to_service_bus(
+                    endpoint=url,
+                    body=variables,
+                    headers=headers,
+                    http_method="POST"
+                )
             )
         )
 
@@ -109,8 +102,10 @@ class APIClient(httpx.AsyncClient):
             headers=headers
         )
 
-        APIClient.fire_and_forget(
-            self.send_response_to_service_bus(response, headers)
+        AuditLogHelper.fire_and_forget(
+            AuditQueueHelper.send(
+                self.send_response_to_service_bus(response, headers)
+            )
         )
 
         return self._handle_response(response)

encryptors-2.1/src/Osdental/Grpc/Adapter/AuthGrpcAdapter.py

@@ -0,0 +1,15 @@
+import json
+from Osdental.Grpc.Client.AuthGrpcClient import AuthGrpcClient
+
+class AuthGrpcAdapter:
+
+    def __init__(self, client: AuthGrpcClient):
+        self.client = client
+
+
+    async def validate_auth_token(self, data: str) -> bool:
+        response = await self.client.call_validate_auth_token(data)
+        if response.status != 200:
+            raise ValueError(response.message)
+        
+        return response.data

encryptors-2.1/src/Osdental/Grpc/Adapter/SharedGrpcAdapter.py

@@ -0,0 +1,28 @@
+import json
+from Osdental.Grpc.Client.SharedGrpcClient import SharedGrpcClient
+from Osdental.Models.Encryptor import Encryptor
+from Osdental.Models.ShardResource import ShardResource
+
+class SharedGrpcAdapter:
+
+    def __init__(self, client: SharedGrpcClient):
+        self.client = client
+    
+    
+    async def get_shared_encryptions(self) -> Encryptor:
+        response = await self.client.call_get_shared_encryptions()
+        if response.status != 200:
+            raise ValueError(response.message)
+        
+        data_dict = json.loads(response.data)
+        return Encryptor.model_validate(data_dict)
+    
+
+    async def get_shared_resources(self, id_external_enterprise: str, microservice_name: str) -> ShardResource:
+        response = await self.client.call_get_shared_resources(id_external_enterprise, microservice_name)
+        if response.status != 200:
+            raise ValueError(response.message)
+        
+        data_dict = json.loads(response.data)
+        return ShardResource.model_validate(data_dict)
+    

{encryptors-2.0 → encryptors-2.1}/src/Osdental/Grpc/Client/AuthGrpcClient.py

@@ -17,9 +17,9 @@ class AuthGrpcClient:
 
 
     @grpc_retry
-    async def validate_auth_token(self, request) -> GrpcResponse:
+    async def call_validate_auth_token(self, data: str) -> GrpcResponse:
         await self._ensure_stub()
-        request = Auth_pb2.AuthTokenRequest(data=request)
+        request = Auth_pb2.AuthTokenRequest(data=data)
         response = await self.stub.ValidateAuthToken(request)
         return GrpcResponse(
             status=response.status, 

encryptors-2.0/src/Osdental/Grpc/Client/SharedResourcesGrpcClient.py → encryptors-2.1/src/Osdental/Grpc/Client/SharedGrpcClient.py

@@ -2,7 +2,7 @@ from Osdental.Grpc.Client.GrpcConnection import GrpcConnection
 from Osdental.Grpc.Generated import Shared_pb2_grpc, Shared_pb2
 from Osdental.Grpc.Dtos.GrpcResponse import GrpcResponse
 
-class SharedResourcesGrpcClient:
+class SharedGrpcClient:
     
     def __init__(self, connection: GrpcConnection):
         self.connection = connection
@@ -25,3 +25,13 @@ class SharedResourcesGrpcClient:
             message=response.message, 
             data=response.data
         )
+
+    async def call_get_shared_encryptions(self) -> GrpcResponse:
+        await self._ensure_stub()
+        request = Shared_pb2.EmptyRequest()
+        response = await self.stub.GetShardEncryptionData(request)
+        return GrpcResponse(
+            status=response.status, 
+            message=response.message, 
+            data=response.data
+        )

{encryptors-2.0 → encryptors-2.1}/src/Osdental/Grpc/Generated/Shared_pb2.py

@@ -24,7 +24,7 @@ _sym_db = _symbol_database.Default()
 
 
 
-DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0cShared.proto\x12\nShardProto\"\x0e\n\x0c\x45mptyRequest\"H\n\x0eGetUserRequest\x12\x1c\n\x14idExternalEnterprise\x18\x01 \x01(\t\x12\x18\n\x10microserviceName\x18\x02 \x01(\t\"\x1c\n\x0cSetKeyPortal\x12\x0c\n\x04\x64\x61ta\x18\x01 \x01(\t\">\n\x10GetTenantRequest\x12\x18\n\x10microserviceName\x18\x01 \x01(\t\x12\x10\n\x08idTenant\x18\x02 \x01(\t\">\n\rShardResponse\x12\x0e\n\x06status\x18\x01 \x01(\x05\x12\x0f\n\x07message\x18\x02 \x01(\t\x12\x0c\n\x04\x64\x61ta\x18\x03 \x01(\t2\xd2\x02\n\rShardResource\x12X\n\x1fGetShardResourcesByMicroservice\x12\x1a.ShardProto.GetUserRequest\x1a\x19.ShardProto.ShardResponse\x12\x45\n\x0eGetShardLegacy\x12\x18.ShardProto.SetKeyPortal\x1a\x19.ShardProto.ShardResponse\x12J\n\x13GetShardSqlSecurity\x12\x18.ShardProto.EmptyRequest\x1a\x19.ShardProto.ShardResponse\x12T\n\x19GetShardResourcesByTenant\x12\x1c.ShardProto.GetTenantRequest\x1a\x19.ShardProto.ShardResponseb\x06proto3')
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x0cShared.proto\x12\nShardProto\"\x0e\n\x0c\x45mptyRequest\"H\n\x0eGetUserRequest\x12\x1c\n\x14idExternalEnterprise\x18\x01 \x01(\t\x12\x18\n\x10microserviceName\x18\x02 \x01(\t\"\x1c\n\x0cSetKeyPortal\x12\x0c\n\x04\x64\x61ta\x18\x01 \x01(\t\">\n\x10GetTenantRequest\x12\x18\n\x10microserviceName\x18\x01 \x01(\t\x12\x10\n\x08idTenant\x18\x02 \x01(\t\">\n\rShardResponse\x12\x0e\n\x06status\x18\x01 \x01(\x05\x12\x0f\n\x07message\x18\x02 \x01(\t\x12\x0c\n\x04\x64\x61ta\x18\x03 \x01(\t2\xa1\x03\n\rShardResource\x12X\n\x1fGetShardResourcesByMicroservice\x12\x1a.ShardProto.GetUserRequest\x1a\x19.ShardProto.ShardResponse\x12\x45\n\x0eGetShardLegacy\x12\x18.ShardProto.SetKeyPortal\x1a\x19.ShardProto.ShardResponse\x12J\n\x13GetShardSqlSecurity\x12\x18.ShardProto.EmptyRequest\x1a\x19.ShardProto.ShardResponse\x12T\n\x19GetShardResourcesByTenant\x12\x1c.ShardProto.GetTenantRequest\x1a\x19.ShardProto.ShardResponse\x12M\n\x16GetShardEncryptionData\x12\x18.ShardProto.EmptyRequest\x1a\x19.ShardProto.ShardResponseb\x06proto3')
 
 _globals = globals()
 _builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, _globals)
@@ -42,5 +42,5 @@ if not _descriptor._USE_C_DESCRIPTORS:
   _globals['_SHARDRESPONSE']._serialized_start=212
   _globals['_SHARDRESPONSE']._serialized_end=274
   _globals['_SHARDRESOURCE']._serialized_start=277
-  _globals['_SHARDRESOURCE']._serialized_end=615
+  _globals['_SHARDRESOURCE']._serialized_end=694
 # @@protoc_insertion_point(module_scope)

{encryptors-2.0 → encryptors-2.1}/src/Osdental/Grpc/Generated/Shared_pb2_grpc.py

@@ -54,6 +54,11 @@ class ShardResourceStub(object):
                 request_serializer=Shared__pb2.GetTenantRequest.SerializeToString,
                 response_deserializer=Shared__pb2.ShardResponse.FromString,
                 _registered_method=True)
+        self.GetShardEncryptionData = channel.unary_unary(
+                '/ShardProto.ShardResource/GetShardEncryptionData',
+                request_serializer=Shared__pb2.EmptyRequest.SerializeToString,
+                response_deserializer=Shared__pb2.ShardResponse.FromString,
+                _registered_method=True)
 
 
 class ShardResourceServicer(object):
@@ -83,6 +88,12 @@ class ShardResourceServicer(object):
         context.set_details('Method not implemented!')
         raise NotImplementedError('Method not implemented!')
 
+    def GetShardEncryptionData(self, request, context):
+        """Missing associated documentation comment in .proto file."""
+        context.set_code(grpc.StatusCode.UNIMPLEMENTED)
+        context.set_details('Method not implemented!')
+        raise NotImplementedError('Method not implemented!')
+
 
 def add_ShardResourceServicer_to_server(servicer, server):
     rpc_method_handlers = {
@@ -106,6 +117,11 @@ def add_ShardResourceServicer_to_server(servicer, server):
                     request_deserializer=Shared__pb2.GetTenantRequest.FromString,
                     response_serializer=Shared__pb2.ShardResponse.SerializeToString,
             ),
+            'GetShardEncryptionData': grpc.unary_unary_rpc_method_handler(
+                    servicer.GetShardEncryptionData,
+                    request_deserializer=Shared__pb2.EmptyRequest.FromString,
+                    response_serializer=Shared__pb2.ShardResponse.SerializeToString,
+            ),
     }
     generic_handler = grpc.method_handlers_generic_handler(
             'ShardProto.ShardResource', rpc_method_handlers)
@@ -224,3 +240,30 @@ class ShardResource(object):
             timeout,
             metadata,
             _registered_method=True)
+
+    @staticmethod
+    def GetShardEncryptionData(request,
+            target,
+            options=(),
+            channel_credentials=None,
+            call_credentials=None,
+            insecure=False,
+            compression=None,
+            wait_for_ready=None,
+            timeout=None,
+            metadata=None):
+        return grpc.experimental.unary_unary(
+            request,
+            target,
+            '/ShardProto.ShardResource/GetShardEncryptionData',
+            Shared__pb2.EmptyRequest.SerializeToString,
+            Shared__pb2.ShardResponse.FromString,
+            options,
+            channel_credentials,
+            insecure,
+            call_credentials,
+            compression,
+            wait_for_ready,
+            timeout,
+            metadata,
+            _registered_method=True)

{encryptors-2.0 → encryptors-2.1}/src/Osdental/Helpers/AuditLogHelper.py

@@ -4,32 +4,12 @@ from typing import Dict, Any
 from Osdental.InternalHttp.Response import CustomResponse
 from Osdental.Encryptor.Rsa import RSAEncryptor
 from Osdental.Shared.Logger import logger
-from Osdental.Shared.Enums.App import App
 from Osdental.Shared.Instance import Instance
 from Osdental.Helpers.AuditQueueHelper import AuditQueueHelper
 
 
-class AuditLogHelper:
-
-    _GRPC_LEGACY_CACHE = {"value": None, "timestamp": 0}
-    _GRPC_LOCK = asyncio.Lock()
-    
-    @staticmethod
-    async def get_cached_legacy():
-        """Cache the legacy for X seconds to avoid GRPC calls on every resolver."""
-        
-
-        if AuditLogHelper._GRPC_LEGACY_CACHE["value"] is not None:
-            return AuditLogHelper._GRPC_LEGACY_CACHE["value"]
-
-        async with AuditLogHelper._GRPC_LOCK:
-            if AuditLogHelper._GRPC_LEGACY_CACHE["value"] is not None:
-                return AuditLogHelper._GRPC_LEGACY_CACHE["value"]
-
-            legacy = await Instance.grpc_shared_adapter.get_shared_legacies(App.LEGACY_NAME)
-            AuditLogHelper._GRPC_LEGACY_CACHE["value"] = legacy
-            return legacy
-
+class AuditLogHelper:    
+ 
     @staticmethod
     def fire_and_forget(coro):
         """Centralized task handler to avoid silent errors."""
@@ -39,7 +19,7 @@ class AuditLogHelper:
             try:
                 t.result()
             except Exception as e:
-                logger.error(f"[fire_and_forget] Unhandled task error: {e}")
+                logger.exception("[fire_and_forget] Unhandled task error")
 
         task.add_done_callback(_callback)
         return task

{encryptors-2.0 → encryptors-2.1}/src/Osdental/Helpers/DecryptedHelper.py

@@ -5,11 +5,8 @@ from typing import Callable, Tuple, Optional, Union, Dict, Any
 from graphql import GraphQLResolveInfo
 from graphql import OperationType
 from Osdental.Encryptor.Jwt import JWT
-from Osdental.Exception.ControlledException import (
-    UnauthorizedException, 
-    InvalidFormatException, OSDException
-)
-from Osdental.Models.Legacy import Legacy
+from Osdental.Exception.ControlledException import UnauthorizedException, InvalidFormatException
+from Osdental.Models.Encryptor import Encryptor
 from Osdental.Models.Token import AuthToken
 from Osdental.Shared.Enums.Message import Message
 from Osdental.Shared.Enums.Profile import Profile
@@ -19,23 +16,7 @@ from Osdental.Shared.Instance import Instance
 
 class DecryptedHelper:
 
-    _GRPC_LEGACY_CACHE = {"value": None, "timestamp": 0}
-    _GRPC_LOCK = asyncio.Lock()
     _PARAM_MASK_CACHE: Dict[Callable, Dict[str, bool]] = {}
-    
-    @staticmethod
-    async def get_cached_legacy():
-        """Cache the legacy for X seconds to avoid GRPC calls on every resolver."""
-        if DecryptedHelper._GRPC_LEGACY_CACHE["value"] is not None:
-            return DecryptedHelper._GRPC_LEGACY_CACHE["value"]
-
-        async with DecryptedHelper._GRPC_LOCK:
-            if DecryptedHelper._GRPC_LEGACY_CACHE["value"] is not None:
-                return DecryptedHelper._GRPC_LEGACY_CACHE["value"]
-
-            legacy = await Instance.grpc_shared_adapter.get_shared_legacies(App.LEGACY_NAME)
-            DecryptedHelper._GRPC_LEGACY_CACHE["value"] = legacy
-            return legacy
 
 
     @staticmethod
@@ -50,17 +31,13 @@ class DecryptedHelper:
             "id_external_enterprise": id_external_enterprise,
             "id_tenant": id_tenant
         }
-        res = await Instance.auth_client.validate_auth_token(json.dumps(request))
-        if res.status != 200:
-            raise OSDException(error=res.message)
-
-        is_auth = res.data
+        is_auth = await Instance.grpc_auth_adapter.validate_auth_token(json.dumps(request))
         if not is_auth:
             raise UnauthorizedException(message=Message.PORTAL_ACCESS_RESTRICTED_MSG, error=Message.PORTAL_ACCESS_RESTRICTED_MSG)
         
     
     @staticmethod
-    async def decrypted_token(info: GraphQLResolveInfo, legacy: Legacy, mutate: bool = True) -> Optional[AuthToken]:
+    async def decrypted_token(info: GraphQLResolveInfo, encryptor: Encryptor, mutate: bool = True) -> Optional[AuthToken]:
         """
         Decrypts and validates the context token (user_token).
         Returns AuthToken or None if no token exists.
@@ -71,10 +48,10 @@ class DecryptedHelper:
         if not user_token_encrypted:
             return None
 
-        # decrypt user_token using legacy user key
-        user_token = Instance.aes.decrypt(legacy.aes_key_user, user_token_encrypted)
+        # decrypt user_token using encryptor user key
+        user_token = Instance.aes.decrypt(encryptor.aes_user, user_token_encrypted)
         payload = JWT.extract_payload(user_token, App.JWT_USER_KEY)
-        payload['legacy'] = legacy
+        payload['encryptor'] = encryptor
         payload['jwt_user_key'] = App.JWT_USER_KEY
 
         access_token = info.context.get('access_token')

encryptors-2.1/src/Osdental/Helpers/EncryptorHelper.py

@@ -0,0 +1,24 @@
+import asyncio
+from Osdental.Models.Encryptor import Encryptor
+from Osdental.Shared.Instance import Instance
+
+
+class EncryptorHelper:
+
+    _GRPC_ENCRYPTOR_CACHE = {"value": None, "timestamp": 0}
+    _GRPC_LOCK = asyncio.Lock()
+    
+    @staticmethod
+    async def get_cached_encryptors() -> Encryptor:
+        """Cache the encryptors for X seconds to avoid GRPC calls on every resolver."""
+        
+        if EncryptorHelper._GRPC_ENCRYPTOR_CACHE["value"] is not None:
+            return EncryptorHelper._GRPC_ENCRYPTOR_CACHE["value"]
+
+        async with EncryptorHelper._GRPC_LOCK:
+            if EncryptorHelper._GRPC_ENCRYPTOR_CACHE["value"] is not None:
+                return EncryptorHelper._GRPC_ENCRYPTOR_CACHE["value"]
+
+            encryptor = await Instance.grpc_shared_adapter.get_shared_encryptions()
+            EncryptorHelper._GRPC_ENCRYPTOR_CACHE["value"] = encryptor
+            return encryptor

{encryptors-2.0 → encryptors-2.1}/src/Osdental/Messaging/AzureServiceBus.py

@@ -51,7 +51,7 @@ class AzureServiceBusQueue(IMessageQueue):
                             results.append(body)
                             await receiver.complete_message(msg)
                         except Exception as e:
-                            logger.error(f"Processing message failed: {e}")
+                            logger.exception("Processing message failed")
                             await receiver.abandon_message(msg)
                             
                 return results

encryptors-2.1/src/Osdental/Models/Encryptor.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel, Field
+
+class Encryptor(BaseModel):
+    public_key_1: str = Field(alias="PublicKey1")
+    public_key_2: str = Field(alias="PublicKey2")
+    private_key_1: str = Field(alias="SecretKey1")
+    private_key_2: str = Field(alias="SecretKey1")
+    aes_auth: str = Field(alias="AesAuth")
+    aes_user: str = Field(alias="AesUser")
+
+    class ConfigDict:
+        populate_by_name = True

{encryptors-2.0 → encryptors-2.1}/src/Osdental/Models/Token.py

@@ -1,6 +1,6 @@
 from pydantic import BaseModel, Field
 from typing import Optional
-from Osdental.Models.Legacy import Legacy
+from Osdental.Models.Encryptor import Encryptor
 
 class AuthToken(BaseModel):
     id_token: str = Field(alias="idToken")
@@ -19,7 +19,7 @@ class AuthToken(BaseModel):
     base_id_external_enterprise: Optional[str] = None
     mk_id_external_enterprise: Optional[str] = None
     jwt_user_key: Optional[str] = None
-    legacy: Optional[Legacy] = None
+    encryptor: Optional[Encryptor] = None
 
     class ConfigDict:
         populate_by_name = True

{encryptors-2.0 → encryptors-2.1}/src/Osdental/RedisCache/Redis.py

@@ -1,9 +1,6 @@
 import json
 from typing import Dict, List, Optional
 import redis.asyncio as redis
-from Osdental.Exception.ControlledException import RedisException
-from Osdental.Shared.Logger import logger
-from Osdental.Shared.Enums.Message import Message
 from Osdental.Shared.Enums.Constant import Constant
 
 class RedisCacheAsync:
@@ -26,56 +23,37 @@ class RedisCacheAsync:
 
     async def set_dict(self, key: str, value: Dict, ttl: Optional[int] = None):
         """Set a JSON value in the cache."""
-        try:
-            json_value = json.dumps(value)
-            await self.client.set(key, json_value)
-            if ttl:
-                await self.client.expire(key, ttl)
-        except Exception as e:
-            logger.error(f'Redis set_dict error: {str(e)}')
-            raise RedisException(message=Message.UNEXPECTED_ERROR_MSG, error=str(e))
+        json_value = json.dumps(value)
+        await self.client.set(key, json_value)
+        if ttl:
+            await self.client.expire(key, ttl)
 
 
     async def set_str(self, key: str, value: str, ttl: Optional[int] = None):
         """Set a string value in the cache."""
-        try:
-            await self.client.set(key, value)
-            if ttl:
-                await self.client.expire(key, ttl)
-        except Exception as e:
-            logger.error(f'Redis set_str error: {str(e)}')
-            raise RedisException(message=Message.UNEXPECTED_ERROR_MSG, error=str(e))
+        await self.client.set(key, value)
+        if ttl:
+            await self.client.expire(key, ttl)
 
 
     async def get_dict(self, key: str) -> Optional[str]:
         """Get a JSON value from the cache and convert it back to a Python object."""
-        try:
-            json_value = await self.client.get(key)
-            if json_value:
-                return json.loads(json_value)
-            return None
-        except Exception as e:
-            logger.error(f'Redis get_dict error: {str(e)}')
-            raise RedisException(message=Message.UNEXPECTED_ERROR_MSG, error=str(e))
+        json_value = await self.client.get(key)
+        if json_value:
+            return json.loads(json_value)
+        
+        return None
 
 
     async def get_str(self, key: str) -> Optional[str]:
         """Get a string value from the cache."""
-        try:
-            value = await self.client.get(key)
-            return value.decode(Constant.DEFAULT_ENCODING) if value else None
-        except Exception as e:
-            logger.error(f'Redis get_str error: {str(e)}')
-            raise RedisException(message=Message.UNEXPECTED_ERROR_MSG, error=str(e))
+        value = await self.client.get(key)
+        return value.decode(Constant.DEFAULT_ENCODING) if value else None
 
     
     async def delete(self, key: str) -> bool:
         """Delete a value from the cache."""
-        try:
-            return await self.client.delete(key)
-        except Exception as e:
-            logger.error(f'Redis delete error: {str(e)}')
-            raise RedisException(message=Message.UNEXPECTED_ERROR_MSG, error=str(e))
+        return await self.client.delete(key)
 
 
     async def exists(self, key: str) -> bool:

encryptors-2.1/src/Osdental/ServicesBus/ServicesBus.py

@@ -0,0 +1,21 @@
+import json
+from typing import Dict
+from azure.servicebus.aio import ServiceBusClient
+from azure.servicebus import ServiceBusMessage
+from Osdental.Decorators.Deprecated import deprecated
+
+@deprecated("Replaced class, use Osdental.Messaging.. and implement its port")
+class ServicesBus:
+
+    def __init__(self, conn_str:str, queue_name:str):
+        self.conn_str = conn_str
+        self.queue_name = queue_name
+
+
+    async def send_message(self, message:Dict[str,str] | str) -> None:
+        """Method to send a message to the Service Bus."""
+        data = json.dumps(message) if isinstance(message, dict) else message
+        async with ServiceBusClient.from_connection_string(self.conn_str) as servicebus_client:
+            async with servicebus_client.get_queue_sender(queue_name=self.queue_name) as sender:
+                message = ServiceBusMessage(data)
+                await sender.send_messages(message)

{encryptors-2.0 → encryptors-2.1}/src/Osdental/Shared/Enums/App.py

@@ -5,7 +5,6 @@ from dotenv import load_dotenv
 load_dotenv(dotenv_path='.env', override=True)
 
 class App(StrEnum):
-    LEGACY_NAME = os.getenv('LEGACY_NAME')
     MICROSERVICE_NAME = os.getenv('MICROSERVICE_NAME')
     JWT_USER_KEY = os.getenv('JWT_USER_KEY')
     ENVIRONMENT = os.getenv('ENVIRONMENT')

{encryptors-2.0 → encryptors-2.1}/src/Osdental/Shared/Instance.py

@@ -2,9 +2,10 @@ import httpx
 from Osdental.Encryptor.Aes import AES
 from Osdental.Messaging.AuditServiceBus import AuditServiceBus
 from Osdental.Grpc.Client.AuthGrpcClient import AuthGrpcClient
+from Osdental.Grpc.Adapter.AuthGrpcAdapter import AuthGrpcAdapter
 from Osdental.Grpc.Client.GrpcConnection import GrpcConnection
-from Osdental.Grpc.Client.SharedLegacyGrpcClient import SharedLegacyGrpcClient
-from Osdental.Grpc.Adapter.SharedLegacyGrpcAdapter import SharedLegacyGrpcAdapter
+from Osdental.Grpc.Client.SharedGrpcClient import SharedGrpcClient
+from Osdental.Grpc.Adapter.SharedGrpcAdapter import SharedGrpcAdapter
 from Osdental.Shared.Config import Config
 
 class Instance:
@@ -12,13 +13,14 @@ class Instance:
     # Service bus audit log
     sb_audit = AuditServiceBus(Config.CONNECTION_STRING, Config.AUDIT_QUEUE)
     # Grpc Security
-    grpc_security_conn = GrpcConnection(Config.SECURITY_GRPC_HOST)
-    auth_client = AuthGrpcClient(grpc_security_conn)
+    grpc_auth_conn = GrpcConnection(Config.SECURITY_GRPC_HOST)
+    grpc_auth_client = AuthGrpcClient(grpc_auth_conn)
+    grpc_auth_adapter = AuthGrpcAdapter(grpc_auth_client)
 
     # Grpc Shared Resources
     grpc_shared_conn = GrpcConnection(Config.SHARED_GRPC_HOST)
-    grpc_shared_client = SharedLegacyGrpcClient(grpc_shared_conn)
-    grpc_shared_adapter = SharedLegacyGrpcAdapter(grpc_shared_client)
+    grpc_shared_client = SharedGrpcClient(grpc_shared_conn)
+    grpc_shared_adapter = SharedGrpcAdapter(grpc_shared_client)
 
     # AES Encryptor
     aes = AES()

encryptors-2.1/src/Osdental/Shared/Logger.py

@@ -0,0 +1,3 @@
+import logging
+
+logger = logging.getLogger(__name__)

encryptors-2.0/src/Osdental/Grpc/Adapter/SharedLegacyGrpcAdapter.py

@@ -1,17 +0,0 @@
-import json
-from Osdental.Grpc.Client.SharedLegacyGrpcClient import SharedLegacyGrpcClient
-from Osdental.Models.Legacy import Legacy
-
-class SharedLegacyGrpcAdapter:
-
-    def __init__(self, client: SharedLegacyGrpcClient):
-        self.client = client
-
-
-    async def get_shared_legacies(self, data: str) -> Legacy:
-        response = await self.client.call_get_shared_legacies(data)
-        if response.status != 200:
-            raise ValueError(response.message)
-        
-        data_dict = json.loads(response.data)
-        return Legacy(**data_dict)

encryptors-2.0/src/Osdental/Grpc/Adapter/SharedResourcesGrpcAdapter.py

@@ -1,19 +0,0 @@
-import json
-from Osdental.Grpc.Client.SharedResourcesGrpcClient import SharedResourcesGrpcClient
-from Osdental.Exception.ControlledException import OSDException
-from Osdental.Models.ShardResource import ShardResource
-
-
-class SharedResourcesGrpcAdapter:
-
-    def __init__(self, client: SharedResourcesGrpcClient):
-        self.client = client
-
-
-    async def get_shared_resources(self, id_external_enterprise: str, microservice_name: str) -> ShardResource:
-        response = await self.client.call_get_shared_resources(id_external_enterprise, microservice_name)
-        if response.status != 200:
-            raise OSDException(message=response.message, error=response.message)
-        
-        data_dict = json.loads(response.data)
-        return ShardResource(**data_dict)

encryptors-2.0/src/Osdental/Grpc/Client/SharedLegacyGrpcClient.py

@@ -1,26 +0,0 @@
-from Osdental.Grpc.Client.GrpcConnection import GrpcConnection
-from Osdental.Grpc.Generated import Shared_pb2_grpc, Shared_pb2
-from Osdental.Grpc.Dtos.GrpcResponse import GrpcResponse
-
-
-class SharedLegacyGrpcClient:
-    
-    def __init__(self, connection: GrpcConnection):
-        self.connection = connection
-        self.stub = None
-
-    async def _ensure_stub(self):
-        if not self.stub:
-            channel = await self.connection.connect()
-            self.stub = Shared_pb2_grpc.ShardResourceStub(channel)
-
-
-    async def call_get_shared_legacies(self, data: str) -> GrpcResponse:
-        await self._ensure_stub()
-        request = Shared_pb2.SetKeyPortal(data=data)
-        response = await self.stub.GetShardLegacy(request)
-        return GrpcResponse(
-            status=response.status, 
-            message=response.message, 
-            data=response.data
-        )

encryptors-2.0/src/Osdental/ServicesBus/ServicesBus.py

@@ -1,28 +0,0 @@
-import json
-from typing import Dict
-from azure.servicebus.aio import ServiceBusClient
-from azure.servicebus import ServiceBusMessage
-from Osdental.Shared.Logger import logger
-from Osdental.Shared.Enums.Message import Message
-from Osdental.Decorators.Deprecated import deprecated
-
-@deprecated("Replaced class, use Osdental.Messaging.. and implement its port")
-class ServicesBus:
-
-    def __init__(self, conn_str:str, queue_name:str):
-        self.conn_str = conn_str
-        self.queue_name = queue_name
-
-
-    async def send_message(self, message:Dict[str,str] | str) -> None:
-        """Method to send a message to the Service Bus."""
-        try:
-            data = json.dumps(message) if isinstance(message, dict) else message
-            async with ServiceBusClient.from_connection_string(self.conn_str) as servicebus_client:
-                async with servicebus_client.get_queue_sender(queue_name=self.queue_name) as sender:
-                    message = ServiceBusMessage(data)
-                    await sender.send_messages(message)
-
-        except Exception as e:
-            logger.error(f'Unexpected services bus error: {str(e)}')
-            raise ValueError(f'{Message.UNEXPECTED_ERROR_MSG}: {str(e)}')

encryptors-2.0/src/Osdental/Shared/Logger.py

@@ -1,17 +0,0 @@
-import logging
-import colorlog
-
-handler = colorlog.StreamHandler()
-handler.setFormatter(colorlog.ColoredFormatter(
-    '%(log_color)s%(levelname)s:%(name)s:%(message)s',  
-    log_colors={
-        'DEBUG': 'cyan',
-        'INFO': 'green',
-        'WARNING': 'yellow',
-        'ERROR': 'red',
-        'CRITICAL': 'bold_red',
-    }
-))
-logger = colorlog.getLogger('my_logger')
-logger.addHandler(handler)
-logger.setLevel(logging.DEBUG)