Update admin_routes.py

admin_routes.py

@@ -21,6 +21,8 @@ from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
 from pydantic import BaseModel, Field
 
 from utils import log
+from config_provider import ConfigProvider
+from encryption_utils import encrypt, decrypt
 
 # ===================== JWT Config =====================
 def get_jwt_config():
@@ -146,18 +148,6 @@ class APIUpdate(BaseModel):
 class TestRequest(BaseModel):
     test_type: str  # "all", "ui", "backend", "integration", "spark"
 
-class EnvironmentUpdate(BaseModel):
-    work_mode: str
-    cloud_token: Optional[str] = None
-    spark_endpoint: str
-    internal_prompt: Optional[str] = None
-    tts_engine: str = "no_tts"
-    tts_engine_api_key: Optional[str] = None
-    tts_settings: Optional[Dict[str, Any]] = None
-    stt_engine: str = "no_stt"
-    stt_engine_api_key: Optional[str] = None
-    stt_settings: Optional[Dict[str, Any]] = None
-
 class TTSRequest(BaseModel):
     text: str
     voice_id: Optional[str] = None
@@ -186,6 +176,9 @@ def verify_token(credentials: HTTPAuthorizationCredentials = Depends(security))
         raise HTTPException(status_code=401, detail="Token expired")
     except jwt.InvalidTokenError:  # Bu genel JWT hatalarını yakalar
         raise HTTPException(status_code=401, detail="Invalid token")
