trovesuite 1.0.1__py3-none-any.whl → 1.0.31__py3-none-any.whl

trovesuite/configs/database.py

@@ -1,36 +1,65 @@
 """
 Database configuration and connection management
+
+FIXED VERSION - Removed pool reinitialization during runtime to prevent "unkeyed connection" errors.
+Key changes:
+- Pool created once at startup, never recreated during runtime
+- Removed connection validation queries that consume pool connections
+- Increased default pool size to 2 (safe for Azure Basic tier)
+- Simplified get_db_connection() - let pool.getconn() block naturally
+- Removed _recover_connection_pool() and _is_pool_valid() runtime checks
+
+NOTE: Database initialization is NOT automatic for package version.
+You must call initialize_database() explicitly in your application startup.
+Example in FastAPI:
+    @app.on_event("startup")
+    async def startup_event():
+        initialize_database()
 """
 from contextlib import contextmanager
 from typing import Generator, Optional
 import psycopg2
 import psycopg2.pool
 from psycopg2.extras import RealDictCursor
+import threading
 from .settings import db_settings
 from .logging import get_logger
 
 logger = get_logger("database")
 
-# Database connection pool
+# Database connection pool - created once at startup, never replaced during runtime
 _connection_pool: Optional[psycopg2.pool.ThreadedConnectionPool] = None
-_sqlmodel_engine = None
+_initialization_lock = threading.Lock()
 
 
 class DatabaseConfig:
     """Database configuration and connection management"""
-    
+
     def __init__(self):
+        import os
         self.settings = db_settings
-        self.pool_size = 5
-        self.max_overflow = 10
-    
-    @property
-    def database_url(self):
-        """Get database URL (lazy evaluation)"""
-        return self.settings.database_url
-        
+        self.database_url = self.settings.database_url
+        # Safe pool size for Azure Basic tier (B_Standard_B1ms)
+        # With 2 workers and pool_size=2: 2 × 2 = 4 connections (very safe)
+        # With 4 workers and pool_size=2: 4 × 2 = 8 connections (still safe, well under 50 limit)
+        # Can be overridden with DB_POOL_SIZE environment variable
+        self.pool_size = int(os.getenv("DB_POOL_SIZE", "2"))
+
     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,
