b1sl-python 0.1.0__py3-none-any.whl

b1sl/saphdb/adapter.py

@@ -0,0 +1,24 @@
+from typing import Optional
+
+from b1sl.saphdb.config import SapHDBConfig
+from b1sl.saphdb.odbc_adapter import HDBCliAdapter
+
+# This module provides a shared odbc_adapter instance for Django users.
+# It uses settings.SAPODBCLIENT_* vars from the Django environment.
+# Avoid importing this if not in a Django context.
+
+_odbc_adapter: Optional[HDBCliAdapter] = None
+
+
+def get_odbc_adapter() -> HDBCliAdapter:
+    global _odbc_adapter
+    if _odbc_adapter is None:
+        _odbc_adapter = HDBCliAdapter.from_config(SapHDBConfig.from_django_settings())
+    return _odbc_adapter
+
+
+# Legacy support for direct access
+try:
+    odbc_adapter = get_odbc_adapter()
+except Exception:
+    odbc_adapter = None

b1sl/saphdb/client.py

@@ -0,0 +1,50 @@
+"""
+SapHDBClient — Framework-agnostic entry point for SAP HANA ODBC SDK.
+
+Usage (standalone / scripts):
+    from b1sl.saphdb import SapHDBClient, SapHDBConfig
+    config = SapHDBConfig.from_env()
+    client = SapHDBClient(config)
+
+Usage (Django — in service layer only):
+    from b1sl.saphdb import SapHDBClient, SapHDBConfig
+    config = SapHDBConfig.from_django_settings()
+    client = SapHDBClient(config)
+"""
+
+from __future__ import annotations
+
+import logging
+
+from b1sl.saphdb.config import SapHDBConfig
+from b1sl.saphdb.odbc_adapter import HDBCliAdapter
+
+
+class SapHDBClient:
+    """
+    Public interface for the SAP HANA ODBC SDK.
+    """
+
+    def __init__(
+        self,
+        config: SapHDBConfig,
+        logger: logging.Logger | None = None,
+    ) -> None:
+        self._logger = logger or logging.getLogger(__name__)
+        self._adapter = HDBCliAdapter.from_config(config, logger=self._logger)
+
+        # Lazy resources
+        self._serial_numbers = None
+
+    @property
+    def serial_numbers(self):
+        """Access the SerialNumberDetails ODBC resource."""
+        if self._serial_numbers is None:
+            from b1sl.saphdb.endpoints.serialnumberdetailodbc import (
+                SerialNumberDetailsODBCEndpoint,
+            )
+
+            self._serial_numbers = SerialNumberDetailsODBCEndpoint(
+                adapter=self._adapter
+            )
+        return self._serial_numbers

b1sl/saphdb/config.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from datetime import timedelta
+
+
+@dataclass
+class SapHDBConfig:
+    address: str
+    port: int
+    user: str
+    password: str
+    schema: str
+    reuse_connection: bool = False
+    connection_timeout: timedelta = field(
+        default_factory=lambda: timedelta(seconds=900)
+    )
+
+    @classmethod
+    def from_env(cls) -> "SapHDBConfig":
+        """Load config from environment variables (no Django dependency)."""
+        missing = []
+        required = {
+            "address": "SAPODBCLIENT_ADDRESS",
+            "port": "SAPODBCLIENT_PORT",
+            "user": "SAPODBCLIENT_USER",
+            "password": "SAPODBCLIENT_PASSWORD",
+            "schema": "SAPODBCLIENT_COMPANY_DB",
+        }
+        kwargs = {}
+        for attr, env_key in required.items():
+            val = os.environ.get(env_key)
+            if not val:
+                missing.append(env_key)
+            kwargs[attr] = val
+
+        if missing:
+            raise EnvironmentError(
+                f"Missing required SAP HDB config env vars: {missing}"
+            )
+
+        kwargs["port"] = int(kwargs["port"])
+        # Standard pythonic way to parse boolean environment variables
+        env_reuse = os.environ.get("SAPODBCLIENT_REUSE_CONNECTION", "False").lower()
+        kwargs["reuse_connection"] = env_reuse in ("true", "1", "t", "y", "yes")
+
+        kwargs["connection_timeout"] = timedelta(
+            seconds=int(os.environ.get("SAPODBCLIENT_CONNECTION_TIMEOUT", 900))
+        )
+        return cls(**kwargs)
+
+    @classmethod
+    def from_django_settings(cls) -> "SapHDBConfig":
+        """Load from django.conf.settings — only call this inside a Django app."""
+        from django.conf import settings
+
+        return cls(
+            address=settings.SAPODBCLIENT_ADDRESS,
+            port=int(settings.SAPODBCLIENT_PORT),
+            user=settings.SAPODBCLIENT_USER,
+            password=settings.SAPODBCLIENT_PASSWORD,
+            schema=settings.SAPODBCLIENT_COMPANY_DB,
+            reuse_connection=getattr(settings, "SAPODBCLIENT_REUSE_CONNECTION", False),
+            connection_timeout=timedelta(
+                seconds=int(getattr(settings, "SAPODBCLIENT_CONNECTION_TIMEOUT", 900))
+            ),
+        )

