trovesuite 1.0.5__py3-none-any.whl → 1.0.7__py3-none-any.whl

trovesuite/__init__.py

@@ -1,18 +1,21 @@
 """
 TroveSuite Package
 
-A comprehensive authentication, authorization, and notification service for ERP systems.
-Provides JWT token validation, user authorization, permission checking, and notification capabilities.
+A comprehensive authentication, authorization, notification, and storage service for ERP systems.
+Provides JWT token validation, user authorization, permission checking, notification capabilities,
+and Azure Storage blob management.
 """
 
 from .auth import AuthService
 from .notification import NotificationService
+from .storage import StorageService
 
-__version__ = "1.0.8"
+__version__ = "1.0.7"
 __author__ = "Bright Debrah Owusu"
 __email__ = "owusu.debrah@deladetech.com"
 
 __all__ = [
     "AuthService",
-    "NotificationService"
+    "NotificationService",
+    "StorageService"
 ]

trovesuite/auth/auth_controller.py

@@ -1,10 +1,10 @@
 from fastapi import APIRouter
-from src.trovesuite.auth.auth_write_dto import AuthControllerWriteDto
-from src.trovesuite.auth.auth_read_dto import AuthControllerReadDto
-from src.trovesuite.auth.auth_service import AuthService
-from src.trovesuite.entities.sh_response import Respons
+from .auth_write_dto import AuthControllerWriteDto
+from .auth_read_dto import AuthControllerReadDto
+from .auth_service import AuthService
+from ..entities.sh_response import Respons
 
-auth_router = APIRouter()
+auth_router = APIRouter(tags=["Auth"])
 
 @auth_router.post("/auth", response_model=Respons[AuthControllerReadDto])
 async def authorize(data: AuthControllerWriteDto):

trovesuite/configs/database.py

@@ -17,20 +17,25 @@ _connection_pool: Optional[psycopg2.pool.ThreadedConnectionPool] = None
 
 class DatabaseConfig:
     """Database configuration and connection management"""
-    
+
     def __init__(self):
         self.settings = db_settings
         self.database_url = self.settings.database_url
         self.pool_size = 5
         self.max_overflow = 10
-        
+
     def get_connection_params(self) -> dict:
         """Get database connection parameters"""
         if self.settings.DATABASE_URL:
             # Use full DATABASE_URL if available
             return {
                 "dsn": self.settings.DATABASE_URL,
-                "cursor_factory": RealDictCursor
+                "cursor_factory": RealDictCursor,
+                "keepalives": 1,
+                "keepalives_idle": 30,
+                "keepalives_interval": 10,
+                "keepalives_count": 5,
+                "connect_timeout": 10
             }
 
         # fallback to individual DB_* variables
@@ -41,9 +46,14 @@ class DatabaseConfig:
             "user": self.settings.DB_USER,
             "password": self.settings.DB_PASSWORD,
             "cursor_factory": RealDictCursor,
-            "application_name": f"{self.settings.APP_NAME}_{self.settings.ENVIRONMENT}"
+            "application_name": f"{self.settings.APP_NAME}_{self.settings.ENVIRONMENT}",
+            "keepalives": 1,
+            "keepalives_idle": 30,
+            "keepalives_interval": 10,
+            "keepalives_count": 5,
+            "connect_timeout": 10
         }
-    
+
     def create_connection_pool(self) -> psycopg2.pool.ThreadedConnectionPool:
         """Create a connection pool for psycopg2"""
         try:
@@ -57,7 +67,7 @@ class DatabaseConfig:
         except Exception as e:
             logger.error(f"Failed to create database connection pool: {str(e)}")
             raise
-    
+
     def test_connection(self) -> bool:
         """Test database connection"""
         try:
@@ -81,17 +91,17 @@ db_config = DatabaseConfig()
 def initialize_database():
     """Initialize database connections and pool"""
     global _connection_pool
-    
+
     try:
         # Test connection first
         if not db_config.test_connection():
             raise Exception("Database connection test failed")
-        
+
         # Create connection pool
         _connection_pool = db_config.create_connection_pool()
-        
+
         logger.info("Database initialization completed successfully")
-        
+
     except Exception as e:
         logger.error(f"Database initialization failed: {str(e)}")
         raise
@@ -114,6 +124,17 @@ def get_connection_pool() -> psycopg2.pool.ThreadedConnectionPool:
     return _connection_pool
 
 