+
+# Utility function to get username for Depends
+get_username = verify_token
         
 def hash_password(password: str, salt: str = None) -> tuple[str, str]:
     """Hash password with bcrypt.
@@ -214,64 +207,17 @@ def verify_password(password: str, hashed: str, salt: str = None) -> bool:
         log(f"Password verification error: {e}")
         return False
 
-def load_config():
-    """Load service_config.jsonc"""
-    config_path = Path("service_config.jsonc")
-    if not config_path.exists():
-        return {"config": {}, "projects": [], "apis": []}
-    
-    with open(config_path, 'r', encoding='utf-8') as f:
-        content = f.read()
-        # Remove comments for JSON parsing
-        lines = []
-        for line in content.split('\n'):
-            stripped = line.strip()
-            if not stripped.startswith('//'):
-                lines.append(line)
-        clean_content = '\n'.join(lines)
-        return json.loads(clean_content)
-
-def save_config(config: dict):
-    """Save config back to service_config.jsonc"""
-    with open("service_config.jsonc", 'w', encoding='utf-8') as f:
-        json.dump(config, f, indent=2, ensure_ascii=False)
-        
 def get_timestamp():
     """Get current timestamp in ISO format with milliseconds"""
     return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
 
-def add_activity_log(config: dict, username: str, action: str, 
-                    entity_type: str, entity_id: Any, entity_name: str,
-                    details: str = ""):
-    """Add activity log entry"""
-    if "activity_log" not in config:
-        config["activity_log"] = []
-    
-    # Get next ID
-    log_id = max([log.get("id", 0) for log in config["activity_log"]], default=0) + 1
-    
-    config["activity_log"].append({
-        "id": log_id,
-        "timestamp": get_timestamp(),
-        "user": username,
-        "action": action,
-        "entity_type": entity_type,
-        "entity_id": entity_id,
-        "entity_name": entity_name,
-        "details": details
-    })
-    
-    # Keep only last 1000 entries
-    if len(config["activity_log"]) > 1000:
-        config["activity_log"] = config["activity_log"][-1000:]
-
 async def _spark_project_control(action: str, project_name: str, username: str):
     """Common function for Spark project control"""
     if not project_name:
         raise HTTPException(status_code=400, detail="project_name is required")
     
-    config = load_config()
-    spark_endpoint = config.get("config", {}).get("spark_endpoint", "").rstrip("/")
+    cfg = ConfigProvider.get()
+    spark_endpoint = str(cfg.global_config.spark_endpoint).rstrip("/")
     spark_token = _get_spark_token()
     
     if not spark_endpoint:
@@ -306,8 +252,8 @@ async def _spark_project_control(action: str, project_name: str, username: str):
 
 def _get_spark_token() -> Optional[str]:
     """Get Spark token based on work_mode"""
-    config = load_config()
-    work_mode = config.get("config", {}).get("work_mode", "on-premise")
+    cfg = ConfigProvider.get()
+    work_mode = cfg.global_config.work_mode
     
     if work_mode in ("hfcloud", "cloud"):
         # Cloud mode - use HuggingFace Secrets
@@ -339,7 +285,6 @@ async def notify_spark_manual(project: dict, version: dict, global_config: dict)
     
     # Decrypt token if needed
     if cloud_token and cloud_token.startswith("enc:"):
-        from encryption_utils import decrypt
         cloud_token = decrypt(cloud_token)
     
     payload = {
@@ -371,16 +316,16 @@ async def notify_spark_manual(project: dict, version: dict, global_config: dict)
 @router.post("/login", response_model=LoginResponse)
 async def login(request: LoginRequest):
     """Authenticate user and return JWT token"""
-    config = load_config()
-    users = config.get("config", {}).get("users", [])
+    cfg = ConfigProvider.get()
+    users = cfg.global_config.users
     
     # Find user
-    user = next((u for u in users if u["username"] == request.username), None)
+    user = next((u for u in users if u.username == request.username), None)
     if not user:
         raise HTTPException(status_code=401, detail="Invalid credentials")
     
     # Verify password
-    if not verify_password(request.password, user["password_hash"], user.get("salt")):
+    if not verify_password(request.password, user.password_hash, user.salt):
         raise HTTPException(status_code=401, detail="Invalid credentials")
     
     # Generate JWT token
@@ -402,25 +347,23 @@ async def change_password(
     username: str = Depends(verify_token)
 ):
     """Change user password"""
-    config = load_config()
-    users = config.get("config", {}).get("users", [])
+    cfg = ConfigProvider.get()
+    users = cfg.global_config.users
     
     # Find user
-    user = next((u for u in users if u["username"] == username), None)
+    user = next((u for u in users if u.username == username), None)
     if not user:
         raise HTTPException(status_code=404, detail="User not found")
     
     # Verify current password
-    if not verify_password(request.current_password, user["password_hash"], user.get("salt")):
+    if not verify_password(request.current_password, user.password_hash, user.salt):
         raise HTTPException(status_code=401, detail="Current password is incorrect")
     
     # Hash new password
     new_hash, new_salt = hash_password(request.new_password)
-    user["password_hash"] = new_hash
-    user["salt"] = new_salt
     
-    # Save config
-    save_config(config)
+    # Update user via ConfigProvider
+    ConfigProvider.update_user_password(username, new_hash, new_salt)
     
     log(f"✅ Password changed for user '{username}'")
     return {"success": True}
@@ -457,32 +400,21 @@ async def get_locale_details(
 @router.get("/environment")
 async def get_environment(username: str = Depends(verify_token)):
     """Get environment configuration"""
-    config = load_config()
-    env_config = config.get("config", {})
+    cfg = ConfigProvider.get()
+    env_config = cfg.global_config
     
     return {
-        "work_mode": env_config.get("work_mode", "on-premise"),
-        "cloud_token": env_config.get("cloud_token", ""),
-        "spark_endpoint": env_config.get("spark_endpoint", "http://localhost:7861"),
-        "internal_prompt": env_config.get("internal_prompt", ""),
-        "tts_engine": env_config.get("tts_engine", "no_tts"),
-        "tts_engine_api_key": env_config.get("tts_engine_api_key", ""),
-        "tts_settings": env_config.get("tts_settings", {
-            "use_ssml": False
-        }),
-        "stt_engine": env_config.get("stt_engine", "no_stt"),
-        "stt_engine_api_key": env_config.get("stt_engine_api_key", ""),
-        "stt_settings": env_config.get("stt_settings", {
-            "speech_timeout_ms": 2000,
-            "noise_reduction_level": 2,
-            "vad_sensitivity": 0.5,
-            "language": "tr-TR",
-            "model": "latest_long",
-            "use_enhanced": True,
-            "enable_punctuation": True,
-            "interim_results": True
-            }),
-        "parameter_collection_config": env_config.get("parameter_collection_config", {})
+        "work_mode": env_config.work_mode,
+        "cloud_token": env_config.cloud_token or "",
+        "spark_endpoint": str(env_config.spark_endpoint),
+        "internal_prompt": env_config.internal_prompt or "",
+        "tts_engine": env_config.tts_engine,
+        "tts_engine_api_key": env_config.tts_engine_api_key or "",
+        "tts_settings": env_config.get_tts_settings(),
+        "stt_engine": env_config.stt_engine,
+        "stt_engine_api_key": env_config.stt_engine_api_key or "",
+        "stt_settings": env_config.get_stt_settings(),
+        "parameter_collection_config": env_config.parameter_collection_config.model_dump()
     }
 
 @router.put("/environment")
@@ -491,7 +423,7 @@ async def update_environment(
     username: str = Depends(verify_token)
 ):
     """Update environment configuration"""
-    config = load_config()
+    log(f"📝 Updating environment config by {username}")
     
     # Token validation based on mode
     if update.work_mode in ("gpt4o", "gpt4o-mini"):
@@ -503,10 +435,6 @@ async def update_environment(
         if not update.cloud_token:
             raise HTTPException(status_code=400, detail="Cloud token is required for cloud modes")
 
-    # Debug log - gelen değerleri kontrol et
-    log(f"📥 Received TTS engine: {update.tts_engine}")
-    log(f"📥 Received TTS key: {'***' + update.tts_engine_api_key[-4:] if update.tts_engine_api_key else 'None'}")
-
     # TTS/STT validation
     if update.tts_engine not in ("no_tts", "elevenlabs", "blaze"):
         raise HTTPException(status_code=400, detail="Invalid TTS engine")
@@ -524,52 +452,9 @@ async def update_environment(
     if update.work_mode not in ("gpt4o", "gpt4o-mini") and not update.spark_endpoint:
         raise HTTPException(status_code=400, detail="Spark endpoint is required for non-GPT modes")
     
-    # Encrypt API keys if needed
-    from encryption_utils import encrypt
+    # Update via ConfigProvider
+    ConfigProvider.update_environment(update.model_dump(), username)
     
-    # TTS key encryption
-    if update.tts_engine_api_key:
-        encrypted_tts_key = encrypt(update.tts_engine_api_key)
-        log(f"🔐 Encrypted TTS key: {encrypted_tts_key[:20]}...")
-    else:
-        encrypted_tts_key = ""
-
-    # STT key encryption
-    if update.stt_engine_api_key:
-        encrypted_stt_key = encrypt(update.stt_engine_api_key)
-    else:
-        encrypted_stt_key = ""
-
-    # Update config
-    config["config"]["work_mode"] = update.work_mode
-    config["config"]["cloud_token"] = encrypt(update.cloud_token) if update.cloud_token else ""
-    config["config"]["spark_endpoint"] = update.spark_endpoint
-    config["config"]["internal_prompt"] = update.internal_prompt or ""
-    config["config"]["tts_engine"] = update.tts_engine
-    config["config"]["tts_engine_api_key"] = encrypted_tts_key
-    config["config"]["stt_engine"] = update.stt_engine
-    config["config"]["stt_engine_api_key"] = encrypted_stt_key
-    config["config"]["last_update_date"] = get_timestamp()
-    config["config"]["last_update_user"] = username
-    config["config"]["parameter_collection_config"] = update.parameter_collection_config
-    
-    if update.tts_settings:
-        config["config"]["tts_settings"] = update.tts_settings
-    
-    if update.stt_settings:
-        config["config"]["stt_settings"] = update.stt_settings
-    
-    # Add activity log
-    add_activity_log(config, username, "UPDATE_ENVIRONMENT", "config", None, 
-                    "environment", f"Changed to {update.work_mode}, TTS: {update.tts_engine}, STT: {update.stt_engine}")
-    
-    # Save config
-    save_config(config)
-    
-    # Reload ConfigProvider to reflect changes
-    from config_provider import ConfigProvider
-    ConfigProvider.reload()
-
     log(f"✅ Environment updated to {update.work_mode} with TTS: {update.tts_engine}, STT: {update.stt_engine} by {username}")
     return {"success": True}
 
@@ -577,9 +462,8 @@ async def update_environment(
 @router.get("/projects/names")
 def list_enabled_projects():
     """Get list of enabled project names for chat"""
-    cfg = load_config()
-    projects = cfg.get("projects", [])
-    return [p["name"] for p in projects if p.get("enabled", False) and not p.get("deleted", False)]
+    cfg = ConfigProvider.get()
+    return [p.name for p in cfg.projects if p.enabled and not getattr(p, 'deleted', False)]
 
 @router.get("/projects")
 async def list_projects(
@@ -587,14 +471,14 @@ async def list_projects(
     username: str = Depends(verify_token)
 ):
     """List all projects"""
-    config = load_config()
-    projects = config.get("projects", [])
+    cfg = ConfigProvider.get()
+    projects = cfg.projects
     
     # Filter deleted if needed
     if not include_deleted:
-        projects = [p for p in projects if not p.get("deleted", False)]
+        projects = [p for p in projects if not getattr(p, 'deleted', False)]
     
-    return projects
+    return [p.model_dump() for p in projects]
 
 @router.get("/projects/{project_id}")
 async def get_project(
@@ -602,21 +486,11 @@ async def get_project(
     username: str = Depends(verify_token)
 ):
     """Get single project by ID"""
-    try:
-        config = load_config()
-        projects = config.get("projects", [])
-        
-        project = next((p for p in projects if p.get("id") == project_id), None)
-        if not project or project.get("deleted", False):
-            raise HTTPException(status_code=404, detail="Project not found")
-        
-        return project
-        
-    except HTTPException:
-        raise
-    except Exception as e:
-        log(f"Failed to get project: {e}")
-        raise HTTPException(status_code=500, detail=str(e))
+    project = ConfigProvider.get_project(project_id)
+    if not project or getattr(project, 'deleted', False):
+        raise HTTPException(status_code=404, detail="Project not found")
+    
+    return project.model_dump()
 
 @router.post("/projects")
 async def create_project(
@@ -624,13 +498,6 @@ async def create_project(
     username: str = Depends(verify_token)
 ):
     """Create new project with initial version"""
-    config = load_config()
-    
-    # Validate project name
-    existing_names = [p["name"].lower() for p in config.get("projects", []) if not p.get("deleted", False)]
-    if project.name.lower() in existing_names:
-        raise HTTPException(status_code=400, detail="Project name already exists")
-    
     # Validate supported languages
     from locale_manager import LocaleManager
     
@@ -644,77 +511,17 @@ async def create_project(
         )
     
     # Check if default language is in supported languages
-    # NOT: default_language bir name (Türkçe), supported_languages ise code'lar (tr-TR)
-    # Bu yüzden karşılaştırma yapamayız, sadece supported_languages'ın boş olmamasını kontrol edelim
     if not project.supported_languages:
         raise HTTPException(
             status_code=400,
             detail="At least one supported language must be selected"
         )
     
-    # Get new project ID
-    project_id = config.get("project_id_counter", 1)
-    config["project_id_counter"] = project_id + 1
-    
-    # Create project with version
-    new_project = {
-        "id": project_id,
-        "name": project.name,
-        "caption": project.caption,
-        "icon": project.icon,
-        "description": project.description,
-        "default_language": project.default_language,
-        "supported_languages": project.supported_languages,
-        "timezone": project.timezone,
-        "region": project.region,
-        "enabled": True,
-        "deleted": False,
-        "version_id_counter": 2,  # Start from 2 since we create version 1
-        "last_version_number": 1,
-        "created_date": get_timestamp(),
-        "created_by": username,
-        "last_update_date": get_timestamp(),
-        "last_update_user": username,
-        "versions": [
-            {
-                "id": 1,
-                "no": 1,
-                "caption": "Version 1",
-                "published": False,
-                "created_date": get_timestamp(),
-                "created_by": username,
-                "last_update_date": get_timestamp(),
-                "last_update_user": username,
-                "general_prompt": "",
-                "llm": {
-                    "repo_id": "Qwen/Qwen2.5-72B-Instruct",
-                    "generation_config": {
-                        "temperature": 0.5,
-                        "max_tokens": 2048,
-                        "top_p": 0.7,
-                        "repetition_penalty": 1.1
-                    },
-                    "use_fine_tune": False,
-                    "fine_tune_zip": ""
-                },
-                "intents": []
-            }
-        ]
-    }
-    
-    # Add to config
-    if "projects" not in config:
-        config["projects"] = []
-    config["projects"].append(new_project)
-    
-    # Add activity log
-    add_activity_log(config, username, "CREATE_PROJECT", "project", project_id, project.name)
-    
-    # Save
-    save_config(config)
+    # Create project via ConfigProvider
+    new_project = ConfigProvider.create_project(project.model_dump(), username)
     
     log(f"✅ Project '{project.name}' created by {username}")
-    return new_project
+    return new_project.model_dump()
 
 @router.put("/projects/{project_id}")
 async def update_project(
@@ -723,85 +530,27 @@ async def update_project(
     username: str = Depends(verify_token)
 ):
     """Update project"""
-    config = load_config()
-    
-    # Find project
-    project = next((p for p in config.get("projects", []) if p["id"] == project_id), None)
-    if not project:
-        raise HTTPException(status_code=404, detail="Project not found")
+    # Update via ConfigProvider
+    updated_project = ConfigProvider.update_project(project_id, update.model_dump(), username)
     
-    # Check race condition
-    if project.get("last_update_date") != update.last_update_date:
-        raise HTTPException(status_code=409, detail="Project was modified by another user")
-    
-    # Update - yeni alanlarla
-    project["caption"] = update.caption
-    project["icon"] = update.icon
-    project["description"] = update.description
-    project["default_language"] = update.default_language
-    project["supported_languages"] = update.supported_languages
-    project["timezone"] = update.timezone
-    project["region"] = update.region
-    project["last_update_date"] = get_timestamp()
-    project["last_update_user"] = username
-    
-    # Add activity log
-    add_activity_log(config, username, "UPDATE_PROJECT", "project", project_id, project["name"])
-    
-    # Save
-    save_config(config)
-    
-    log(f"✅ Project '{project['name']}' updated by {username}")
-    return project
+    log(f"✅ Project '{updated_project.name}' updated by {username}")
+    return updated_project.model_dump()
 
 @router.delete("/projects/{project_id}")
 async def delete_project(project_id: int, username: str = Depends(verify_token)):
     """Delete project (soft delete)"""
-    config = load_config()
-    
-    # Find project
-    project = next((p for p in config.get("projects", []) if p["id"] == project_id), None)
-    if not project:
-        raise HTTPException(status_code=404, detail="Project not found")
+    ConfigProvider.delete_project(project_id, username)
     
-    # Soft delete
-    project["deleted"] = True
-    project["last_update_date"] = get_timestamp()
-    project["last_update_user"] = username
-    
-    # Add activity log
-    add_activity_log(config, username, "DELETE_PROJECT", "project", project_id, project["name"])
-    
-    # Save
-    save_config(config)
-    
-    log(f"✅ Project '{project['name']}' deleted by {username}")
+    log(f"✅ Project deleted by {username}")
     return {"success": True}
 
 @router.patch("/projects/{project_id}/toggle")
 async def toggle_project(project_id: int, username: str = Depends(verify_token)):
     """Toggle project enabled status"""
-    config = load_config()
-    
-    # Find project
-    project = next((p for p in config.get("projects", []) if p["id"] == project_id), None)
-    if not project:
-        raise HTTPException(status_code=404, detail="Project not found")
-    
-    # Toggle
-    project["enabled"] = not project.get("enabled", False)
-    project["last_update_date"] = get_timestamp()
-    project["last_update_user"] = username
-    
-    # Add activity log
-    action = "ENABLE_PROJECT" if project["enabled"] else "DISABLE_PROJECT"
-    add_activity_log(config, username, action, "project", project_id, project["name"])
+    enabled = ConfigProvider.toggle_project(project_id, username)
     
-    # Save
-    save_config(config)
-    
-    log(f"✅ Project '{project['name']}' {'enabled' if project['enabled'] else 'disabled'} by {username}")
-    return {"enabled": project["enabled"]}
+    log(f"✅ Project {'enabled' if enabled else 'disabled'} by {username}")
+    return {"enabled": enabled}
 
 # ===================== Version Endpoints =====================
 @router.get("/projects/{project_id}/versions")
@@ -811,20 +560,17 @@ async def list_versions(
     username: str = Depends(verify_token)
 ):
     """List project versions"""
-    config = load_config()
-    
-    # Find project
-    project = next((p for p in config.get("projects", []) if p["id"] == project_id), None)
+    project = ConfigProvider.get_project(project_id)
     if not project:
         raise HTTPException(status_code=404, detail="Project not found")
     
-    versions = project.get("versions", [])
+    versions = project.versions
     
     # Filter deleted if needed
     if not include_deleted:
-        versions = [v for v in versions if not v.get("deleted", False)]
+        versions = [v for v in versions if not getattr(v, 'deleted', False)]
     
-    return versions
+    return [v.model_dump() for v in versions]
 
 @router.post("/projects/{project_id}/versions")
 async def create_version(
@@ -833,89 +579,10 @@ async def create_version(
     username: str = Depends(verify_token)
 ):
     """Create new version"""
-    config = load_config()
-    
-    # Find project
-    project = next((p for p in config.get("projects", []) if p["id"] == project_id), None)
-    if not project:
-        raise HTTPException(status_code=404, detail="Project not found")
-    
-    # Get next version ID
-    version_id = project.get("version_id_counter", 0) + 1
-    project["version_id_counter"] = version_id
-    
-    # Get next version number
-    existing_versions = [v for v in project.get("versions", []) if not v.get("deleted", False)]
-    version_no = max([v.get("no", 0) for v in existing_versions], default=0) + 1
-    
-    # Create base version
-    new_version = {
-        "id": version_id,
-        "no": version_no,
-        "caption": version_data.caption,
-        "description": f"Version {version_no}",
-        "published": False,
-        "deleted": False,
-        "created_date": get_timestamp(),
-        "created_by": username,
-        "last_update_date": get_timestamp(),
-        "last_update_user": username,
-        "publish_date": None,
-        "published_by": None
-    }
+    new_version = ConfigProvider.create_version(project_id, version_data.model_dump(), username)
     
-    # Copy from source version if specified
-    if version_data.source_version_id:
-        source_version = next(
-            (v for v in project.get("versions", []) if v["id"] == version_data.source_version_id),
-            None
-        )
-        if source_version:
-            # Copy configuration from source
-            new_version.update({
-                "general_prompt": source_version.get("general_prompt", ""),
-                "llm": source_version.get("llm", {}).copy(),
-                "intents": [intent.copy() for intent in source_version.get("intents", [])],
-                "parameters": [param.copy() for param in source_version.get("parameters", [])]
-            })
-    else:
-        # Empty template
-        new_version.update({
-            "general_prompt": "",
-            "llm": {
-                "repo_id": "",
-                "generation_config": {
-                    "max_new_tokens": 512,
-                    "temperature": 0.7,
-                    "top_p": 0.95,
-                    "top_k": 50,
-                    "repetition_penalty": 1.1
-                },
-                "use_fine_tune": False,
-                "fine_tune_zip": ""
-            },
-            "intents": [],
-            "parameters": []
-        })
-    
-    # Add to project
-    if "versions" not in project:
-        project["versions"] = []
-    project["versions"].append(new_version)
-    
-    # Update project timestamp
-    project["last_update_date"] = get_timestamp()
-    project["last_update_user"] = username
-    
-    # Add activity log
-    add_activity_log(config, username, "CREATE_VERSION", "version", version_id,
-                    f"{project['name']} v{version_no}")
-    
-    # Save
-    save_config(config)
-    
-    log(f"✅ Version {version_no} created for project '{project['name']}' by {username}")
-    return new_version
+    log(f"✅ Version created for project {project_id} by {username}")
+    return new_version.model_dump()
 
 @router.put("/projects/{project_id}/versions/{version_id}")
 async def update_version(
@@ -925,46 +592,10 @@ async def update_version(
     username: str = Depends(verify_token)
 ):
     """Update version"""
-    config = load_config()
-    
-    # Find project and version
-    project = next((p for p in config.get("projects", []) if p["id"] == project_id), None)
-    if not project:
-        raise HTTPException(status_code=404, detail="Project not found")
-    
-    version = next((v for v in project.get("versions", []) if v["id"] == version_id), None)
-    if not version:
-        raise HTTPException(status_code=404, detail="Version not found")
-    
-    # Check race condition
-    if version.get("last_update_date") != update.last_update_date:
-        raise HTTPException(status_code=409, detail="Version was modified by another user")
+    updated_version = ConfigProvider.update_version(project_id, version_id, update.model_dump(), username)
     
-    # Cannot update published version
-    if version.get("published", False):
-        raise HTTPException(status_code=400, detail="Cannot modify published version")
-    
-    # Update version
-    version["caption"] = update.caption
-    version["general_prompt"] = update.general_prompt
-    version["llm"] = update.llm
-    version["intents"] = [intent.dict() for intent in update.intents]
-    version["last_update_date"] = get_timestamp()
-    version["last_update_user"] = username
-    
-    # Update project timestamp
-    project["last_update_date"] = get_timestamp()
-    project["last_update_user"] = username
-    
-    # Add activity log
-    add_activity_log(config, username, "UPDATE_VERSION", "version", version_id,
-                    f"{project['name']} v{version['no']}")
-    
-    # Save
-    save_config(config)
-    
-    log(f"✅ Version {version['no']} updated for project '{project['name']}' by {username}")
-    return version
+    log(f"✅ Version {version_id} updated for project {project_id} by {username}")
+    return updated_version.model_dump()
 
 @router.post("/projects/{project_id}/versions/{version_id}/publish")
 async def publish_version(
@@ -973,46 +604,19 @@ async def publish_version(
     username: str = Depends(verify_token)
 ):
     """Publish version"""
-    config = load_config()
-    
-    # Find project and version
-    project = next((p for p in config.get("projects", []) if p["id"] == project_id), None)
-    if not project:
-        raise HTTPException(status_code=404, detail="Project not found")
-    
-    version = next((v for v in project.get("versions", []) if v["id"] == version_id), None)
-    if not version:
-        raise HTTPException(status_code=404, detail="Version not found")
-    
-    # Unpublish all other versions
-    for v in project.get("versions", []):
-        if v["id"] != version_id:
-            v["published"] = False
-    
-    # Publish this version
-    version["published"] = True
-    version["publish_date"] = get_timestamp()
-    version["published_by"] = username
-    version["last_update_date"] = get_timestamp()
-    version["last_update_user"] = username
-    
-    # Update project timestamp
-    project["last_update_date"] = get_timestamp()
-    project["last_update_user"] = username
-    
-    # Add activity log
-    add_activity_log(config, username, "PUBLISH_VERSION", "version", version_id,
-                    f"{project['name']} v{version['no']}")
-    
-    # Save
-    save_config(config)
+    project, version = ConfigProvider.publish_version(project_id, version_id, username)
     
-    log(f"✅ Version {version_id} published for project '{project['name']}' by {username}")
+    log(f"✅ Version {version_id} published for project '{project.name}' by {username}")
 
     # Notify Spark if project is enabled
-    if project.get("enabled", False):
+    if project.enabled:
         try:
-            await notify_spark_manual(project, version, config.get("config", {}))
+            cfg = ConfigProvider.get()
+            await notify_spark_manual(
+                project.model_dump(), 
+                version.model_dump(), 
+                cfg.global_config.model_dump()
+            )
         except Exception as e:
             log(f"⚠️ Failed to notify Spark: {e}")
             # Don't fail the publish 
@@ -1026,37 +630,9 @@ async def delete_version(
     username: str = Depends(verify_token)
 ):
     """Delete version (soft delete)"""
-    config = load_config()
-    
-    # Find project and version
-    project = next((p for p in config.get("projects", []) if p["id"] == project_id), None)
-    if not project:
-        raise HTTPException(status_code=404, detail="Project not found")
-    
-    version = next((v for v in project.get("versions", []) if v["id"] == version_id), None)
-    if not version:
-        raise HTTPException(status_code=404, detail="Version not found")
-    
-    # Cannot delete published version
-    if version.get("published", False):
-        raise HTTPException(status_code=400, detail="Cannot delete published version")
+    ConfigProvider.delete_version(project_id, version_id, username)
     
-    # Soft delete
-    version["deleted"] = True
-    version["last_update_date"] = get_timestamp()
-    version["last_update_user"] = username
-    
-    project["last_update_date"] = get_timestamp()
-    project["last_update_user"] = username
-    
-    # Add activity log
-    add_activity_log(config, username, "DELETE_VERSION", "version", version_id,
-                    f"{project['name']} v{version_id}")
-    
-    # Save
-    save_config(config)
-    
-    log(f"✅ Version {version_id} deleted for project '{project['name']}' by {username}")
+    log(f"✅ Version {version_id} deleted for project {project_id} by {username}")
     return {"success": True}
 
 @router.post("/validate/regex")
@@ -1095,45 +671,22 @@ async def list_apis(
     username: str = Depends(verify_token)
 ):
     """List all APIs"""
-    config = load_config()
-    apis = config.get("apis", [])
+    cfg = ConfigProvider.get()
+    apis = cfg.apis
     
     # Filter deleted if needed
     if not include_deleted:
-        apis = [a for a in apis if not a.get("deleted", False)]
+        apis = [a for a in apis if not getattr(a, 'deleted', False)]
     
-    return apis
+    return [a.model_dump() for a in apis]
 
 @router.post("/apis")
 async def create_api(api: APICreate, username: str = Depends(verify_token)):
     """Create new API"""
-    config = load_config()
-    
-    # Check duplicate name
-    existing = [a for a in config.get("apis", []) if a["name"] == api.name]
-    if existing:
-        raise HTTPException(status_code=400, detail="API name already exists")
-    
-    # Create API
-    new_api = api.dict()
-    new_api["deleted"] = False
-    new_api["created_date"] = get_timestamp()
-    new_api["created_by"] = username
-    new_api["last_update_date"] = get_timestamp()
-    new_api["last_update_user"] = username
-    
-    if "apis" not in config:
-        config["apis"] = []
-    config["apis"].append(new_api)
-    
-    # Add activity log
-    add_activity_log(config, username, "CREATE_API", "api", api.name, api.name)
-    
-    # Save
-    save_config(config)
+    new_api = ConfigProvider.create_api(api.model_dump(), username)
     
     log(f"✅ API '{api.name}' created by {username}")
-    return new_api
+    return new_api.model_dump()
 
 @router.put("/apis/{api_name}")
 async def update_api(
@@ -1142,78 +695,15 @@ async def update_api(
     username: str = Depends(verify_token)
 ):
     """Update API"""
-    config = load_config()
-    
-    # Find API
-    api = next((a for a in config.get("apis", []) if a["name"] == api_name), None)
-    if not api:
-        raise HTTPException(status_code=404, detail="API not found")
-    
-    # Check race condition
-    if api.get("last_update_date") != update.last_update_date:
-        raise HTTPException(status_code=409, detail="API was modified by another user")
-    
-    # Check if API is in use
-    for project in config.get("projects", []):
-        for version in project.get("versions", []):
-            for intent in version.get("intents", []):
-                if intent.get("action") == api_name and version.get("published", False):
-                    raise HTTPException(status_code=400,
-                                      detail=f"API is used in published version of project '{project['name']}'")
-    
-    # Update
-    update_dict = update.dict()
-    del update_dict["last_update_date"]
-    api.update(update_dict)
-    api["last_update_date"] = get_timestamp()
-    api["last_update_user"] = username
-    
-    # Add activity log
-    add_activity_log(config, username, "UPDATE_API", "api", api_name, api_name)
-    
-    # Save
-    save_config(config)
+    updated_api = ConfigProvider.update_api(api_name, update.model_dump(), username)
     
     log(f"✅ API '{api_name}' updated by {username}")
-    return api
+    return updated_api.model_dump()
 
 @router.delete("/apis/{api_name}")
 async def delete_api(api_name: str, username: str = Depends(verify_token)):
     """Delete API (soft delete)"""
-    config = load_config()
-    
-    # Find API
-    api = next((a for a in config.get("apis", []) if a["name"] == api_name), None)
-    if not api:
-        raise HTTPException(status_code=404, detail="API not found")
-    
-    # Check if API is in use
-    for project in config.get("projects", []):
-        # Skip deleted projects
-        if project.get("deleted", False):
-            continue
-            
-        for version in project.get("versions", []):
-            # Skip deleted versions
-            if version.get("deleted", False):
-                continue
-            
-            # Check in intents
-            for intent in version.get("intents", []):
-                if intent.get("action") == api_name:
-                    raise HTTPException(status_code=400,
-                                      detail=f"API is used in intent '{intent.get('name', 'unknown')}' in project '{project['name']}' version {version.get('version_number', version.get('id'))}")
-    
-    # Soft delete
-    api["deleted"] = True
-    api["last_update_date"] = get_timestamp()
-    api["last_update_user"] = username
-    
-    # Add activity log
-    add_activity_log(config, username, "DELETE_API", "api", api_name, api_name)
-    
-    # Save
-    save_config(config)
+    ConfigProvider.delete_api(api_name, username)
     
     log(f"✅ API '{api_name}' deleted by {username}")
     return {"success": True}
@@ -1226,21 +716,23 @@ async def spark_startup(request: dict = Body(...), username: str = Depends(verif
     if not project_name:
         raise HTTPException(status_code=400, detail="project_name is required")
     
-    config = load_config()
-    
-    # Find project
-    project = next((p for p in config.get("projects", []) if p["name"] == project_name), None)
+    project = ConfigProvider.get_project_by_name(project_name)
     if not project:
         raise HTTPException(status_code=404, detail=f"Project not found: {project_name}")
     
     # Find published version
-    version = next((v for v in project.get("versions", []) if v.get("published", False)), None)
+    version = next((v for v in project.versions if v.published), None)
     if not version:
         raise HTTPException(status_code=400, detail=f"No published version found for project: {project_name}")
     
     # Notify Spark
     try:
-        result = await notify_spark_manual(project, version, config.get("config", {}))
+        cfg = ConfigProvider.get()
+        result = await notify_spark_manual(
+            project.model_dump(), 
+            version.model_dump(), 
+            cfg.global_config.model_dump()
+        )
         return {"message": result.get("message", "Spark startup initiated")}
     except Exception as e:
         log(f"❌ Spark startup failed: {e}")
@@ -1249,8 +741,8 @@ async def spark_startup(request: dict = Body(...), username: str = Depends(verif
 @router.get("/spark/projects")
 async def spark_get_projects(username: str = Depends(verify_token)):
     """Get Spark project list"""
-    config = load_config()
-    spark_endpoint = config.get("config", {}).get("spark_endpoint", "").rstrip("/")
+    cfg = ConfigProvider.get()
+    spark_endpoint = str(cfg.global_config.spark_endpoint).rstrip("/")
     spark_token = _get_spark_token()
     
     if not spark_endpoint:
@@ -1470,75 +962,10 @@ async def import_project(
     username: str = Depends(verify_token)
 ):
     """Import project from JSON"""
-    config = load_config()
-    
-    # Validate structure
-    if "name" not in project_data:
-        raise HTTPException(status_code=400, detail="Invalid project data")
-    
-    # Check duplicate name
-    existing = [p for p in config.get("projects", []) 
-               if p["name"] == project_data["name"] and not p.get("deleted", False)]
-    if existing:
-        raise HTTPException(status_code=400, detail="Project name already exists")
-    
-    # Get new project ID
-    project_id = config["config"].get("project_id_counter", 0) + 1
-    config["config"]["project_id_counter"] = project_id
-    
-    # Create new project
-    new_project = {
-        "id": project_id,
-        "name": project_data["name"],
-        "caption": project_data.get("caption", ""),
-        "icon": project_data.get("icon", "folder"),
-        "description": project_data.get("description", ""),
-        "enabled": False,
-        "deleted": False,
-        "created_date": get_timestamp(),
-        "created_by": username,
-        "last_update_date": get_timestamp(),
-        "last_update_user": username,
-        "version_id_counter": 1,
-        "versions": []
-    }
-    
-    # Import versions
-    for idx, version_data in enumerate(project_data.get("versions", [])):
-        new_version = {
-            "id": idx + 1,
-            "no": idx + 1,
-            "caption": version_data.get("caption", f"Version {idx + 1}"),
-            "description": version_data.get("description", ""),
-            "published": False,
-            "deleted": False,
-            "created_date": get_timestamp(),
-            "created_by": username,
-            "last_update_date": get_timestamp(),
-            "last_update_user": username,
-            "publish_date": None,
-            "published_by": None,
-            "general_prompt": version_data.get("general_prompt", ""),
-            "llm": version_data.get("llm", {}),
-            "intents": version_data.get("intents", []),
-            "parameters": version_data.get("parameters", [])
-        }
-        new_project["versions"].append(new_version)
-        new_project["version_id_counter"] = idx + 1
+    imported_project = ConfigProvider.import_project(project_data, username)
     
-    # Add to config
-    if "projects" not in config:
-        config["projects"] = []
-    config["projects"].append(new_project)
-    
-    # Add activity log
-    add_activity_log(config, username, "IMPORT_PROJECT", "project", project_id, new_project["name"])
-    
-    # Save
-    save_config(config)
-    
-    log(f"✅ Project '{new_project['name']}' imported by {username}")
-    return new_project
+    log(f"✅ Project '{imported_project.name}' imported by {username}")
+    return imported_project.model_dump()
 
 @router.get("/projects/{project_id}/export")
 async def export_project(
@@ -1546,40 +973,9 @@ async def export_project(
     username: str = Depends(verify_token)
 ):
     """Export project as JSON"""
-    config = load_config()
-    
-    # Find project
-    project = next((p for p in config.get("projects", []) if p["id"] == project_id), None)
-    if not project:
-        raise HTTPException(status_code=404, detail="Project not found")
-    
-    # Create export data
-    export_data = {
-        "name": project["name"],
-        "caption": project.get("caption", ""),
-        "icon": project.get("icon", "folder"),
-        "description": project.get("description", ""),
-        "versions": []
-    }
-    
-    # Export versions
-    for version in project.get("versions", []):
-        if not version.get("deleted", False):
-            export_version = {
-                "caption": version.get("caption", ""),
-                "description": version.get("description", ""),
-                "general_prompt": version.get("general_prompt", ""),
-                "llm": version.get("llm", {}),
-                "intents": version.get("intents", []),
-                "parameters": version.get("parameters", [])
-            }
-            export_data["versions"].append(export_version)
-    
-    # Add activity log
-    add_activity_log(config, username, "EXPORT_PROJECT", "project", project_id, project["name"])
-    save_config(config)
+    export_data = ConfigProvider.export_project(project_id, username)
     
-    log(f"✅ Project '{project['name']}' exported by {username}")
+    log(f"✅ Project exported by {username}")
     return export_data
 
 # ===================== TTS Endpoints =====================
@@ -1590,9 +986,8 @@ async def generate_tts(
 ):
     """Generate TTS audio from text"""
     try:
-        # ConfigProvider'dan reload ederek güncel config'i alalım
-        from config_provider import ConfigProvider
-        cfg = ConfigProvider.reload()
+        # ConfigProvider'dan güncel config'i al (reload yerine get kullan)
+        cfg = ConfigProvider.get()
         
         tts_engine = cfg.global_config.tts_engine
         log(f"🔧 TTS Engine: {tts_engine}")
@@ -1654,23 +1049,19 @@ async def get_activity_log(
     username: str = Depends(verify_token)
 ):
     """Get activity log"""
-    config = load_config()
-    logs = config.get("activity_log", [])
+    cfg = ConfigProvider.get()
+    logs = cfg.activity_log
     
-    # Return latest entries (format as paginated response if needed)
-    return logs[-limit:]
+    # Return latest entries
+    return [log.model_dump() for log in logs[-limit:]]
 
 # ===================== Cleanup Task =====================
 def cleanup_old_logs():
     """Cleanup old activity logs (runs in background)"""
     while True:
         try:
-            config = load_config()
-            if "activity_log" in config and len(config["activity_log"]) > 5000:
-                # Keep only last 1000 entries
-                config["activity_log"] = config["activity_log"][-1000:]
-                save_config(config)
-                log("🧹 Cleaned up old activity logs")
+            ConfigProvider.cleanup_activity_logs()
+            log("🧹 Cleaned up old activity logs")
         except Exception as e:
             log(f"Error in cleanup task: {e}")