Merge pull request #62 from mafzaal/copilot/fix-61

[FEATURE] Implement System Settings Management Feature with Database Storage and Admin UI

Author: mafzaal

.github/copilot-instructions.md

@@ -40,3 +40,11 @@ This file provides guidelines for GitHub Copilot to interact with this repositor
   - Use `test_document_loader_pytest.py` for main tests
   - Use `test_document_loader_comprehensive_pytest.py` for comprehensive tests 
 - Use `_pytest` suffix for new pytest files to avoid conflicts with existing unittest files
+
+# Documentation and Comments
+- Use clear, concise comments in code to explain complex logic or important decisions
+- Use docstrings for functions and classes to describe their purpose, parameters, and return values
+- Maintain consistent formatting and style across all documentation files
+- Use Markdown for documentation files, ensuring proper headings, lists, and code blocks
+- Store documentation in the `docs/` directory, with subdirectories for specific topics (e.g., `docs/frontend/`, `docs/backend/`, etc.)
+

backend/lets_talk/api/endpoints/settings.py

@@ -0,0 +1,132 @@
+"""FastAPI endpoints for settings management."""
+from fastapi import APIRouter, HTTPException, Depends
+from typing import List
+import logging
+
+from lets_talk.api.models.settings import (
+    SettingsResponse,
+    SettingsUpdateSchema,
+    SettingsUpdateResponse,
+    RestoreDefaultsResponse
+)
+from lets_talk.core.services.settings import SettingsService
+from lets_talk.core.services.settings_init import settings_initializer
+from lets_talk.shared.config import LOGGER_NAME
+
+logger = logging.getLogger(f"{LOGGER_NAME}.api.settings")
+
+router = APIRouter(
+    prefix="/settings",
+    tags=["settings"],
+    responses={404: {"description": "Not found"}},
+)
+
+
+def get_settings_service():
+    """Dependency to get settings service instance."""
+    return SettingsService()
+
+
+@router.get("/", response_model=SettingsResponse)
+async def get_settings(settings_service: SettingsService = Depends(get_settings_service)):
+    """
+    Get all system settings.
+    
+    Returns all settings with secrets masked and organized by sections.
+    """
+    try:
+        # Ensure settings are initialized
+        if not settings_initializer.ensure_settings_initialized():
+            raise HTTPException(
+                status_code=500,
+                detail="Failed to initialize settings database"
+            )
+        
+        settings = settings_service.get_all_settings()
+        sections = settings_service.get_sections()
+        
+        return SettingsResponse(
+            settings=settings,
+            sections=sorted(sections)
+        )
+    
+    except Exception as e:
+        logger.error(f"Error getting settings: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Internal server error: {str(e)}"
+        )
+
+
+@router.put("/", response_model=SettingsUpdateResponse)
+async def update_settings(
+    update_request: SettingsUpdateSchema,
+    settings_service: SettingsService = Depends(get_settings_service)
+):
+    """
+    Update multiple system settings.
+    
+    Only read-write settings can be updated. Read-only settings will be rejected.
+    """
+    try:
+        # Ensure settings are initialized
+        if not settings_initializer.ensure_settings_initialized():
+            raise HTTPException(
+                status_code=500,
+                detail="Failed to initialize settings database"
+            )
+        
+        successful_updates, failed_updates = settings_service.update_settings(
+            update_request.settings
+        )
+        
+        success = len(failed_updates) == 0
+        message = "All settings updated successfully" if success else "Some settings failed to update"
+        
+        return SettingsUpdateResponse(
+            success=success,
+            message=message,
+            updated_settings=successful_updates,
+            failed_settings=failed_updates
+        )
+    
+    except Exception as e:
+        logger.error(f"Error updating settings: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Internal server error: {str(e)}"
+        )
+
+
+@router.post("/restore-defaults", response_model=RestoreDefaultsResponse)
+async def restore_default_settings(
+    settings_service: SettingsService = Depends(get_settings_service)
+):
+    """
+    Restore all read-write settings to their default values.
+    
+    This will reset all editable settings to their original default values.
+    Read-only settings are not affected.
+    """
+    try:
+        # Ensure settings are initialized
+        if not settings_initializer.ensure_settings_initialized():
+            raise HTTPException(
+                status_code=500,
+                detail="Failed to initialize settings database"
+            )
+        
+        restored_count = settings_service.restore_defaults()
+        
+        return RestoreDefaultsResponse(
+            success=True,
+            message=f"Successfully restored {restored_count} settings to defaults",
+            restored_count=restored_count
+        )
+    
+    except Exception as e:
+        logger.error(f"Error restoring defaults: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail=f"Internal server error: {str(e)}"
+        )

backend/lets_talk/api/main.py

@@ -8,7 +8,7 @@
 import logging
 
 from lets_talk.api.dependencies import set_scheduler_instance
-from lets_talk.api.endpoints import scheduler, pipeline, health
+from lets_talk.api.endpoints import scheduler, pipeline, health, settings
 from lets_talk.core.scheduler.manager import PipelineScheduler
 from lets_talk.shared.config import LOGGER_NAME
 
@@ -102,9 +102,9 @@ def create_app() -> FastAPI:
                 "description": "Background task scheduler endpoints. Control the execution of scheduled tasks and monitor their status."
             },
             {
-                "name": "examples",
-                "description": "Example endpoints demonstrating API patterns, request/response models, and documentation best practices. These endpoints showcase common REST operations and can be used for testing and learning."
-            }
+                "name": "settings",
+                "description": "System settings management endpoints. View, update, and restore system configurations through a user-friendly API."
+            },
         ],
         docs_url="/docs",
         redoc_url="/redoc",