b1sl/saphdb/endpoints/serialnumberdetailodbc.py

@@ -0,0 +1,100 @@
+from b1sl.saphdb.exceptions.exceptions import SapHAClientException
+from b1sl.saphdb.models.serial import SerialNumberList
+from b1sl.saphdb.odbc_adapter import HDBCliAdapter
+
+
+class SerialNumberDetailsODBCEndpoint:
+    """
+    Provides methods for interacting with SerialNumberDetails in an SAP B1 system.
+    """
+
+    def __init__(self, adapter: HDBCliAdapter):
+        """
+        Initializes the SerialNumberDetailsEndpoint with a RestAdapter instance.
+        """
+        self.adapter = adapter
+
+    @staticmethod
+    def _format_payload_for_api(payload: dict) -> dict:
+        """Converts internal representation to the format expected by the API."""
+        # Converts boolean values to the format expected by the API.
+        # if 'Valid' in payload:
+        #     payload['Valid'] = 'tYES' if payload.get('valid', True) else 'tNO'
+        #     payload['Frozen'] = 'tNO' if payload.get('valid', True) else 'tYES'
+
+        return payload
+
+    @staticmethod
+    def _parse_api_response(data: dict) -> dict:
+        """Converts API response to internal representation."""
+        # Converts 'tYES'/'tNO' values to booleans in the API response.
+        # if 'Valid' in data:
+        #     data['Valid'] = True if data['Valid'] == 'tYES' else False
+
+        return data
+
+    # TODO: AGREGAR MANEJO DE ERRORES EN ELEMENTOS SQL-SL
+    def get_by_id(self, doc_entry: int) -> SerialNumberList:
+        """Consulta un ítem en el sistema."""
+        try:
+            query = """
+            SELECT TOP 10 T0."AbsEntry", T0."Quantity", T0."QuantOut", T1."WhsCode"
+            FROM OSRN T0 INNER JOIN OSRI T1 ON (T0."ItemCode" = T1."ItemCode") AND (T1."SuppSerial" = T0."MnfSerial") AND (T0."SysNumber" = T1."SysSerial")
+            WHERE T0."AbsEntry" = ?
+            """
+            result = self.adapter.execute_query(query=query, params=(doc_entry,))
+
+            response = SerialNumberDetailsODBCEndpoint._parse_api_response(
+                data=result.data
+            )
+
+            if response and len(response) > 0:
+                serialnumberdetails_list = response[0]
+                print(f"serialnumberdetail_list: {serialnumberdetails_list}")
+                return SerialNumberList(**serialnumberdetails_list)
+            else:
+                raise ValueError(f"No serial number found with doc entry {doc_entry}")
+
+        except SapHAClientException as e:
+            raise ValueError(
+                f"Error retrieving serial number with doc entry {doc_entry}: {e}"
+            )
+
+    def get_by_ids(self, doc_entries: list[int]) -> list[SerialNumberList]:
+        """Consulta ítems en el sistema para una lista de IDs."""
+        if not doc_entries:
+            raise ValueError("La lista de IDs está vacía.")
+
+        try:
+            # Construir dinámicamente los placeholders para el IN
+            placeholders = ", ".join(["?"] * len(doc_entries))
+            query = f"""
+            SELECT T0."AbsEntry", T0."Quantity", T0."QuantOut", T1."WhsCode"
+            FROM OSRN T0 
+            INNER JOIN OSRI T1 
+            ON (T0."ItemCode" = T1."ItemCode") AND (T1."SuppSerial" = T0."MnfSerial") AND (T0."SysNumber" = T1."SysSerial")
+            WHERE T0."AbsEntry" IN ({placeholders})
+            """
+
+            result = self.adapter.execute_query(query=query, params=tuple(doc_entries))
+
+            # Parsear la respuesta
+            response = SerialNumberDetailsODBCEndpoint._parse_api_response(
+                data=result.data
+            )
+
+            if response:
+                serialnumberdetails_list = [
+                    SerialNumberList(**item) for item in response
+                ]
+                print(f"serialnumberdetails_list: {serialnumberdetails_list}")
+                return serialnumberdetails_list
+            else:
+                raise ValueError(
+                    "No se encontraron números de serie para los IDs proporcionados."
+                )
+
+        except SapHAClientException as e:
+            raise ValueError(
+                f"Error al recuperar números de serie para los IDs proporcionados: {e}"
+            )

