Encryptors 2.26__tar.gz → 2.28__tar.gz

{encryptors-2.26 → encryptors-2.28}/PKG-INFO

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

{encryptors-2.26 → encryptors-2.28}/setup.py

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

{encryptors-2.26 → encryptors-2.28}/src/Encryptors.egg-info/PKG-INFO

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

{encryptors-2.26 → encryptors-2.28}/src/Encryptors.egg-info/SOURCES.txt

@@ -10,6 +10,7 @@ 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
@@ -73,6 +74,7 @@ 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

encryptors-2.28/src/Osdental/Database/BaseRepository.py

@@ -0,0 +1,98 @@
+from typing import Any
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import AsyncSession
+from Osdental.Exception.ControlledException import DatabaseException
+from Osdental.Shared.Utils.DataNormalizer import normalize
+
+class BaseRepository:
+
+    def __init__(self, async_session: AsyncSession):
+        self.async_session = async_session
+    
+    def _get_status_value(self, rows: dict, *possible_keys: str):
+        for key in possible_keys:
+            if key in rows:
+                return rows[key]
+        return None
+
+    async def _execute_query(
+        self,
+        query: str,
+        params: dict | None = None,
+        *,
+        many: bool = False,
+        as_dict: bool = False
+    ) -> Any:
+        result = await self.async_session.execute(
+            text(query),
+            params or {}
+        )
+        
+        data = (
+            result.mappings().all()
+            if many
+            else result.mappings().first()
+        )
+
+        if not as_dict or data is None:
+            return data
+
+        if many:
+            return normalize(data)
+
+        return normalize(data)
+
+    async def _execute_command(
+        self,
+        query: str,
+        params: dict | None = None,
+        *,
+        validate: bool = True,
+        success_codes: str | int | tuple[str | int, ...] | None = None
+    ):
+        result = await self.async_session.execute(
+            text(query),
+            params or {}
+        )
+
+        row = result.mappings().first()
+
+        if not validate or not row:
+            return row
+
+        status_code = self._get_status_value(
+            row,
+            "statusCode",
+            "STATUS_CODE",
+            "status_code"
+        )
+
+        status_message = self._get_status_value(
+            row,
+            "statusMessage",
+            "STATUS_MESSAGE",
+            "status_message"
+        )
+
+        # Si no se define success_codes, solo valida que no sea None
+        if success_codes is None:
+            if status_code is None:
+                raise DatabaseException(
+                    message="Status code missing",
+                    error="Status code missing",
+                    status_code=500
+                )
+            return row
+
+        # Normalizamos a tupla
+        if not isinstance(success_codes, tuple):
+            success_codes = (success_codes,)
+
+        if status_code not in success_codes:
+            raise DatabaseException(
+                message=status_message,
+                error=status_message,
+                status_code=status_code
+            )
+
+        return row

{encryptors-2.26 → encryptors-2.28}/src/Osdental/Messaging/AzureServiceBus.py

@@ -4,7 +4,7 @@ from azure.servicebus import ServiceBusMessage
 from azure.servicebus.aio import ServiceBusClient
 from azure.identity.aio import DefaultAzureCredential
 
-class ServiceBusService:
+class AzureServiceBusQueue:
 
     def __init__(self, namespace: str, queue_name: str):
 

encryptors-2.28/src/Osdental/Shared/Utils/DataNormalizer.py

@@ -0,0 +1,58 @@
+from datetime import datetime, date
+from decimal import Decimal
+from uuid import UUID
+from typing import Any
+from sqlalchemy import RowMapping
+
+def is_uuid_string(value: str) -> bool:
+    try:
+        UUID(value)
+        return True
+    except (ValueError, TypeError):
+        return False
+    
+def normalize_odbc_value(value: Any) -> Any:
+    """
+    Convierte valores problemáticos de ODBC a tipos JSON serializables.
+    """
+    
+    if value is None:
+        return None
+    
+    if isinstance(value, Decimal):
+        return float(value)
+
+    if isinstance(value, (datetime, date)):
+        return value.isoformat()
+
+    if isinstance(value, UUID):
+        return str(value).lower()
+    
+    if isinstance(value, str) and is_uuid_string(value):
+        return value.lower()
+
+    return value
+
+def normalize(data: Any) -> Any:
+    """
+    Normaliza cualquier estructura:
+    - RowMapping
+    - dict
+    - list
+    - valores simples
+    """
+
+    # SQLAlchemy RowMapping
+    if isinstance(data, RowMapping):
+        data = dict(data)
+
+    # dict
+    if isinstance(data, dict):
+        return {k: normalize(v) for k, v in data.items()}
+
+    # list / tuple
+    if isinstance(data, (list, tuple)):
+        return [normalize(item) for item in data]
+
+    # valor simple
+    return normalize_odbc_value(data)