+def _validate_connection(conn) -> bool:
+    """Validate if a connection is still alive"""
+    try:
+        # Test if connection is alive with a simple query
+        with conn.cursor() as cursor:
+            cursor.execute("SELECT 1")
+        return True
+    except (psycopg2.OperationalError, psycopg2.InterfaceError):
+        return False
+
+
 @contextmanager
 def get_db_connection():
     """Get a database connection from the pool (context manager)"""
@@ -121,52 +142,79 @@ def get_db_connection():
     conn = None
     try:
         conn = pool.getconn()
+
+        # Validate connection before using it
+        if not _validate_connection(conn):
+            logger.warning("Stale connection detected, getting new connection")
+            pool.putconn(conn, close=True)
+            conn = pool.getconn()
+
         logger.debug("Database connection acquired from pool")
         yield conn
     except Exception as e:
         logger.error(f"Database connection error: {str(e)}")
         if conn:
-            conn.rollback()
+            try:
+                # Only rollback if connection is still open
+                if not conn.closed:
+                    conn.rollback()
+            except (psycopg2.OperationalError, psycopg2.InterfaceError) as rollback_error:
+                logger.warning(f"Could not rollback closed connection: {str(rollback_error)}")
         raise
     finally:
         if conn:
-            pool.putconn(conn)
-            logger.debug("Database connection returned to pool")
+            try:
+                # If connection is broken, close it instead of returning to pool
+                if conn.closed:
+                    pool.putconn(conn, close=True)
+                else:
+                    pool.putconn(conn)
+                logger.debug("Database connection returned to pool")
+            except Exception as put_error:
+                logger.error(f"Error returning connection to pool: {str(put_error)}")
 
 
 @contextmanager
 def get_db_cursor():
     """Get a database cursor (context manager)"""
     with get_db_connection() as conn:
-        cursor = conn.cursor()
+        cursor = conn.cursor(cursor_factory=RealDictCursor)
         try:
             yield cursor
-            conn.commit()
+            if not conn.closed:
+                conn.commit()
         except Exception as e:
-            conn.rollback()
+            if not conn.closed:
+                try:
+                    conn.rollback()
+                except (psycopg2.OperationalError, psycopg2.InterfaceError) as rollback_error:
+                    logger.warning(f"Could not rollback transaction on closed connection: {str(rollback_error)}")
             logger.error(f"Database cursor error: {str(e)}")
             raise
         finally:
-            cursor.close()
+            try:
+                cursor.close()
+            except Exception as close_error:
+                logger.warning(f"Error closing cursor: {str(close_error)}")
 
 
 class DatabaseManager:
     """Database manager for common operations"""
-    
+
     @staticmethod
     def execute_query(query: str, params: tuple = None) -> list:
         """Execute a SELECT query and return results"""
         with get_db_cursor() as cursor:
             cursor.execute(query, params)
             return cursor.fetchall()
-    
+
     @staticmethod
     def execute_update(query: str, params: tuple = None) -> int:
         """Execute an INSERT/UPDATE/DELETE query and return affected rows"""
         with get_db_cursor() as cursor:
             cursor.execute(query, params)
             return cursor.rowcount
-    
+
     @staticmethod
     def execute_scalar(query: str, params: tuple = None):
         """Execute a query and return a single value"""
@@ -182,7 +230,41 @@ class DatabaseManager:
                     # Handle tuple result
                     return result[0] if len(result) > 0 else None
             return None
-    
+
+    @staticmethod
+    @contextmanager
+    def transaction():
+        """
+        Context manager for database transactions.
+        Wraps multiple operations in a single transaction.
+
+        Usage:
+            with DatabaseManager.transaction() as cursor:
+                cursor.execute("INSERT INTO table1 ...")
+                cursor.execute("INSERT INTO table2 ...")
+                # Auto-commits on success, auto-rollbacks on exception
+        """
+        with get_db_connection() as conn:
+            cursor = conn.cursor(cursor_factory=RealDictCursor)
+            try:
+                yield cursor
+                if not conn.closed:
+                    conn.commit()
+                    logger.debug("Transaction committed successfully")
+            except Exception as e:
+                if not conn.closed:
+                    try:
+                        conn.rollback()
+                        logger.warning(f"Transaction rolled back due to error: {str(e)}")
+                    except (psycopg2.OperationalError, psycopg2.InterfaceError) as rollback_error:
+                        logger.error(f"Could not rollback transaction: {str(rollback_error)}")
+                raise
+            finally:
+                try:
+                    cursor.close()
+                except Exception as close_error:
+                    logger.warning(f"Error closing transaction cursor: {str(close_error)}")
+
     @staticmethod
     def health_check() -> dict:
         """Perform database health check"""