b1sl/saphdb/exceptions/exceptions.py

@@ -0,0 +1,19 @@
+class SapHAClientException(Exception):
+    """Base exception for all SAP HANA client errors."""
+
+    def __init__(self, message, details=None):
+        super().__init__(message)
+        self.details = details
+
+
+class SapHAClientConnectionError(SapHAClientException):
+    pass
+
+
+class SapHAClientResponseError(SapHAClientException):
+    pass
+
+
+# Legacy aliases
+B1ClientConnectionError = SapHAClientConnectionError
+B1ClientResponseError = SapHAClientResponseError

b1sl/saphdb/main.py

@@ -0,0 +1,18 @@
+from b1sl.saphdb.adapter import odbc_adapter
+
+if __name__ == "__main__":
+    # Ejecución de una consulta
+    try:
+        adapter = odbc_adapter
+        query = """
+        SELECT TOP 2 T0."ItemName" 
+        FROM OITM T0
+        """
+        result = adapter.execute_query(query=query)
+        print(result)  # Muestra el resultado en formato JSON
+    except Exception as e:
+        print(f"Error al ejecutar la consulta: {e}")
+        # logger.error(f"Error al ejecutar la consulta: {e}")
+    finally:
+        # Cierra la conexión explícitamente si no es reutilizable
+        adapter.close()

b1sl/saphdb/models/result.py

@@ -0,0 +1,18 @@
+from typing import Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict
+
+
+class Result(BaseModel):
+    status_code: int
+    message: str = ""
+    # data: Optional[Dict] = None
+    data: Optional[List[Dict]] = None  # Cambiado para aceptar listas de diccionarios
+    next_link: Optional[str] = None
+    next_params: Optional[Dict] = None
+    metadata: Optional[str] = None
+
+    # Actualiza la configuración para Pydantic V2
+    model_config = ConfigDict(
+        extra="allow"  # Permite campos adicionales no definidos
+    )

b1sl/saphdb/models/serial.py

@@ -0,0 +1,37 @@
+from decimal import Decimal
+from typing import Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class BaseSerialNumberDetailModel(BaseModel):
+    # active: Optional[bool] = Field(default=True, alias="Valid")
+
+    def to_api_payload(self) -> dict:
+        """Convierte el modelo a un formato compatible con la API."""
+        payload = self.model_dump(by_alias=True)
+        # payload['Valid'] = 'tYES' if payload.get('Valid', False) else 'tNO'
+        return payload
+
+    model_config = ConfigDict(
+        populate_by_name=True,  # Reemplaza a 'allow_population_by_field_name'
+        extra="allow",  # Permite campos adicionales no definidos
+    )
+
+
+class SerialNumberList(BaseSerialNumberDetailModel):
+    doc_entry: int = Field(alias="AbsEntry")
+    warehouse: Optional[str] = Field(alias="WhsCode", default=None)
+    quantity_out: Optional[Decimal] = Field(alias="QuantOut", default=None)
+    quantity: Optional[Decimal] = Field(alias="Quantity", default=None)
+
+    # in_stock: Optional[bool] = None  # Campo derivado
+
+    # @model_validator(mode='before')
+    # def calculate_in_stock(cls, values):
+    #     quantity_out = values.get('quantity_out')
+    #     if quantity_out >= 1:
+    #         values['in_stock'] = False
+    #     else:
+    #         values['in_stock'] = True
+    #     return values