@@ -126,6 +126,7 @@ def create_app() -> FastAPI:
     app.include_router(scheduler.router)
     app.include_router(pipeline.router)
     app.include_router(health.router)
+    app.include_router(settings.router)
 
 
     def custom_openapi():

backend/lets_talk/api/models/settings.py

@@ -0,0 +1,74 @@
+"""Pydantic schemas for settings API."""
+from pydantic import BaseModel, Field
+from typing import Dict, List, Optional, Any, Union
+from datetime import datetime
+
+
+class SettingSchema(BaseModel):
+    """Schema for individual setting representation."""
+    key: str = Field(..., description="Unique identifier for the setting")
+    value: str = Field(..., description="Current value of the setting")
+    default_value: str = Field(..., description="Default value of the setting")
+    data_type: str = Field(..., description="Data type: string, integer, boolean, float")
+    is_secret: bool = Field(..., description="Whether this is a secret setting")
+    section: str = Field(..., description="Setting section/category")
+    description: Optional[str] = Field(None, description="Human-readable description")
+    is_read_only: bool = Field(..., description="Whether this setting is read-only")
+    created_at: datetime = Field(..., description="When the setting was created")
+    updated_at: datetime = Field(..., description="When the setting was last updated")
+
+    class Config:
+        from_attributes = True
+
+
+class SettingDisplaySchema(BaseModel):
+    """Schema for displaying settings (masks secrets)."""
+    key: str
+    value: str  # This will be masked if is_secret is True
+    default_value: str
+    data_type: str
+    is_secret: bool
+    section: str
+    description: Optional[str]
+    is_read_only: bool
+
+    class Config:
+        from_attributes = True
+
+
+class SettingUpdateSchema(BaseModel):
+    """Schema for updating a single setting."""
+    key: str = Field(..., description="Setting key to update")
+    value: str = Field(..., description="New value for the setting")
+
+
+class SettingsUpdateSchema(BaseModel):
+    """Schema for updating multiple settings."""
+    settings: List[SettingUpdateSchema] = Field(..., description="List of settings to update")
+
+
+class SettingsResponse(BaseModel):
+    """Response schema for settings list."""
+    settings: List[SettingDisplaySchema] = Field(..., description="List of all settings")
+    sections: List[str] = Field(..., description="Available setting sections")
+
+
+class SettingsUpdateResponse(BaseModel):
+    """Response schema for settings update."""
+    success: bool = Field(..., description="Whether the update was successful")
+    message: str = Field(..., description="Success or error message")
+    updated_settings: List[str] = Field(..., description="List of updated setting keys")
+    failed_settings: List[Dict[str, str]] = Field(..., description="List of failed updates with errors")
+
+
+class RestoreDefaultsResponse(BaseModel):
+    """Response schema for restore defaults."""
+    success: bool = Field(..., description="Whether the restore was successful")
+    message: str = Field(..., description="Success or error message")
+    restored_count: int = Field(..., description="Number of settings restored to defaults")
+
+
+class SettingError(BaseModel):
+    """Schema for setting-related errors."""
+    key: str = Field(..., description="Setting key that caused the error")
+    error: str = Field(..., description="Error message")

backend/lets_talk/core/models/settings.py

@@ -0,0 +1,66 @@
+"""SQLAlchemy models for system settings."""
+from __future__ import annotations
+
+from sqlalchemy import Column, String, Text, Boolean, DateTime, create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from datetime import datetime
+from typing import Optional, Dict, Any
+import os
+from pathlib import Path
+
+from lets_talk.shared.config import OUTPUT_DIR
+
+Base = declarative_base()
+
+
+class Setting(Base):
+    """Model for storing system settings."""
+    __tablename__ = "settings"
+    
+    key = Column(String(255), primary_key=True, nullable=False)
+    value = Column(Text, nullable=False)
+    default_value = Column(Text, nullable=False)
+    data_type = Column(String(50), nullable=False)  # "string", "integer", "boolean", "float"
+    is_secret = Column(Boolean, default=False, nullable=False)
+    section = Column(String(100), nullable=False)  # e.g., "General", "API", "Database"
+    description = Column(Text, nullable=True)
+    is_read_only = Column(Boolean, default=False, nullable=False)
+    created_at = Column(DateTime, default=datetime.utcnow)
+    updated_at = Column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+    
+    def __repr__(self):
+        return f"<Setting(key='{self.key}', section='{self.section}', is_read_only={self.is_read_only})>"
+
+
+def get_settings_database_url() -> str:
+    """Get the database URL for settings storage."""
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+    return f"sqlite:///{OUTPUT_DIR}/settings.db"
+
+
+def create_settings_engine():
+    """Create SQLAlchemy engine for settings."""
+    database_url = get_settings_database_url()
+    engine = create_engine(database_url, echo=False)
+    return engine
+
+
+def create_settings_tables(engine):
+    """Create settings tables if they don't exist."""
+    Base.metadata.create_all(engine)
+
+
+def get_settings_session():
+    """Get a session for interacting with the settings database."""
+    engine = create_settings_engine()
+    create_settings_tables(engine)
+    SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+    return SessionLocal()
+
+
+def init_settings_db():
+    """Initialize the settings database and tables."""
+    engine = create_settings_engine()
+    create_settings_tables(engine)
+    return engine

backend/lets_talk/core/services/__init__.py

@@ -0,0 +1 @@
+"""Services package."""