+                "keepalives": 1,
+                "keepalives_idle": 30,
+                "keepalives_interval": 10,
+                "keepalives_count": 5,
+                "connect_timeout": 30  # Increased timeout for Azure PostgreSQL
+            }
+
+        # fallback to individual DB_* variables
         return {
             "host": self.settings.DB_HOST,
             "port": self.settings.DB_PORT,
@@ -38,25 +67,54 @@ 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:
+            import os
+            dsn = os.getenv("DATABASE_URL", "") or str(self.database_url or "")
+            is_azure = "database.azure.com" in dsn.lower()
+            pool_size = self.pool_size
+            
             pool = psycopg2.pool.ThreadedConnectionPool(
                 minconn=1,
-                maxconn=self.pool_size,
+                maxconn=pool_size,
                 **self.get_connection_params()
             )
-            logger.info(f"Database connection pool created with {self.pool_size} connections")
+            logger.info(
+                f"Database connection pool created with {pool_size} connections "
+                f"(Azure: {is_azure}, DB_POOL_SIZE: {self.pool_size})"
+            )
             return pool
+        except psycopg2.OperationalError as e:
+            error_str = str(e).lower()
+            if any(keyword in error_str for keyword in ["connection", "slot", "limit", "exhausted", "too many"]):
+                logger.error("⚠️  Database connection limit reached!")
+                logger.error("   Possible causes:")
+                logger.error("   1. Too many connections from multiple replicas/workers")
+                logger.error("   2. Pool size too high (DB_POOL_SIZE environment variable)")
+                logger.error("   3. Too many Gunicorn workers (GUNICORN_WORKERS environment variable)")
+                logger.error("   4. Connections not being properly returned to pool")
+                logger.error("   Solutions:")
+                logger.error("   - Set DB_POOL_SIZE=2 (current default)")
+                logger.error("   - Reduce GUNICORN_WORKERS (default: 4)")
+                logger.error("   - Consider using PgBouncer for connection pooling")
+                logger.error("   - Upgrade to a higher PostgreSQL tier if needed")
+            logger.error(f"Failed to create database connection pool: {str(e)}")
+            raise
         except Exception as e:
             logger.error(f"Failed to create database connection pool: {str(e)}")
             raise
-    
+
     def test_connection(self) -> bool:
-        """Test database connection"""
+        """Test database connection (only used at startup)"""
         try:
             with psycopg2.connect(**self.get_connection_params()) as conn:
                 with conn.cursor() as cursor:
@@ -76,93 +134,147 @@ db_config = DatabaseConfig()
 
 
 def initialize_database():
-    """Initialize database connections and pool"""
+    """
+    Initialize database connections and pool.
+    This should ONLY be called at application startup.
+    Pool is created once and never recreated during runtime.
+    
+    NOTE: For package version, this must be called explicitly in application startup.
+    """
     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")
+    with _initialization_lock:
+        # If pool already exists, don't recreate it
+        if _connection_pool is not None:
+            logger.warning("Database pool already initialized, skipping reinitialization")
+            return
         
-    except Exception as e:
-        logger.error(f"Database initialization failed: {str(e)}")
-        raise
+        try:
+            # Test connection first (only at startup)
+            if not db_config.test_connection():
+                raise Exception("Database connection test failed")
+
+            # Create connection pool (only once at startup)
+            _connection_pool = db_config.create_connection_pool()
+            
+            # Verify pool was created successfully
+            if _connection_pool is None:
+                raise Exception("Connection pool creation returned None")
+
+            logger.info("✅ Database initialization completed successfully")
+
+        except Exception as e:
+            logger.error(f"❌ Database initialization failed: {str(e)}")
+            _connection_pool = None  # Ensure pool is None on failure
+            raise
 
 
 def get_connection_pool() -> psycopg2.pool.ThreadedConnectionPool:
-    """Get the database connection pool"""
+    """
+    Get the database connection pool.
+    Pool must be initialized at startup. This function will raise if pool is None.
+    """
     global _connection_pool
+    
     if _connection_pool is None:
-        raise Exception("Database not initialized. Call initialize_database() first.")
+        error_msg = (
+            "Database connection pool is not initialized. "
+            "Please ensure initialize_database() was called at application startup."
+        )
+        logger.error(error_msg)
+        raise Exception(error_msg)
+    
     return _connection_pool
 
 
-def get_sqlmodel_engine():
-    """Get the SQLModel engine"""
-    global _sqlmodel_engine
-    if _sqlmodel_engine is None:
-        raise Exception("Database not initialized. Call initialize_database() first.")
-    return _sqlmodel_engine
-
-
 @contextmanager
 def get_db_connection():
-    """Get a database connection from the pool (context manager)"""
+    """
+    Get a database connection from the pool (context manager).
+    
+    This is simplified - we let pool.getconn() block naturally.
+    No retries, no validation queries, no pool recovery.
+    """
     pool = get_connection_pool()
     conn = None
     try:
+        # Get connection from pool - this will block if pool is exhausted
+        # That's the correct behavior - let backpressure happen naturally
         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()
+        # If connection exists and isn't closed, rollback transaction
+        if conn and not conn.closed:
+            try:
+                conn.rollback()
+            except Exception as rollback_error:
+                logger.warning(f"Could not rollback transaction: {str(rollback_error)}")
+        # Re-raise the exception - don't retry here
         raise
     finally:
+        # Always return connection to pool
         if conn:
-            pool.putconn(conn)
-            logger.debug("Database connection returned to pool")
+            try:
+                if conn.closed:
+                    # If connection is closed, tell pool to close it instead of returning
+                    pool.putconn(conn, close=True)
+                else:
+                    # Return connection to pool normally
+                    pool.putconn(conn)
+                logger.debug("Database connection returned to pool")
+            except Exception as put_error:
+                # Log error but don't fail - connection will be cleaned up by pool
+                logger.error(f"Error returning connection to pool: {str(put_error)}")
+                # Try to close connection manually as last resort
+                try:
+                    if not conn.closed:
+                        conn.close()
+                except Exception:
+                    pass
 
 
 @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"""
@@ -178,15 +290,53 @@ 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
+        """
+        # Use get_db_connection() instead of directly accessing pool
+        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"""
+        """
+        Perform database health check.
+        Health checks are allowed to fail - they don't attempt to repair the pool.
+        """
         try:
             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'):
@@ -217,5 +367,9 @@ class DatabaseManager:
             }
 
 
-# Database initialization is done lazily when needed
-# Call initialize_database() explicitly when you need to use the database
+# NOTE: Database initialization is NOT automatic for package version
+# You must call initialize_database() explicitly in your application startup
+# Example in FastAPI:
+#   @app.on_event("startup")
+#   async def startup_event():
+#       initialize_database()

trovesuite/configs/settings.py

@@ -1,153 +1,96 @@
 import os
-import warnings
-from typing import Optional
-
 class Settings:
-    """Settings configuration for TroveSuite Auth Service"""
-
-    # =============================================================================
-    # DATABASE CONFIGURATION
-    # =============================================================================
-    DATABASE_URL: str = os.getenv(
-        "DATABASE_URL", 
-        "postgresql://username:password@localhost:5432/database_name"
-    )
 
-    # Alternative database configuration
-    DB_USER: Optional[str] = os.getenv("DB_USER")
-    DB_HOST: Optional[str] = os.getenv("DB_HOST")
-    DB_NAME: Optional[str] = os.getenv("DB_NAME")
-    DB_PORT: int = int(os.getenv("DB_PORT", "5432"))
-    DB_PASSWORD: Optional[str] = os.getenv("DB_PASSWORD")
-    ENVIRONMENT: str = os.getenv("ENVIRONMENT", "development")
+    # Database URL
+    DATABASE_URL: str = os.getenv("DATABASE_URL")
 
-    # =============================================================================
-    # APPLICATION SETTINGS
-    # =============================================================================
-    APP_NAME: str = os.getenv("APP_NAME", "TroveSuite Auth Service")
-    DEBUG: bool = os.getenv("DEBUG", "False").lower() == "true"
+    DB_USER: str = os.getenv("DB_USER")
+    DB_HOST: str = os.getenv("DB_HOST")
+    DB_NAME: str = os.getenv("DB_NAME")
+    DB_PORT: str = os.getenv("DB_PORT")
+    DB_PASSWORD: str = os.getenv("DB_PASSWORD")
     
-    # =============================================================================
-    # SECURITY SETTINGS
-    # =============================================================================
-    ALGORITHM: str = os.getenv("ALGORITHM", "HS256")
-    SECRET_KEY: str = os.getenv("SECRET_KEY", "09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7")
-    ACCESS_TOKEN_EXPIRE_MINUTES: int = int(os.getenv("ACCESS_TOKEN_EXPIRE_MINUTES", "60"))
+    # Application settings
+    DEBUG: bool = os.getenv("DEBUG", "True").lower() in ("true",1)
+    APP_NAME: str = os.getenv("APP_NAME", "Python Template API")
+    APP_VERSION: str = os.getenv("APP_VERSION", "1.0.0")
     
-    # =============================================================================
-    # LOGGING SETTINGS
-    # =============================================================================
+    # Logging settings
     LOG_LEVEL: str = os.getenv("LOG_LEVEL", "INFO")
     LOG_FORMAT: str = os.getenv("LOG_FORMAT", "detailed")  # detailed, json, simple
-    LOG_TO_FILE: bool = os.getenv("LOG_TO_FILE", "False").lower() == "false"
+    LOG_TO_FILE: bool = os.getenv("LOG_TO_FILE", "False").lower() in ("true", 1)
     LOG_MAX_SIZE: int = int(os.getenv("LOG_MAX_SIZE", "10485760"))  # 10MB
     LOG_BACKUP_COUNT: int = int(os.getenv("LOG_BACKUP_COUNT", "5"))
     LOG_DIR: str = os.getenv("LOG_DIR", "logs")
-
+        
+   # Security settings
+    ALGORITHM: str = os.getenv("ALGORITHM")
+    SECRET_KEY: str = os.getenv("SECRET_KEY")
+    ENVIRONMENT: str = os.getenv("ENVIRONMENT")
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = int(os.getenv("ACCESS_TOKEN_EXPIRE_MINUTES", "120"))
+    
     # =============================================================================
-    # DATABASE TABLE NAMES
+    # SHARED TABLES (core_platform schema)
     # =============================================================================
-    # Main schema tables
-    MAIN_TENANTS_TABLE: str = os.getenv("MAIN_TENANTS_TABLE", "tenants")
-    ROLE_PERMISSIONS_TABLE: str = os.getenv("ROLE_PERMISSIONS_TABLE", "role_permissions")
-    
-    # Tenant-specific tables (used in queries with tenant schema)
-    TENANT_LOGIN_SETTINGS_TABLE: str = os.getenv("TENANT_LOGIN_SETTINGS_TABLE", "login_settings")
-    USER_GROUPS_TABLE: str = os.getenv("USER_GROUPS_TABLE", "user_groups")
-    ASSIGN_ROLES_TABLE: str = os.getenv("ASSIGN_ROLES_TABLE", "assign_roles")
+    CORE_PLATFORM_TENANTS_TABLE = os.getenv("CORE_PLATFORM_TENANTS_TABLE", "core_platform.cp_tenants")
+    CORE_PLATFORM_SUBSCRIPTIONS_TABLE = os.getenv("CORE_PLATFORM_SUBSCRIPTIONS_TABLE", "core_platform.cp_subscriptions")
+    CORE_PLATFORM_APPS_TABLE = os.getenv("CORE_PLATFORM_APPS_TABLE", "core_platform.cp_apps")
+    CORE_PLATFORM_USERS_TABLE = os.getenv("CORE_PLATFORM_USERS_TABLE", "core_platform.cp_users")
+    CORE_PLATFORM_RESOURCE_TYPES_TABLE = os.getenv("CORE_PLATFORM_RESOURCE_TYPES_TABLE", "core_platform.cp_resource_types")
+    CORE_PLATFORM_RESOURCE_ID_TABLE = os.getenv("CORE_PLATFORM_RESOURCE_ID_TABLE", "core_platform.cp_resource_ids")
+    CORE_PLATFORM_PERMISSIONS_TABLE = os.getenv("CORE_PLATFORM_PERMISSIONS_TABLE", "core_platform.cp_permissions")
+    CORE_PLATFORM_ROLES_TABLE = os.getenv("CORE_PLATFORM_ROLES_TABLE", "core_platform.cp_roles")
+    CORE_PLATFORM_ROLE_PERMISSIONS_TABLE = os.getenv("CORE_PLATFORM_ROLE_PERMISSIONS_TABLE", "core_platform.cp_role_permissions")
+    CORE_PLATFORM_USER_SUBSCRIPTIONS_TABLE = os.getenv("CORE_PLATFORM_USER_SUBSCRIPTIONS_TABLE", "core_platform.cp_user_subscriptions")
+    CORE_PLATFORM_USER_SUBSCRIPTION_HISTORY_TABLE = os.getenv("CORE_PLATFORM_USER_SUBSCRIPTION_HISTORY_TABLE", "core_platform.cp_user_subscription_histories")
+    CORE_PLATFORM_OTP = os.getenv("CORE_PLATFORM_OTP", "core_platform.cp_otps")
+    CORE_PLATFORM_PASSWORD_POLICY = os.getenv("CORE_PLATFORM_PASSWORD_POLICY", "core_platform.cp_password_policies")
+    CORE_PLATFORM_MULTI_FACTOR_SETTINGS = os.getenv("CORE_PLATFORM_MULTI_FACTOR_SETTINGS", "core_platform.cp_multi_factor_settings")
+    CORE_PLATFORM_USER_LOGIN_TRACKING = os.getenv("CORE_PLATFORM_USER_LOGIN_TRACKING", "core_platform.cp_user_login_tracking")
+    CORE_PLATFORM_ENTERPRISE_SUBSCRIPTIONS_TABLE = os.getenv("CORE_PLATFORM_ENTERPRISE_SUBSCRIPTIONS_TABLE", "core_platform.cp_enterprise_subscriptions")
+    CORE_PLATFORM_CHANGE_PASSWORD_POLICY_TABLE = os.getenv("CORE_PLATFORM_CHANGE_PASSWORD_POLICY_TABLE", "core_platform.cp_change_password_policy")
+    CORE_PLATFORM_APP_FEATURES_TABLE = os.getenv("CORE_PLATFORM_APP_FEATURES_TABLE", "core_platform.cp_app_features")
 
     # =============================================================================
-    # AZURE CONFIGURATION (Optional - for queue functionality)
+    # CORE PLATFORM TABLES (prefixed with cp_, now in core_platform schema with tenant_id)
     # =============================================================================
-    STORAGE_ACCOUNT_NAME: str = os.getenv("STORAGE_ACCOUNT_NAME", "")
-    USER_ASSIGNED_MANAGED_IDENTITY: str = os.getenv("USER_ASSIGNED_MANAGED_IDENTITY", "")
-    
+    # NOTE: These tables have been renamed from tenant_ prefix to cp_ (core platform).
+    # All tables include tenant_id column for multi-tenant isolation.
+    # Tables with is_system column can contain both user and system data.
+    # =============================================================================
+    CORE_PLATFORM_GROUPS_TABLE = os.getenv("CORE_PLATFORM_GROUPS_TABLE", "core_platform.cp_groups")
+    CORE_PLATFORM_LOGIN_SETTINGS_TABLE = os.getenv("CORE_PLATFORM_LOGIN_SETTINGS_TABLE", "core_platform.cp_login_settings")
+    CORE_PLATFORM_RESOURCES_TABLE = os.getenv("CORE_PLATFORM_RESOURCES_TABLE", "core_platform.cp_resources")
+    CORE_PLATFORM_ASSIGN_ROLES_TABLE = os.getenv("CORE_PLATFORM_ASSIGN_ROLES_TABLE", "core_platform.cp_assign_roles")
+    CORE_PLATFORM_SUBSCRIPTION_HISTORY_TABLE = os.getenv("CORE_PLATFORM_SUBSCRIPTION_HISTORY_TABLE", "core_platform.cp_user_subscription_histories")
+    CORE_PLATFORM_RESOURCE_DELETION_CHAT_HISTORY_TABLE = os.getenv("CORE_PLATFORM_RESOURCE_DELETION_CHAT_HISTORY_TABLE", "core_platform.cp_resource_deletion_chat_histories")
+    CORE_PLATFORM_USER_GROUPS_TABLE = os.getenv("CORE_PLATFORM_USER_GROUPS_TABLE", "core_platform.cp_user_groups")
+    CORE_PLATFORM_ACTIVITY_LOGS_TABLE = os.getenv("CORE_PLATFORM_ACTIVITY_LOGS_TABLE", "core_platform.cp_activity_logs")
+    CORE_PLATFORM_ORGANIZATIONS_TABLE = os.getenv("CORE_PLATFORM_ORGANIZATIONS_TABLE", "core_platform.cp_organizations")
+    CORE_PLATFORM_BUSINESSES_TABLE = os.getenv("CORE_PLATFORM_BUSINESSES_TABLE", "core_platform.cp_businesses")
+    CORE_PLATFORM_BUSINESS_APPS_TABLE = os.getenv("CORE_PLATFORM_BUSINESS_APPS_TABLE", "core_platform.cp_business_apps")
+    CORE_PLATFORM_LOCATIONS_TABLE = os.getenv("CORE_PLATFORM_LOCATIONS_TABLE", "core_platform.cp_locations")
+    CORE_PLATFORM_ASSIGN_LOCATIONS_TABLE = os.getenv("CORE_PLATFORM_ASSIGN_LOCATIONS_TABLE", "core_platform.cp_assign_locations")
+    CORE_PLATFORM_UNIT_OF_MEASURE_TABLE = os.getenv("CORE_PLATFORM_UNIT_OF_MEASURE_TABLE", "core_platform.cp_unit_of_measures")
+    CORE_PLATFORM_CURRENCY = os.getenv("CORE_PLATFORM_CURRENCY", "core_platform.cp_currencies")
+    CORE_PLATFORM_THEMES_TABLE = os.getenv("CORE_PLATFORM_THEMES_TABLE", "core_platform.cp_themes")
+    CORE_PLATFORM_NOTIFICATION_EMAIL_CREDENTIALS_TABLE = os.getenv("CORE_PLATFORM_NOTIFICATION_EMAIL_CREDENTIALS_TABLE", "core_platform.cp_notification_email_credentials")
+
+    # Mail Configurations
+    MAIL_SENDER_EMAIL=os.getenv("MAIL_SENDER_EMAIL")
+    MAIL_SENDER_PWD=os.getenv("MAIL_SENDER_PWD")
+
+    # Application Configurations
+    APP_URL=os.getenv("APP_URL", "https://trovesuite.com")
+    USER_ASSIGNED_MANAGED_IDENTITY=os.getenv("USER_ASSIGNED_MANAGED_IDENTITY")
+
     @property
     def database_url(self) -> str:
-        """Get the database URL, either from DATABASE_URL or constructed from individual components"""
-        if self.DATABASE_URL != "postgresql://username:password@localhost:5432/database_name":
+        if self.DATABASE_URL:
             return self.DATABASE_URL
-        
-        # Validate individual components
-        if not all([self.DB_USER, self.DB_HOST, self.DB_NAME, self.DB_PASSWORD]):
-            missing = []
-            if not self.DB_USER:
-                missing.append("DB_USER")
-            if not self.DB_HOST:
-                missing.append("DB_HOST")
-            if not self.DB_NAME:
-                missing.append("DB_NAME")
-            if not self.DB_PASSWORD:
-                missing.append("DB_PASSWORD")
-            
-            raise ValueError(
-                f"Database configuration incomplete. Missing environment variables: {', '.join(missing)}. "
-                f"Please set these variables or provide a complete DATABASE_URL."
-            )
-        
-        return f"postgresql://{self.DB_USER}:{self.DB_PASSWORD}@{self.DB_HOST}:{self.DB_PORT}/{self.DB_NAME}"
-    
-    def validate_configuration(self) -> None:
-        """Validate the current configuration and warn about potential issues"""
-        warnings_list = []
-        
-        # Check for default secret key
-        if self.SECRET_KEY == "09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7":
-            warnings_list.append(
-                "SECRET_KEY is using the default value. This is insecure for production. "
-                "Please set a strong, unique SECRET_KEY environment variable."
-            )
-        
-        # Check for development environment in production-like settings
-        if self.ENVIRONMENT == "development" and self.DEBUG is False:
-            warnings_list.append(
-                "ENVIRONMENT is set to 'development' but DEBUG is False. "
-                "Consider setting ENVIRONMENT to 'production' for production deployments."
-            )
-        
-        # Check database configuration
-        try:
-            self.database_url
-        except ValueError as e:
-            warnings_list.append(f"Database configuration issue: {str(e)}")
-        
-        # Check for missing Azure configuration if needed
-        if self.ENVIRONMENT == "production" and not self.STORAGE_ACCOUNT_NAME:
-            warnings_list.append(
-                "STORAGE_ACCOUNT_NAME is not set. Azure queue functionality may not work properly."
-            )
-        
-        # Emit warnings
-        for warning in warnings_list:
-            warnings.warn(warning, UserWarning)
-    
-    def get_configuration_summary(self) -> dict:
-        """Get a summary of the current configuration (excluding sensitive data)"""
-        return {
-            "app_name": self.APP_NAME,
-            "environment": self.ENVIRONMENT,
-            "debug": self.DEBUG,
-            "database_host": self.DB_HOST,
-            "database_port": self.DB_PORT,
-            "database_name": self.DB_NAME,
-            "database_user": self.DB_USER,
-            "log_level": self.LOG_LEVEL,
-            "log_format": self.LOG_FORMAT,
-            "log_to_file": self.LOG_TO_FILE,
-            "algorithm": self.ALGORITHM,
-            "access_token_expire_minutes": self.ACCESS_TOKEN_EXPIRE_MINUTES,
-            "MAIN_TENANTS_TABLE": self.MAIN_TENANTS_TABLE,
-            "role_permissions_table": self.ROLE_PERMISSIONS_TABLE,
-            "TENANT_LOGIN_SETTINGS_TABLE": self.TENANT_LOGIN_SETTINGS_TABLE,
-            "user_groups_table": self.USER_GROUPS_TABLE,
-            "assign_roles_table": self.ASSIGN_ROLES_TABLE,
-        }
 
-# Global settings instance
-db_settings = Settings()
+        port = int(self.DB_PORT) if self.DB_PORT else 5432
+        return f"postgresql://{self.DB_USER}:{self.DB_PASSWORD}@{self.DB_HOST}:{port}/{self.DB_NAME}"
 
-# Validate configuration on import
-try:
-    db_settings.validate_configuration()
-except Exception as e:
-    warnings.warn("Configuration validation failed: %s", str(e), UserWarning)
+# Global settings instance
+db_settings = Settings()

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/__init__.py

@@ -0,0 +1,14 @@
+"""
+TroveSuite Notification Service
+
+Provides email and SMS notification capabilities for TroveSuite applications.
+"""
+
+from .notification_service import NotificationService
+from .notification_write_dto import NotificationEmailServiceWriteDto, NotificationSMSServiceWriteDto
+
+__all__ = [
+    "NotificationService",
+    "NotificationEmailServiceWriteDto",
+    "NotificationSMSServiceWriteDto"
+]

trovesuite/notification/notification_base.py

@@ -0,0 +1,13 @@
+from typing import List, Optional, Union
+from pydantic import BaseModel
+
+class NotificationEmailBase(BaseModel):
+    sender_email: str
+    receiver_email: Union[str, List[str]]
+    password: str
+    subject: str
+    text_message: str
+    html_message: Optional[str] = None
+
+class NotificationSMSBase(BaseModel):
+    pass