b1sl/saphdb/odbc_adapter.py

@@ -0,0 +1,220 @@
+import logging
+import threading
+from contextlib import contextmanager
+from datetime import datetime, timedelta
+from typing import Any, Dict, List, Optional, Tuple
+
+from hdbcli import dbapi
+from pydantic import BaseModel
+
+from b1sl.saphdb.models.result import Result
+
+
+class QueryResult(BaseModel):
+    data: List[Dict[str, Any]]
+
+
+class HDBCliAdapter:
+    @classmethod
+    def from_config(
+        cls, config, logger: Optional[logging.Logger] = None
+    ) -> "HDBCliAdapter":
+        return cls(
+            address=config.address,
+            port=config.port,
+            user=config.user,
+            password=config.password,
+            schema=config.schema,
+            logger=logger,
+            reuse_connection=config.reuse_connection,
+            connection_timeout=config.connection_timeout,
+        )
+
+    def __init__(
+        self,
+        address: str,
+        port: int,
+        user: str,
+        password: str,
+        schema: str,
+        logger: Optional[logging.Logger] = None,
+        reuse_connection: bool = False,
+        connection_timeout: timedelta = timedelta(seconds=900),
+    ):
+        self._lock = threading.RLock()
+        self.address = address
+        self.port = port
+        self.user = user
+        self.password = password
+        self.schema = schema
+        self.logger = logger or logging.getLogger(__name__)
+
+        self.connection = None
+        self.reuse_connection = reuse_connection
+        self.connection_timeout = connection_timeout
+        self.connection_expiry = None
+
+    def connect(self):
+        """Idempotent and thread-safe connection establishment with liveness check."""
+        with self._lock:
+            if self.connection is None or self._is_connection_expired():
+                # Close the dead socket gracefully if possible
+                if self.connection is not None:
+                    try:
+                        self.connection.close()
+                    except Exception:
+                        pass
+                    finally:
+                        self.connection = None
+
+                try:
+                    self.connection = dbapi.connect(
+                        address=self.address,
+                        port=self.port,
+                        user=self.user,
+                        password=self.password,
+                    )
+                    self.connection_expiry = datetime.now() + self.connection_timeout
+                    self.logger.info("Connected to HANA database")
+                except dbapi.Error as e:
+                    self.logger.error(
+                        f"Failed to connect to HANA database: {e.errortext} (Code: {e.errorcode})"
+                    )
+                    raise
+                except Exception as e:
+                    self.logger.error(
+                        f"Failed to connect to HANA (Network/OS Error): {e}"
+                    )
+                    raise
+
+    def _is_connection_expired(self) -> bool:
+        """Checks both clock-based timeout and actual socket liveness."""
+        if self.connection_expiry is None or self.connection is None:
+            return True
+        if datetime.now() >= self.connection_expiry:
+            return True
+
+        # Real Liveness Check (hdbcli specific)
+        try:
+            if hasattr(self.connection, "isconnected"):
+                if not self.connection.isconnected():
+                    self.logger.warning("HANA socket is natively reported as dead.")
+                    return True
+            else:
+                # Fallback if driver version lacks isconnected(): ping via dummy execute
+                cursor = self.connection.cursor()
+                cursor.execute("SELECT 1 FROM DUMMY")
+                cursor.close()
+        except dbapi.Error:
+            self.logger.warning("HANA socket is dead (failed liveness ping).")
+            return True
+        return False
+
+    @contextmanager
+    def transaction(self):
+        """
+        Transactional Context Manager.
+        Ensures atomic execution: COMMIT on success, ROLLBACK on error.
+        """
+        with self._lock:
+            self.connect()
+            try:
+                yield self.connection
+                self.connection.commit()
+                self.logger.debug("Transaction committed.")
+            except dbapi.Error as e:
+                try:
+                    self.connection.rollback()
+                except Exception:
+                    pass
+                self.logger.error(
+                    f"Transaction rolled back due to HANA error: {e.errortext} (Code: {e.errorcode})"
+                )
+                raise
+            except Exception as e:
+                try:
+                    self.connection.rollback()
+                except Exception:
+                    pass
+                self.logger.error(f"Transaction rolled back due to Runtime Error: {e}")
+                raise
+
+    def execute_query(
+        self,
+        query: str,
+        params: Optional[Tuple[Any, ...]] = None,
+        schema: Optional[str] = None,
+    ) -> Result:
+        """
+        Executes a query safely using bind variables.
+        """
+        with self._lock:
+            cursor = None
+            try:
+                # Use transactional scope for query execution
+                with self.transaction() as conn:
+                    cursor = conn.cursor()
+
+                    # Sanitize schema name (SQL injection prevention for identifiers)
+                    active_schema = schema or self.schema
+                    if active_schema:
+                        # Add double quotes to prevent identifier injection
+                        cursor.execute(f'SET SCHEMA "{active_schema}"')
+                        self.logger.debug(f"Schema set to: {active_schema}")
+
+                    # Execute safely with bind variables
+                    if params:
+                        cursor.execute(query, params)
+                    else:
+                        cursor.execute(query)
+
+                    self.logger.info("Query executed successfully.")
+
+                    if cursor.description:
+                        columns = [col[0] for col in cursor.description]
+                        results = [dict(zip(columns, row)) for row in cursor.fetchall()]
+                    else:
+                        results = []
+
+                    return Result(
+                        status_code=200,
+                        message="Query executed successfully.",
+                        data=results,
+                    )
+            except dbapi.Error as e:
+                self.logger.error(
+                    f"HANA Query error: {e.errortext} (Code: {e.errorcode})"
+                )
+                return Result(
+                    status_code=500,
+                    message=f"SAP HANA Error [{e.errorcode}]: {e.errortext}",
+                )
+            except Exception as e:
+                self.logger.error(f"Runtime query execution error: {e}")
+                return Result(status_code=500, message=f"Runtime query error: {str(e)}")
+            finally:
+                if cursor:
+                    cursor.close()
+                if not self.reuse_connection:
+                    self.close()
+
+    def close(self):
+        """Idempotent closure of resources."""
+        with self._lock:
+            if self.connection is not None:
+                try:
+                    self.connection.close()
+                except Exception:
+                    pass
+                finally:
+                    self.connection = None
+                    self.connection_expiry = None
+                    self.logger.info("Connection closed.")
+
+    # Support for simple 'with adapter:' usage
+    def __enter__(self):
+        self.connect()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.close()