@@ -190,7 +272,7 @@ class DatabaseManager:
             with get_db_cursor() as cursor:
                 cursor.execute("SELECT version(), current_database(), current_user")
                 result = cursor.fetchone()
-                
+
                 if result:
                     # Handle RealDictRow (dictionary-like) result
                     if hasattr(result, 'get'):

trovesuite/entities/health.py

@@ -1,8 +1,8 @@
 from fastapi import APIRouter
-from src.entities.shared.shared_response import Respons
-from src.configs.settings import db_settings
-from src.configs.database import DatabaseManager
-from src.configs.logging import get_logger
+from .sh_response import Respons
+from ..configs.settings import db_settings
+from ..configs.database import DatabaseManager
+from ..configs.logging import get_logger
 
 health_check_router = APIRouter(tags=["Health Path"])
 logger = get_logger("health")

trovesuite/notification/notification_controller.py

@@ -1,16 +1,16 @@
-from src.trovesuite.notification.notification_write_dto import (
+from .notification_write_dto import (
     NotificationEmailControllerWriteDto,
     NotificationSMSControllerWriteDto
 )
-from src.trovesuite.notification.notification_read_dto import (
+from .notification_read_dto import (
     NotificationEmailControllerReadDto,
     NotificationSMSControllerReadDto
 )
-from src.trovesuite.notification.notification_service import NotificationService
-from src.trovesuite.entities.sh_response import Respons
+from .notification_service import NotificationService
+from ..entities.sh_response import Respons
 from fastapi import APIRouter
 
-notification_router = APIRouter()
+notification_router = APIRouter(tags=["Notification"])
 
 @notification_router.post("/send_email", response_model=Respons[NotificationEmailControllerReadDto])
 async def send_email(data: NotificationEmailControllerWriteDto):

trovesuite/notification/notification_read_dto.py

@@ -1,4 +1,4 @@
-from src.trovesuite.notification.notification_base import (
+from .notification_base import (
     NotificationEmailBase,
     NotificationSMSBase
 )

trovesuite/notification/notification_service.py

@@ -1,12 +1,12 @@
 import smtplib
 from email.mime.text import MIMEText
 from email.mime.multipart import MIMEMultipart
-from src.trovesuite.entities.sh_response import Respons
-from src.trovesuite.notification.notification_read_dto import (
+from ..entities.sh_response import Respons
+from .notification_read_dto import (
     NotificationEmailServiceReadDto,
     NotificationSMSServiceReadDto
 )
-from src.trovesuite.notification.notification_write_dto import (
+from .notification_write_dto import (
     NotificationEmailServiceWriteDto,
     NotificationSMSServiceWriteDto
 )

trovesuite/notification/notification_write_dto.py

@@ -1,5 +1,5 @@
 from pydantic import BaseModel
-from src.trovesuite.notification.notification_base import (
+from .notification_base import (
     NotificationEmailBase,
     NotificationSMSBase
 )

trovesuite/storage/__init__.py

@@ -0,0 +1,42 @@
+"""
+TroveSuite Storage Service
+
+Provides Azure Storage blob management capabilities for TroveSuite applications.
+Includes container creation, file upload/download/update/delete, and presigned URL generation.
+"""
+
+from .storage_service import StorageService
+from .storage_write_dto import (
+    StorageContainerCreateServiceWriteDto,
+    StorageFileUploadServiceWriteDto,
+    StorageFileUpdateServiceWriteDto,
+    StorageFileDeleteServiceWriteDto,
+    StorageFileDownloadServiceWriteDto,
+    StorageFileUrlServiceWriteDto
+)
+from .storage_read_dto import (
+    StorageContainerCreateServiceReadDto,
+    StorageFileUploadServiceReadDto,
+    StorageFileUpdateServiceReadDto,
+    StorageFileDeleteServiceReadDto,
+    StorageFileDownloadServiceReadDto,
+    StorageFileUrlServiceReadDto
+)
+
+__all__ = [
+    "StorageService",
+    # Write DTOs
+    "StorageContainerCreateServiceWriteDto",
+    "StorageFileUploadServiceWriteDto",
+    "StorageFileUpdateServiceWriteDto",
+    "StorageFileDeleteServiceWriteDto",
+    "StorageFileDownloadServiceWriteDto",
+    "StorageFileUrlServiceWriteDto",
+    # Read DTOs
+    "StorageContainerCreateServiceReadDto",
+    "StorageFileUploadServiceReadDto",
+    "StorageFileUpdateServiceReadDto",
+    "StorageFileDeleteServiceReadDto",
+    "StorageFileDownloadServiceReadDto",
+    "StorageFileUrlServiceReadDto",
+]

trovesuite/storage/storage_base.py

@@ -0,0 +1,63 @@
+from typing import Optional
+from pydantic import BaseModel
+
+
+class StorageConnectionBase(BaseModel):
+    """Base model for Azure Storage connection using Managed Identity"""
+    storage_account_url: str  # e.g., https://<account-name>.blob.core.windows.net
+    container_name: str
+    managed_identity_client_id: Optional[str] = None  # Optional: For user-assigned managed identity
+
+
+class StorageFileUploadBase(BaseModel):
+    """Base model for file upload operations"""
+    storage_account_url: str
+    container_name: str
+    file_content: bytes
+    blob_name: str
+    directory_path: Optional[str] = None
+    content_type: Optional[str] = None
+    managed_identity_client_id: Optional[str] = None
+
+
+class StorageFileUpdateBase(BaseModel):
+    """Base model for file update operations"""
+    storage_account_url: str
+    container_name: str
+    blob_name: str
+    file_content: bytes
+    content_type: Optional[str] = None
+    managed_identity_client_id: Optional[str] = None
+
+
+class StorageFileDeleteBase(BaseModel):
+    """Base model for file delete operations"""
+    storage_account_url: str
+    container_name: str
+    blob_name: str
+    managed_identity_client_id: Optional[str] = None
+
+
+class StorageFileDownloadBase(BaseModel):
+    """Base model for file download operations"""
+    storage_account_url: str
+    container_name: str
+    blob_name: str
+    managed_identity_client_id: Optional[str] = None
+
+
+class StorageFileUrlBase(BaseModel):
+    """Base model for getting presigned URL"""
+    storage_account_url: str
+    container_name: str
+    blob_name: str
+    expiry_hours: Optional[int] = 1
+    managed_identity_client_id: Optional[str] = None
+
+
+class StorageContainerCreateBase(BaseModel):
+    """Base model for creating a container"""
+    storage_account_url: str
+    container_name: str
+    public_access: Optional[str] = None
+    managed_identity_client_id: Optional[str] = None

trovesuite/storage/storage_controller.py

@@ -0,0 +1,198 @@
+from typing import List
+from fastapi import APIRouter, File, UploadFile, Form
+from fastapi.responses import StreamingResponse
+from io import BytesIO
+from .storage_write_dto import (
+    StorageContainerCreateControllerWriteDto,
+    StorageFileUploadControllerWriteDto,
+    StorageFileUpdateControllerWriteDto,
+    StorageFileDeleteControllerWriteDto,
+    StorageFileDownloadControllerWriteDto,
+    StorageFileUrlControllerWriteDto
+)
+from .storage_read_dto import (
+    StorageContainerCreateControllerReadDto,
+    StorageFileUploadControllerReadDto,
+    StorageFileUpdateControllerReadDto,
+    StorageFileDeleteControllerReadDto,
+    StorageFileDownloadControllerReadDto,
+    StorageFileUrlControllerReadDto
+)
+from .storage_service import StorageService
+from ..entities.sh_response import Respons
+
+storage_router = APIRouter(tags=["File Storage"])
+
+
+@storage_router.post("/create-container", response_model=Respons[StorageContainerCreateControllerReadDto])
+async def create_container(data: StorageContainerCreateControllerWriteDto):
+    """
+    Create a new Azure Storage container.
+
+    Example request body:
+    {
+        "storage_account_url": "https://myaccount.blob.core.windows.net",
+        "container_name": "my-container",
+        "public_access": null,
+        "managed_identity_client_id": "your-client-id"  // optional
+    }
+    """
+    return StorageService.create_container(data=data)
+
+
+@storage_router.post("/upload", response_model=Respons[StorageFileUploadControllerReadDto])
+async def upload_file(
+    storage_account_url: str = Form(...),
+    container_name: str = Form(...),
+    blob_name: str = Form(...),
+    file: UploadFile = File(...),
+    directory_path: str = Form(None),
+    managed_identity_client_id: str = Form(None)
+):
+    """
+    Upload a file to Azure Storage.
+
+    Use form-data with the following fields:
+    - storage_account_url: Your Azure storage URL
+    - container_name: Container name
+    - blob_name: Name for the blob
+    - file: The file to upload
+    - directory_path: Optional directory path (e.g., "uploads/2024")
+    - managed_identity_client_id: Optional client ID for user-assigned managed identity
+    """
+    content = await file.read()
+
+    upload_data = StorageFileUploadControllerWriteDto(
+        storage_account_url=storage_account_url,
+        container_name=container_name,
+        file_content=content,
+        blob_name=blob_name,
+        directory_path=directory_path,
+        content_type=file.content_type,
+        managed_identity_client_id=managed_identity_client_id
+    )
+
+    return StorageService.upload_file(data=upload_data)
+
+
+@storage_router.put("/update", response_model=Respons[StorageFileUpdateControllerReadDto])
+async def update_file(
+    storage_account_url: str = Form(...),
+    container_name: str = Form(...),
+    blob_name: str = Form(...),
+    file: UploadFile = File(...),
+    managed_identity_client_id: str = Form(None)
+):
+    """
+    Update an existing file in Azure Storage.
+
+    Use form-data with the following fields:
+    - storage_account_url: Your Azure storage URL
+    - container_name: Container name
+    - blob_name: Full blob name including path (e.g., "uploads/2024/file.pdf")
+    - file: The new file content
+    - managed_identity_client_id: Optional client ID for user-assigned managed identity
+    """
+    content = await file.read()
+
+    update_data = StorageFileUpdateControllerWriteDto(
+        storage_account_url=storage_account_url,
+        container_name=container_name,
+        blob_name=blob_name,
+        file_content=content,
+        content_type=file.content_type,
+        managed_identity_client_id=managed_identity_client_id
+    )
+
+    return StorageService.update_file(data=update_data)
+
+
+@storage_router.delete("/delete", response_model=Respons[StorageFileDeleteControllerReadDto])
+async def delete_file(data: StorageFileDeleteControllerWriteDto):
+    """
+    Delete a file from Azure Storage.
+
+    Example request body:
+    {
+        "storage_account_url": "https://myaccount.blob.core.windows.net",
+        "container_name": "my-container",
+        "blob_name": "uploads/2024/file.pdf",
+        "managed_identity_client_id": "your-client-id"  // optional
+    }
+    """
+    return StorageService.delete_file(data=data)
+
+
+@storage_router.delete("/delete-multiple", response_model=Respons[StorageFileDeleteControllerReadDto])
+async def delete_multiple_files(
+    storage_account_url: str,
+    container_name: str,
+    blob_names: List[str],
+    managed_identity_client_id: str = None
+):
+    """
+    Delete multiple files from Azure Storage.
+
+    Example request body:
+    {
+        "storage_account_url": "https://myaccount.blob.core.windows.net",
+        "container_name": "my-container",
+        "blob_names": ["file1.pdf", "file2.pdf", "folder/file3.jpg"],
+        "managed_identity_client_id": "your-client-id"  // optional
+    }
+    """
+    return StorageService.delete_multiple_files(
+        storage_account_url=storage_account_url,
+        container_name=container_name,
+        blob_names=blob_names,
+        managed_identity_client_id=managed_identity_client_id
+    )
+
+
+@storage_router.post("/download")
+async def download_file(data: StorageFileDownloadControllerWriteDto):
+    """
+    Download a file from Azure Storage.
+
+    Returns the file as a streaming response.
+
+    Example request body:
+    {
+        "storage_account_url": "https://myaccount.blob.core.windows.net",
+        "container_name": "my-container",
+        "blob_name": "uploads/2024/file.pdf",
+        "managed_identity_client_id": "your-client-id"  // optional
+    }
+    """
+    result = StorageService.download_file(data=data)
+
+    if not result.success:
+        return result
+
+    file_data = result.data[0]
+
+    # Return as streaming response
+    return StreamingResponse(
+        BytesIO(file_data.content),
+        media_type=file_data.content_type or "application/octet-stream",
+        headers={
+            "Content-Disposition": f"attachment; filename={data.blob_name.split('/')[-1]}"
+        }
+    )
+
+
+@storage_router.post("/get-url", response_model=Respons[StorageFileUrlControllerReadDto])
+async def get_file_url(data: StorageFileUrlControllerWriteDto):
+    """
+    Generate a presigned URL for a file.
+
+    Example request body:
+    {
+        "storage_account_url": "https://myaccount.blob.core.windows.net",
+        "container_name": "my-container",
+        "blob_name": "uploads/2024/file.pdf",
+        "expiry_hours": 2,
+        "managed_identity_client_id": "your-client-id"  // optional
+    }
+    """
+    return StorageService.get_file_url(data=data)