b1sl/saphdb/tests/test_01_settings.py

@@ -0,0 +1,37 @@
+from django.conf import settings
+from django.test import TestCase
+
+
+class SettingsTestCase(TestCase):
+    def test_assert_is_working(self):
+        self.assertTrue(True)
+
+    def test_load_settings(self):
+        self.assertIsNotNone(
+            settings.SAPODBCLIENT_ADDRESS, "SAPODBCLIENT_ADDRESS should not be None"
+        )
+        self.assertIsNotNone(
+            settings.SAPODBCLIENT_PORT, "SAPODBCLIENT_PORT should not be None"
+        )
+        self.assertIsNotNone(
+            settings.SAPODBCLIENT_USER, "SAPODBCLIENT_USER should not be None"
+        )
+        self.assertIsNotNone(
+            settings.SAPODBCLIENT_PASSWORD, "SAPODBCLIENT_PASSWORD should not be None"
+        )
+        self.assertIsNotNone(
+            settings.SAPODBCLIENT_COMPANY_DB,
+            "SAPODBCLIENT_COMPANY_DB should not be None",
+        )
+        self.assertIsNotNone(
+            settings.SAPODBCLIENT_REUSE_CONNECTION,
+            "SAPODBCLIENT_REUSE_CONNECTION should not be None",
+        )
+        self.assertIsNotNone(
+            settings.SAPODBCLIENT_CONNECTION_TIMEOUT,
+            "SAPODBCLIENT_CONNECTION_TIMEOUT should not be None",
+        )
+        self.assertTrue(
+            settings.SAPODBCLIENT_IS_CONFIGURED,
+            "SAPODBCLIENT_IS_CONFIGURED should be True",
+        )