Update config_provider.py

config_provider.py

@@ -1,848 +1,865 @@
-import { Component, Inject, OnInit } from '@angular/core';
-import { CommonModule } from '@angular/common';
-import { FormBuilder, FormGroup, Validators, ReactiveFormsModule, FormArray, FormsModule } from '@angular/forms';  
-import { MatDialogRef, MAT_DIALOG_DATA, MatDialogModule, MatDialog } from '@angular/material/dialog';
-import { MatTabsModule } from '@angular/material/tabs';
-import { MatFormFieldModule } from '@angular/material/form-field';
-import { MatInputModule } from '@angular/material/input';
-import { MatSelectModule } from '@angular/material/select';
-import { MatCheckboxModule } from '@angular/material/checkbox';
-import { MatButtonModule } from '@angular/material/button';
-import { MatIconModule } from '@angular/material/icon';
-import { MatSnackBar, MatSnackBarModule } from '@angular/material/snack-bar';
-import { MatTableModule } from '@angular/material/table';
-import { MatChipsModule } from '@angular/material/chips';
-import { MatExpansionModule } from '@angular/material/expansion';
-import { MatDividerModule } from '@angular/material/divider';
-import { MatProgressBarModule } from '@angular/material/progress-bar';
-import { MatListModule } from '@angular/material/list';
-import { MatProgressSpinnerModule } from '@angular/material/progress-spinner';
-import { MatBadgeModule } from '@angular/material/badge';
-import { ApiService, Project, Version } from '../../services/api.service';
-import { LocaleManagerService } from '../../services/locale-manager.service';
-import ConfirmDialogComponent from '../confirm-dialog/confirm-dialog.component';
-
-// Interfaces for multi-language support
-interface LocalizedExample {
-  locale_code: string;
-  example: string;
-}
-
-interface LocalizedCaption {
-  locale_code: string;
-  caption: string;
-}
-
-interface Locale {
-  code: string;
-  name: string;
-}
-
-@Component({
-  selector: 'app-version-edit-dialog',
-  standalone: true,
-  imports: [
-    CommonModule,
-    ReactiveFormsModule,
-    FormsModule,
-    MatDialogModule,
-    MatTabsModule,
-    MatFormFieldModule,
-    MatInputModule,
-    MatSelectModule,
-    MatCheckboxModule,
-    MatButtonModule,
-    MatIconModule,
-    MatSnackBarModule,
-    MatTableModule,
-    MatChipsModule,
-    MatExpansionModule,
-    MatDividerModule,
-    MatProgressBarModule,
-    MatListModule,
-    MatProgressSpinnerModule,
-    MatBadgeModule
-  ],
-  templateUrl: './version-edit-dialog.component.html',
-  styleUrls: ['./version-edit-dialog.component.scss']
-})
-export default class VersionEditDialogComponent implements OnInit {
-  project: Project;
-  versions: Version[] = [];
-  selectedVersion: Version | null = null;
-  versionForm!: FormGroup;
-  
-  loading = false;
-  saving = false;
-  publishing = false;
-  creating = false;
-  isDirty = false;
-  testing = false;
-  
-  selectedTabIndex = 0;
-  testUserMessage = '';
-  testResult: any = null;
-  
-  // Multi-language support
-  selectedExampleLocale: string = 'tr';
-  availableLocales: Locale[] = [];
-
-  constructor(
-    private fb: FormBuilder,
-    private apiService: ApiService,
-    private localeService: LocaleManagerService,
-    private snackBar: MatSnackBar,
-    private dialog: MatDialog,
-    public dialogRef: MatDialogRef<VersionEditDialogComponent>,
-    @Inject(MAT_DIALOG_DATA) public data: any
-  ) {
-    this.project = data.project;
-    this.versions = [...this.project.versions].sort((a, b) => b.no - a.no);
-    this.selectedExampleLocale = this.project.default_locale || 'tr';
-  }
-
-  ngOnInit() {
-    this.initializeForm();
-    this.loadAvailableLocales();
+"""
+Thread-Safe Configuration Provider for Flare Platform
+"""
+import threading
+import os
+import json
+import commentjson
+from typing import Optional, Dict, List, Any
+from datetime import datetime
+from pathlib import Path
+import tempfile
+import shutil
+from utils import get_current_timestamp, normalize_timestamp, timestamps_equal
+
+from config_models import (
+    ServiceConfig, GlobalConfig, ProjectConfig, VersionConfig, 
+    IntentConfig, APIConfig, ActivityLogEntry, ParameterConfig,
+    LLMConfiguration, GenerationConfig
+)
+from logger import log_info, log_error, log_warning, log_debug, LogTimer
+from exceptions import (
+    RaceConditionError, ConfigurationError, ResourceNotFoundError,
+    DuplicateResourceError, ValidationError
+)
+from encryption_utils import encrypt, decrypt
+
+class ConfigProvider:
+    """Thread-safe singleton configuration provider"""
     
-    // Select the latest unpublished version or the latest version
-    const unpublished = this.versions.find(v => !v.published);
-    this.selectedVersion = unpublished || this.versions[0] || null;
+    _instance: Optional[ServiceConfig] = None
+    _lock = threading.RLock()  # Reentrant lock for nested calls
+    _file_lock = threading.Lock()  # Separate lock for file operations
+    _CONFIG_PATH = Path(__file__).parent / "service_config.jsonc"
+
+    @staticmethod
+    def _normalize_date(date_str: Optional[str]) -> str:
+        """Normalize date string for comparison"""
+        if not date_str:
+            return ""
+        return date_str.replace(' ', 'T').replace('+00:00', 'Z').replace('.000Z', 'Z')
+
+    @classmethod
+    def get(cls) -> ServiceConfig:
+        """Get cached configuration - thread-safe"""
+        if cls._instance is None:
+            with cls._lock:
+                # Double-checked locking pattern
+                if cls._instance is None:
+                    with LogTimer("config_load"):
+                        cls._instance = cls._load()
+                        cls._instance.build_index()
+                        log_info("Configuration loaded successfully")
+        return cls._instance
     
-    if (this.selectedVersion) {
-      this.loadVersion(this.selectedVersion);
-    }
-
-    this.versionForm.valueChanges.subscribe(() => {
-      this.isDirty = true;
-    });
-  }
-
-  initializeForm() {
-    this.versionForm = this.fb.group({
-      no: [{value: '', disabled: true}],
-      caption: ['', Validators.required],
-      published: [{value: false, disabled: true}],
-      general_prompt: ['', Validators.required],
-      welcome_prompt: [''],  // Added welcome_prompt field
-      llm: this.fb.group({
-        repo_id: ['', Validators.required],
-        generation_config: this.fb.group({
-          max_new_tokens: [256, [Validators.required, Validators.min(1), Validators.max(2048)]],
-          temperature: [0.2, [Validators.required, Validators.min(0), Validators.max(2)]],
-          top_p: [0.8, [Validators.required, Validators.min(0), Validators.max(1)]],
-          repetition_penalty: [1.1, [Validators.required, Validators.min(1), Validators.max(2)]]
-        }),
-        use_fine_tune: [false],
-        fine_tune_zip: ['']
-      }),
-      intents: this.fb.array([]),
-      last_update_date: ['']
-    });
-
-    // Watch for fine-tune toggle
-    this.versionForm.get('llm.use_fine_tune')?.valueChanges.subscribe(useFineTune => {
-      const fineTuneControl = this.versionForm.get('llm.fine_tune_zip');
-      if (useFineTune) {
-        fineTuneControl?.setValidators([Validators.required]);
-      } else {
-        fineTuneControl?.clearValidators();
-        fineTuneControl?.setValue('');
-      }
-      fineTuneControl?.updateValueAndValidity();
-    });
-  }
-
-  async loadAvailableLocales() {
-    // Get supported locales from project
-    const supportedCodes = [
-      this.project.default_locale,
-      ...(this.project.supported_locales || [])
-    ].filter(Boolean);
-
-    // Get locale details
-    for (const code of supportedCodes) {
-      if (!code) continue; // Skip undefined/null values
-      
-      try {
-        const localeInfo = await this.localeService.getLocaleDetails(code).toPromise();
-        if (localeInfo) {
-          this.availableLocales.push({
-            code: localeInfo.code,
-            name: localeInfo.name
-          });
-        }
-      } catch (error) {
-        // Use fallback for known locales
-        const fallbackNames: { [key: string]: string } = {
-          'tr': 'Türkçe',
-          'en': 'English',
-          'de': 'Deutsch',
-          'fr': 'Français',
-          'es': 'Español'
-        };
-        if (code && fallbackNames[code]) {
-          this.availableLocales.push({
-            code: code,
-            name: fallbackNames[code]
-          });
-        }
-      }
-    }
-  }
-
-  getAvailableLocales(): Locale[] {
-    return this.availableLocales;
-  }
-
-  getLocaleName(localeCode: string): string {
-    const locale = this.availableLocales.find(l => l.code === localeCode);
-    return locale?.name || localeCode;
-  }
-
-  loadVersion(version: Version) {
-    this.selectedVersion = version;
+    @classmethod
+    def reload(cls) -> ServiceConfig:
+        """Force reload configuration from file"""
+        with cls._lock:
+            log_info("Reloading configuration...")
+            cls._instance = None
+            return cls.get()
     
-    // Form değerlerini set et
-    this.versionForm.patchValue({
-      no: version.no,
-      caption: version.caption || '',
-      published: version.published || false,
-      general_prompt: (version as any).general_prompt || '',
-      welcome_prompt: (version as any).welcome_prompt || '',  // Added welcome_prompt
-      last_update_date: version.last_update_date || ''
-    });
-  
-    // LLM config'i ayrı set et
-    if ((version as any).llm) {
-      this.versionForm.patchValue({
-        llm: {
-          repo_id: (version as any).llm.repo_id || '',
-          generation_config: (version as any).llm.generation_config || {
-            max_new_tokens: 512,
-            temperature: 0.7,
-            top_p: 0.95,
-            repetition_penalty: 1.1
-          },
-          use_fine_tune: (version as any).llm.use_fine_tune || false,
-          fine_tune_zip: (version as any).llm.fine_tune_zip || ''
-        }
-      });
-    }
-  
-    // Clear and rebuild intents
-    this.intents.clear();
-    ((version as any).intents || []).forEach((intent: any) => {
-      this.intents.push(this.createIntentFormGroup(intent));
-    });
-
-    this.isDirty = false;
-  }
-  
-  async loadVersions() {
-    this.loading = true;
-    try {
-      const project = await this.apiService.getProject(this.project.id).toPromise();
-      if (project) {
-        this.project = project;
-        this.versions = [...project.versions].sort((a, b) => b.no - a.no);
+    @classmethod
+    def _load(cls) -> ServiceConfig:
+        """Load configuration from file"""
+        try:
+            if not cls._CONFIG_PATH.exists():
+                raise ConfigurationError(
+                    f"Config file not found: {cls._CONFIG_PATH}",
+                    config_key="service_config.jsonc"
+                )
+            
+            with open(cls._CONFIG_PATH, 'r', encoding='utf-8') as f:
+                config_data = commentjson.load(f)
+            
+            # Debug: İlk project'in tarihini kontrol et
+            if 'projects' in config_data and len(config_data['projects']) > 0:
+                first_project = config_data['projects'][0]
+                log_debug(f"🔍 Raw project data - last_update_date: {first_project.get('last_update_date')}")
+            
+            # Ensure required fields
+            if 'config' not in config_data:
+                config_data['config'] = {}
+            
+            # Parse API configs (handle JSON strings)
+            if 'apis' in config_data:
+                cls._parse_api_configs(config_data['apis'])
+            
+            # Validate and create model
+            cfg = ServiceConfig.model_validate(config_data)
+            
+            # Debug: Model'e dönüştükten sonra kontrol et
+            if cfg.projects and len(cfg.projects) > 0:
+                log_debug(f"🔍 Parsed project - last_update_date: {cfg.projects[0].last_update_date}")
+                log_debug(f"🔍 Type: {type(cfg.projects[0].last_update_date)}")
+            
+            log_debug(
+                "Configuration loaded",
+                projects=len(cfg.projects),
+                apis=len(cfg.apis),
+                users=len(cfg.global_config.users)
+            )
+            
+            return cfg
         
-        // Re-select current version if it still exists
-        if (this.selectedVersion) {
-          const currentVersion = this.versions.find(v => v.no === this.selectedVersion!.no);
-          if (currentVersion) {
-            this.loadVersion(currentVersion);
-          } else if (this.versions.length > 0) {
-            this.loadVersion(this.versions[0]);
-          }
-        } else if (this.versions.length > 0) {
-          this.loadVersion(this.versions[0]);
-        }
-      }
-    } catch (error) {
-      this.snackBar.open('Failed to reload versions', 'Close', { duration: 3000 });
-    } finally {
-      this.loading = false;
-    }
-  }
-
-  createIntentFormGroup(intent: any = {}): FormGroup {
-    const group = this.fb.group({
-      name: [intent.name || '', [Validators.required, Validators.pattern(/^[a-zA-Z0-9-]+$/)]],
-      caption: [intent.caption || ''],
-      detection_prompt: [intent.detection_prompt || '', Validators.required],
-      examples: [intent.examples || []], // Store as array, not FormArray
-      parameters: this.fb.array([]),
-      action: [intent.action || '', Validators.required],
-      fallback_timeout_prompt: [intent.fallback_timeout_prompt || ''],
-      fallback_error_prompt: [intent.fallback_error_prompt || '']
-    });
-  
-    // Parameters'ı ayrı olarak ekle
-    if (intent.parameters && Array.isArray(intent.parameters)) {
-      const parametersArray = group.get('parameters') as FormArray;
-      intent.parameters.forEach((param: any) => {
-        parametersArray.push(this.createParameterFormGroup(param));
-      });
-    }
-  
-    return group;
-  }
-
-  createParameterFormGroup(param: any = {}): FormGroup {
-    return this.fb.group({
-      name: [param.name || '', [Validators.required, Validators.pattern(/^[a-zA-Z0-9_]+$/)]],
-      caption: [param.caption || []],
-      type: [param.type || 'str', Validators.required],
-      required: [param.required !== false],
-      variable_name: [param.variable_name || '', Validators.required],
-      extraction_prompt: [param.extraction_prompt || ''],
-      validation_regex: [param.validation_regex || ''],
-      invalid_prompt: [param.invalid_prompt || ''],
-      type_error_prompt: [param.type_error_prompt || '']
-    });
-  }
-
-  get intents() {
-    return this.versionForm.get('intents') as FormArray;
-  }
-
-  getIntentParameters(intentIndex: number): FormArray {
-    return this.intents.at(intentIndex).get('parameters') as FormArray;
-  }
-
-  // LocalizedExample support methods
-  getLocalizedExamples(examples: any[], locale: string): LocalizedExample[] {
-    if (!examples || !Array.isArray(examples)) return [];
+        except Exception as e:
+            log_error(f"Error loading config", error=str(e), path=str(cls._CONFIG_PATH))
+            raise ConfigurationError(f"Failed to load configuration: {e}")
     
-    // Check if examples are in new format
-    if (examples.length > 0 && typeof examples[0] === 'object' && 'locale_code' in examples[0]) {
-      return examples.filter(ex => ex.locale_code === locale);
-    }
+    @classmethod
+    def _parse_api_configs(cls, apis: List[Dict[str, Any]]) -> None:
+        """Parse JSON string fields in API configs"""
+        for api in apis:
+            # Parse headers
+            if 'headers' in api and isinstance(api['headers'], str):
+                try:
+                    api['headers'] = json.loads(api['headers'])
+                except json.JSONDecodeError:
+                    api['headers'] = {}
+            
+            # Parse body_template
+            if 'body_template' in api and isinstance(api['body_template'], str):
+                try:
+                    api['body_template'] = json.loads(api['body_template'])
+                except json.JSONDecodeError:
+                    api['body_template'] = {}
+            
+            # Parse auth configs
+            if 'auth' in api and api['auth']:
+                cls._parse_auth_config(api['auth'])
     
-    // Old format - convert to new
-    if (typeof examples[0] === 'string') {
-      return examples.map(ex => ({ locale_code: locale, example: ex }));
-    }
+    @classmethod
+    def _parse_auth_config(cls, auth: Dict[str, Any]) -> None:
+        """Parse auth configuration"""
+        # Parse token_request_body
+        if 'token_request_body' in auth and isinstance(auth['token_request_body'], str):
+            try:
+                auth['token_request_body'] = json.loads(auth['token_request_body'])
+            except json.JSONDecodeError:
+                auth['token_request_body'] = {}
+        
+        # Parse token_refresh_body
+        if 'token_refresh_body' in auth and isinstance(auth['token_refresh_body'], str):
+            try:
+                auth['token_refresh_body'] = json.loads(auth['token_refresh_body'])
+            except json.JSONDecodeError:
+                auth['token_refresh_body'] = {}
     
-    return [];
-  }
-
-  getParameterCaptionDisplay(captions: LocalizedCaption[]): string {
-    if (!captions || !Array.isArray(captions) || captions.length === 0) {
-      return '(No caption)';
-    }
+    @classmethod
+    def save(cls, config: ServiceConfig, username: str) -> None:
+        """Thread-safe configuration save with optimistic locking"""
+        with cls._file_lock:
+            try:
+                # Load current config for race condition check
+                try:
+                    current_config = cls._load()
+                    
+                    # Check for race condition
+                    if config.last_update_date and current_config.last_update_date:
+                        if not timestamps_equal(config.last_update_date, current_config.last_update_date):
+                            raise RaceConditionError(
+                                "Configuration was modified by another user",
+                                current_user=username,
+                                last_update_user=current_config.last_update_user,
+                                last_update_date=current_config.last_update_date,
+                                entity_type="configuration"
+                            )
+                except ConfigurationError as e:
+                    # Eğer mevcut config yüklenemiyorsa, race condition kontrolünü atla
+                    log_warning(f"Could not load current config for race condition check: {e}")
+                    current_config = None
+                
+                # Update metadata
+                config.last_update_date = get_current_timestamp()
+                config.last_update_user = username
+                
+                # Convert to JSON - Pydantic v2 kullanımı
+                data = config.model_dump(mode='json')
+                json_str = json.dumps(data, ensure_ascii=False, indent=2)
+                
+                # Backup current file if exists
+                backup_path = None
+                if cls._CONFIG_PATH.exists():
+                    backup_path = cls._CONFIG_PATH.with_suffix('.backup')
+                    shutil.copy2(str(cls._CONFIG_PATH), str(backup_path))
+                    log_debug(f"Created backup at {backup_path}")
+                
+                try:
+                    # Write to temporary file first
+                    temp_path = cls._CONFIG_PATH.with_suffix('.tmp')
+                    with open(temp_path, 'w', encoding='utf-8') as f:
+                        f.write(json_str)
+                    
+                    # Validate the temp file by trying to load it
+                    with open(temp_path, 'r', encoding='utf-8') as f:
+                        test_data = commentjson.load(f)
+                        ServiceConfig.model_validate(test_data)
+                    
+                    # If validation passes, replace the original
+                    shutil.move(str(temp_path), str(cls._CONFIG_PATH))
+                    
+                    # Delete backup if save successful
+                    if backup_path and backup_path.exists():
+                        backup_path.unlink()
+                        
+                except Exception as e:
+                    # Restore from backup if something went wrong
+                    if backup_path and backup_path.exists():
+                        shutil.move(str(backup_path), str(cls._CONFIG_PATH))
+                        log_error(f"Restored configuration from backup due to error: {e}")
+                    raise
+                
+                # Update cached instance
+                with cls._lock:
+                    cls._instance = config
+                
+                log_info(
+                    "Configuration saved successfully",
+                    user=username,
+                    last_update=config.last_update_date
+                )
+                
+            except Exception as e:
+                log_error("Failed to save configuration", error=str(e), user=username)
+                raise
     
-    // Try to find caption for selected locale
-    const selectedCaption = captions.find(c => c.locale_code === this.selectedExampleLocale);
-    if (selectedCaption) return selectedCaption.caption;
+    # ===================== Environment Methods =====================
     
-    // Try default locale
-    const defaultCaption = captions.find(c => c.locale_code === this.project.default_locale);
-    if (defaultCaption) return defaultCaption.caption;
+    @classmethod
+    def update_environment(cls, update_data: dict, username: str) -> None:
+        """Update environment configuration"""
+        with cls._lock:
+            config = cls.get()
+            
+            # Update providers
+            if 'llm_provider' in update_data:
+                config.global_config.llm_provider = update_data['llm_provider']
+            
+            if 'tts_provider' in update_data:
+                config.global_config.tts_provider = update_data['tts_provider']
+            
+            if 'stt_provider' in update_data:
+                config.global_config.stt_provider = update_data['stt_provider']
+            
+            # Log activity
+            cls._add_activity(
+                config, username, "UPDATE_ENVIRONMENT",
+                "environment", None, None,
+                f"Updated providers"
+            )
+            
+            # Save
+            cls.save(config, username)
     
-    // Return first available caption
-    return captions[0].caption;
-  }
-
-  addLocalizedExample(intentIndex: number, example: string) {
-    if (!example.trim()) return;
+    # ===================== Project Methods =====================
     
-    const intent = this.intents.at(intentIndex);
-    const currentExamples = intent.get('examples')?.value || [];
+    @classmethod
+    def get_project(cls, project_id: int) -> Optional[ProjectConfig]:
+        """Get project by ID"""
+        config = cls.get()
+        return next((p for p in config.projects if p.id == project_id), None)
     
-    // Check if already exists
-    const exists = currentExamples.some((ex: any) => 
-      ex.locale_code === this.selectedExampleLocale && ex.example === example.trim()
-    );
+    @classmethod
+    def create_project(cls, project_data: dict, username: str) -> ProjectConfig:
+        """Create new project with initial version"""
+        with cls._lock:
+            config = cls.get()
+            
+            # Check for duplicate name
+            if any(p.name == project_data['name'] for p in config.projects):
+                raise DuplicateResourceError("project", project_data['name'])
+            
+            # Create project
+            project = ProjectConfig(
+                id=config.project_id_counter,
+                created_date=get_current_timestamp(),
+                created_by=username,
+                version_id_counter=1,  # Başlangıç değeri
+                versions=[],  # Boş başla
+                **project_data
+            )
+            
+            # Create initial version with proper models
+            initial_version = VersionConfig(
+                no=1,
+                caption="Initial version",
+                description="Auto-generated initial version",
+                published=False,  # Explicitly set to False
+                deleted=False,
+                general_prompt="You are a helpful assistant.",
+                welcome_prompt=None,
+                llm=LLMConfiguration(
+                    repo_id="ytu-ce-cosmos/Turkish-Llama-8b-Instruct-v0.1",
+                    generation_config=GenerationConfig(
+                        max_new_tokens=512,
+                        temperature=0.7,
+                        top_p=0.9,
+                        repetition_penalty=1.1,
+                        do_sample=True
+                    ),
+                    use_fine_tune=False,
+                    fine_tune_zip=""
+                ),
+                intents=[],
+                created_date=get_current_timestamp(),
+                created_by=username,
+                last_update_date=None,
+                last_update_user=None,
+                publish_date=None,
+                published_by=None   
+            )
+            
+            # Add initial version to project
+            project.versions.append(initial_version)
+            project.version_id_counter = 2  # Next version will be 2
+            
+            # Update config
+            config.projects.append(project)
+            config.project_id_counter += 1
+            
+            # Log activity
+            cls._add_activity(
+                config, username, "CREATE_PROJECT",
+                "project", project.id, project.name,
+                f"Created with initial version"
+            )
+            
+            # Save
+            cls.save(config, username)
+            
+            log_info(
+                "Project created with initial version",
+                project_id=project.id,
+                name=project.name,
+                user=username
+            )
+            
+            return project
+        
+    @classmethod
+    def update_project(cls, project_id: int, update_data: dict, username: str, expected_last_update: Optional[str] = None) -> ProjectConfig:
+        """Update project with optimistic locking"""
+        with cls._lock:
+            config = cls.get()
+            project = cls.get_project(project_id)
+            
+            if not project:
+                raise ResourceNotFoundError("project", project_id)
+            
+            # Check race condition
+            if expected_last_update is not None and expected_last_update != '':
+                if project.last_update_date and not timestamps_equal(expected_last_update, project.last_update_date):
+                    raise RaceConditionError(
+                        f"Project '{project.name}' was modified by another user",
+                        current_user=username,
+                        last_update_user=project.last_update_user,
+                        last_update_date=project.last_update_date,
+                        entity_type="project",
+                        entity_id=project_id
+                    )
+            
+            # Update fields
+            for key, value in update_data.items():
+                if hasattr(project, key) and key not in ['id', 'created_date', 'created_by', 'last_update_date', 'last_update_user']:
+                    setattr(project, key, value)
+            
+            project.last_update_date = get_current_timestamp()
+            project.last_update_user = username
+            
+            # Log activity
+            cls._add_activity(
+                config, username, "UPDATE_PROJECT",
+                "project", project.id, project.name
+            )
+            
+            # Save
+            cls.save(config, username)
+            
+            log_info(
+                "Project updated",
+                project_id=project.id,
+                user=username
+            )
+            
+            return project
     
-    if (!exists) {
-      const newExamples = [...currentExamples, {
-        locale_code: this.selectedExampleLocale,
-        example: example.trim()
-      }];
-      intent.patchValue({ examples: newExamples });
-      this.isDirty = true;
-    }
-  }
-
-  removeLocalizedExample(intentIndex: number, exampleToRemove: LocalizedExample) {
-    const intent = this.intents.at(intentIndex);
-    const currentExamples = intent.get('examples')?.value || [];
+    @classmethod
+    def delete_project(cls, project_id: int, username: str) -> None:
+        """Soft delete project"""
+        with cls._lock:
+            config = cls.get()
+            project = cls.get_project(project_id)
+            
+            if not project:
+                raise ResourceNotFoundError("project", project_id)
+            
+            project.deleted = True
+            project.last_update_date = get_current_timestamp()
+            project.last_update_user = username
+            
+            # Log activity
+            cls._add_activity(
+                config, username, "DELETE_PROJECT",
+                "project", project.id, project.name
+            )
+            
+            # Save
+            cls.save(config, username)
+            
+            log_info(
+                "Project deleted",
+                project_id=project.id,
+                user=username
+            )
     
-    const newExamples = currentExamples.filter((ex: any) => 
-      !(ex.locale_code === exampleToRemove.locale_code && ex.example === exampleToRemove.example)
-    );
+    @classmethod
+    def toggle_project(cls, project_id: int, username: str) -> bool:
+        """Toggle project enabled status"""
+        with cls._lock:
+            config = cls.get()
+            project = cls.get_project(project_id)
+            
+            if not project:
+                raise ResourceNotFoundError("project", project_id)
+            
+            project.enabled = not project.enabled
+            project.last_update_date = get_current_timestamp()
+            project.last_update_user = username
+            
+            # Log activity
+            cls._add_activity(
+                config, username, "TOGGLE_PROJECT",
+                "project", project.id, project.name,
+                f"{'Enabled' if project.enabled else 'Disabled'}"
+            )
+            
+            # Save
+            cls.save(config, username)
+            
+            log_info(
+                "Project toggled",
+                project_id=project.id,
+                enabled=project.enabled,
+                user=username
+            )
+            
+            return project.enabled
     
-    intent.patchValue({ examples: newExamples });
-    this.isDirty = true;
-  }
-
-  addParameter(intentIndex: number) {
-    const parameters = this.getIntentParameters(intentIndex);
-    parameters.push(this.createParameterFormGroup());
-    this.isDirty = true;
-  }
-
-  removeParameter(intentIndex: number, paramIndex: number) {
-    const parameters = this.getIntentParameters(intentIndex);
-    parameters.removeAt(paramIndex);
-    this.isDirty = true;
-  }
-
-  // Check if version can be edited
-  get canEdit(): boolean {
-    return !this.selectedVersion?.published;
-  }
-
-  addIntent() {
-    this.intents.push(this.createIntentFormGroup());
-    this.isDirty = true;
-  }
-
-  removeIntent(index: number) {
-    const intent = this.intents.at(index).value;
-    const dialogRef = this.dialog.open(ConfirmDialogComponent, {
-      width: '400px',
-      data: {
-        title: 'Delete Intent',
-        message: `Are you sure you want to delete intent "${intent.name}"?`,
-        confirmText: 'Delete',
-        confirmColor: 'warn'
-      }
-    });
-
-    dialogRef.afterClosed().subscribe(confirmed => {
-      if (confirmed) {
-        this.intents.removeAt(index);
-        this.isDirty = true;
-      }
-    });
-  }
-
-  async editIntent(intentIndex: number) {
-    const { default: IntentEditDialogComponent } = await import('../intent-edit-dialog/intent-edit-dialog.component');
+    # ===================== Version Methods =====================
     
-    const intent = this.intents.at(intentIndex);
-    const currentValue = intent.value;
+    @classmethod
+    def create_version(cls, project_id: int, version_data: dict, username: str) -> VersionConfig:
+        """Create new version"""
+        with cls._lock:
+            config = cls.get()
+            project = cls.get_project(project_id)
+            
+            if not project:
+                raise ResourceNotFoundError("project", project_id)
+            
+            # Handle source version copy
+            if 'source_version_no' in version_data and version_data['source_version_no']:
+                source_version = next((v for v in project.versions if v.no == version_data['source_version_no']), None)
+                if source_version:
+                    # Copy from source version
+                    version_dict = source_version.model_dump()
+                    # Remove fields that shouldn't be copied
+                    for field in ['no', 'created_date', 'created_by', 'published', 'publish_date', 
+                                  'published_by', 'last_update_date', 'last_update_user']:
+                        version_dict.pop(field, None)
+                    # Override with provided data
+                    version_dict['caption'] = version_data.get('caption', f"Copy of {source_version.caption}")
+                else:
+                    # Source not found, create blank
+                    version_dict = {
+                        'caption': version_data.get('caption', 'New Version'),
+                        'general_prompt': '',
+                        'welcome_prompt': None,
+                        'llm': {
+                            'repo_id': '',
+                            'generation_config': {
+                                'max_new_tokens': 512,
+                                'temperature': 0.7,
+                                'top_p': 0.95,
+                                'repetition_penalty': 1.1
+                            },
+                            'use_fine_tune': False,
+                            'fine_tune_zip': ''
+                        },
+                        'intents': []
+                    }
+            else:
+                # Create blank version
+                version_dict = {
+                    'caption': version_data.get('caption', 'New Version'),
+                    'general_prompt': '',
+                    'welcome_prompt': None,
+                    'llm': {
+                        'repo_id': '',
+                        'generation_config': {
+                            'max_new_tokens': 512,
+                            'temperature': 0.7,
+                            'top_p': 0.95,
+                            'repetition_penalty': 1.1
+                        },
+                        'use_fine_tune': False,
+                        'fine_tune_zip': ''
+                    },
+                    'intents': []
+                }
+            
+            # Create version
+            version = VersionConfig(
+                no=project.version_id_counter,
+                published=False,  # New versions are always unpublished
+                deleted=False,
+                created_date=get_current_timestamp(),
+                created_by=username,
+                last_update_date=None,
+                last_update_user=None,
+                publish_date=None,
+                published_by=None,
+                **version_dict
+            )
+            
+            # Update project
+            project.versions.append(version)
+            project.version_id_counter += 1
+            project.last_update_date = get_current_timestamp()
+            project.last_update_user = username
+            
+            # Log activity
+            cls._add_activity(
+                config, username, "CREATE_VERSION",
+                "version", version.no, f"{project.name} v{version.no}",
+                f"Project: {project.name}"
+            )
+            
+            # Save
+            cls.save(config, username)
+            
+            log_info(
+                "Version created",
+                project_id=project.id,
+                version_no=version.no,
+                user=username
+            )
+            
+            return version
     
-    // Intent verilerini dialog'a gönder
-    const dialogRef = this.dialog.open(IntentEditDialogComponent, {
-      width: '90vw',
-      maxWidth: '1000px',
-      data: { 
-        intent: {
-          ...currentValue,
-          examples: currentValue.examples || [],
-          parameters: currentValue.parameters || []
-        },
-        project: this.project,
-        apis: await this.getAvailableAPIs()
-      }
-    });
-  
-    dialogRef.afterClosed().subscribe(result => {
-      if (result) {
-        // Update intent with result
-        intent.patchValue({
-          name: result.name,
-          caption: result.caption,
-          detection_prompt: result.detection_prompt,
-          examples: result.examples || [],
-          action: result.action,
-          fallback_timeout_prompt: result.fallback_timeout_prompt,
-          fallback_error_prompt: result.fallback_error_prompt
-        });
-  
-        // Update parameters
-        const parametersArray = intent.get('parameters') as FormArray;
-        parametersArray.clear();
-        (result.parameters || []).forEach((param: any) => {
-          parametersArray.push(this.createParameterFormGroup(param));
-        });
-        
-        this.isDirty = true;
-      }
-    });
-  }
-
-  async getAvailableAPIs(): Promise<any[]> {
-    try {
-      return await this.apiService.getAPIs().toPromise() || [];
-    } catch {
-      return [];
-    }
-  }
-
-  async createVersion() {
-    const publishedVersions = this.versions.filter(v => v.published);
+    @classmethod
+    def publish_version(cls, project_id: int, version_no: int, username: str) -> tuple[ProjectConfig, VersionConfig]:
+        """Publish a version"""
+        with cls._lock:
+            config = cls.get()
+            project = cls.get_project(project_id)
+            
+            if not project:
+                raise ResourceNotFoundError("project", project_id)
+            
+            version = next((v for v in project.versions if v.no == version_no), None)
+            if not version:
+                raise ResourceNotFoundError("version", version_no)
+            
+            # Unpublish other versions
+            for v in project.versions:
+                if v.published and v.no != version_no:
+                    v.published = False
+            
+            # Publish this version
+            version.published = True
+            version.publish_date = get_current_timestamp()
+            version.published_by = username
+            
+            # Update project
+            project.last_update_date = get_current_timestamp()
+            project.last_update_user = username
+            
+            # Log activity
+            cls._add_activity(
+                config, username, "PUBLISH_VERSION",
+                "version", version.no, f"{project.name} v{version.no}",
+                f"Published version {version.no}"
+            )
+            
+            # Save
+            cls.save(config, username)
+            
+            log_info(
+                "Version published",
+                project_id=project.id,
+                version_no=version.no,
+                user=username
+            )
+            
+            return project, version
+
+    @classmethod
+    def update_version(cls, project_id: int, version_no: int, update_data: dict, username: str, expected_last_update: Optional[str] = None) -> VersionConfig:
+        """Update version with optimistic locking"""
+        with cls._lock:
+            config = cls.get()
+            project = cls.get_project(project_id)
+            
+            if not project:
+                raise ResourceNotFoundError("project", project_id)
+            
+            version = next((v for v in project.versions if v.no == version_no), None)
+            if not version:
+                raise ResourceNotFoundError("version", version_no)
+            
+            # Debug: Log version published status
+            log_debug(f"🔍 Updating version {version_no} - published: {version.published}, type: {type(version.published)}")
+            
+            # Ensure published is a boolean (safety check)
+            if version.published is None:
+                version.published = False
+            
+            # Published versions cannot be edited
+            if version.published:
+                raise ValidationError("Published versions cannot be modified")
+            
+            # Check race condition
+            if expected_last_update is not None and expected_last_update != '':
+                if version.last_update_date and not timestamps_equal(expected_last_update, version.last_update_date):
+                    raise RaceConditionError(
+                        f"Version '{version.no}' was modified by another user",
+                        current_user=username,
+                        last_update_user=version.last_update_user,
+                        last_update_date=version.last_update_date,
+                        entity_type="version",
+                        entity_id=f"{project_id}:{version_no}"
+                    )                
+            
+            # Update fields
+            for key, value in update_data.items():
+                if hasattr(version, key) and key not in ['no', 'created_date', 'created_by', 'published', 'last_update_date']:
+                    setattr(version, key, value)
+            
+            version.last_update_date = get_current_timestamp()
+            version.last_update_user = username
+            
+            # Update project last update
+            project.last_update_date = get_current_timestamp()
+            project.last_update_user = username
+            
+            # Log activity
+            cls._add_activity(
+                config, username, "UPDATE_VERSION",
+                "version", f"{project.id}:{version.no}", f"{project.name} v{version.no}"
+            )
+            
+            # Save
+            cls.save(config, username)
+            
+            log_info(
+                "Version updated",
+                project_id=project.id,
+                version_no=version.no,
+                user=username
+            )
+            
+            return version
     
-    const dialogRef = this.dialog.open(ConfirmDialogComponent, {
-      width: '500px',
-      data: {
-        title: 'Create New Version',
-        message: 'Which published version would you like to use as a base for the new version?',
-        showDropdown: true,
-        dropdownOptions: publishedVersions.map(v => ({
-          value: v.no,
-          label: `Version ${v.no} - ${v.caption || 'No description'}`
-        })),
-        dropdownPlaceholder: 'Select published version (or leave empty for blank)',
-        confirmText: 'Create',
-        cancelText: 'Cancel'
-      }
-    });
-  
-    dialogRef.afterClosed().subscribe(async (result) => {
-      if (result?.confirmed) {
-        this.creating = true;
-        try {
-          let newVersionData;
-          
-          if (result.selectedValue) {
-            // Copy from selected version - we need to get the full version data
-            const sourceVersion = this.versions.find(v => v.no === result.selectedValue);
-            if (sourceVersion) {
-              // Load the full version data from the current form if it's the selected version
-              if (sourceVersion.no === this.selectedVersion?.no) {
-                const formValue = this.versionForm.getRawValue();
-                newVersionData = {
-                  ...formValue,
-                  no: undefined,
-                  published: false,
-                  last_update_date: undefined,
-                  caption: `Copy of ${sourceVersion.caption || `version ${sourceVersion.no}`}`
-                };
-              } else {
-                // For other versions, we only have basic info, so create minimal copy
-                newVersionData = {
-                  caption: `Copy of ${sourceVersion.caption || `version ${sourceVersion.no}`}`,
-                  general_prompt: '',
-                  llm: {
-                    repo_id: '',
-                    generation_config: {
-                      max_new_tokens: 512,
-                      temperature: 0.7,
-                      top_p: 0.95,
-                      repetition_penalty: 1.1
-                    },
-                    use_fine_tune: false,
-                    fine_tune_zip: ''
-                  },
-                  intents: []
-                };
-              }
-            }
-          } else {
-            // Create blank version
-            newVersionData = {
-              caption: `Version ${this.versions.length + 1}`,
-              general_prompt: '',
-              llm: {
-                repo_id: '',
-                generation_config: {
-                  max_new_tokens: 512,
-                  temperature: 0.7,
-                  top_p: 0.95,
-                  repetition_penalty: 1.1
-                },
-                use_fine_tune: false,
-                fine_tune_zip: ''
-              },
-              intents: []
-            };
-          }
-  
-          if (newVersionData) {
-            await this.apiService.createVersion(this.project.id, newVersionData).toPromise();
-            await this.loadVersions();
-            this.snackBar.open('Version created successfully!', 'Close', { duration: 3000 });
-          }
-        } catch (error) {
-          this.snackBar.open('Failed to create version', 'Close', { duration: 3000 });
-        } finally {
-          this.creating = false;
-        }
-      }
-    });
-  }
-
-  async saveVersion() {
-    if (!this.selectedVersion || !this.canEdit) {
-      this.snackBar.open('Cannot save published version', 'Close', { duration: 3000 });
-      return;
-    }
+    @classmethod
+    def delete_version(cls, project_id: int, version_no: int, username: str) -> None:
+        """Soft delete version"""
+        with cls._lock:
+            config = cls.get()
+            project = cls.get_project(project_id)
+            
+            if not project:
+                raise ResourceNotFoundError("project", project_id)
+            
+            version = next((v for v in project.versions if v.no == version_no), None)
+            if not version:
+                raise ResourceNotFoundError("version", version_no)
+            
+            if version.published:
+                raise ValidationError("Cannot delete published version")
+            
+            version.deleted = True
+            version.last_update_date = get_current_timestamp()
+            version.last_update_user = username
+            
+            # Update project
+            project.last_update_date = get_current_timestamp()
+            project.last_update_user = username
+            
+            # Log activity
+            cls._add_activity(
+                config, username, "DELETE_VERSION",
+                "version", f"{project.id}:{version.no}", f"{project.name} v{version.no}"
+            )
+            
+            # Save
+            cls.save(config, username)
+            
+            log_info(
+                "Version deleted",
+                project_id=project.id,
+                version_no=version.no,
+                user=username
+            )
     
-    if (this.versionForm.invalid) {
-      const invalidFields: string[] = [];
-      Object.keys(this.versionForm.controls).forEach(key => {
-        const control = this.versionForm.get(key);
-        if (control && control.invalid) {
-          invalidFields.push(key);
-        }
-      });
-      
-      this.intents.controls.forEach((intent, index) => {
-        if (intent.invalid) {
-          invalidFields.push(`Intent ${index + 1}`);
-        }
-      });
-  
-      this.snackBar.open(`Please fix validation errors in: ${invalidFields.join(', ')}`, 'Close', { 
-        duration: 5000 
-      });
-      return;
-    }
-  
-    const currentVersion = this.selectedVersion!;
-  
-    this.saving = true;
+    # ===================== API Methods =====================
     
-    try {
-      const formValue = this.versionForm.getRawValue();
-      
-      // updateData'yı backend'in beklediği formatta hazırla
-      const updateData = {
-        caption: formValue.caption,
-        general_prompt: formValue.general_prompt || '',
-        welcome_prompt: formValue.welcome_prompt || '',  // Added welcome_prompt
-        llm: formValue.llm,
-        intents: formValue.intents.map((intent: any) => ({
-          name: intent.name,
-          caption: intent.caption,
-          detection_prompt: intent.detection_prompt,
-          examples: Array.isArray(intent.examples) ? intent.examples : [],
-          parameters: Array.isArray(intent.parameters) ? intent.parameters.map((param: any) => ({
-            name: param.name,
-            caption: param.caption,
-            type: param.type,
-            required: param.required,
-            variable_name: param.variable_name,
-            extraction_prompt: param.extraction_prompt,
-            validation_regex: param.validation_regex,
-            invalid_prompt: param.invalid_prompt,
-            type_error_prompt: param.type_error_prompt
-          })) : [],
-          action: intent.action,
-          fallback_timeout_prompt: intent.fallback_timeout_prompt,
-          fallback_error_prompt: intent.fallback_error_prompt
-        })),
-        last_update_date: currentVersion.last_update_date || ''
-      };
-  
-      console.log('Saving version data:', JSON.stringify(updateData, null, 2));
-  
-      const result = await this.apiService.updateVersion(
-        this.project.id, 
-        currentVersion.no, 
-        updateData
-      ).toPromise();
-  
-      this.snackBar.open('Version saved successfully', 'Close', { duration: 3000 });
-
-      this.isDirty = false;
-      
-      if (result) {
-        this.selectedVersion = result;
-        this.versionForm.patchValue({
-          last_update_date: result.last_update_date
-        });
-      }
-      
-      await this.loadVersions();
-      
-    } catch (error: any) {
-      console.error('Save error:', error);
-      
-      if (error.status === 409) {
-        // Race condition handling
-        await this.handleRaceCondition(currentVersion);
-      } else if (error.status === 400 && error.error?.detail?.includes('Published versions')) {
-        this.snackBar.open('Published versions cannot be modified. Create a new version instead.', 'Close', { 
-          duration: 5000,
-          panelClass: 'error-snackbar'
-        });
-      } else {
-        const errorMessage = error.error?.detail || error.message || 'Failed to save version';
-        this.snackBar.open(errorMessage, 'Close', { 
-          duration: 5000,
-          panelClass: 'error-snackbar'
-        });
-      }
-    } finally {
-      this.saving = false;
-    }
-  }
-  
-  // Race condition handling
-  private async handleRaceCondition(currentVersion: Version) {
-    const formValue = this.versionForm.getRawValue();
+    @classmethod
+    def create_api(cls, api_data: dict, username: str) -> APIConfig:
+        """Create new API"""
+        with cls._lock:
+            config = cls.get()
+            
+            # Check for duplicate name
+            if any(a.name == api_data['name'] for a in config.apis):
+                raise DuplicateResourceError("api", api_data['name'])
+            
+            # Create API
+            api = APIConfig(
+                created_date=get_current_timestamp(),
+                created_by=username,
+                **api_data
+            )
+            
+            # Add to config
+            config.apis.append(api)
+            
+            # Rebuild index
+            config.build_index()
+            
+            # Log activity
+            cls._add_activity(
+                config, username, "CREATE_API",
+                "api", api.name, api.name
+            )
+            
+            # Save
+            cls.save(config, username)
+            
+            log_info(
+                "API created",
+                api_name=api.name,
+                user=username
+            )
+            
+            return api
     
-    const retryUpdateData = {
-      caption: formValue.caption,
-      general_prompt: formValue.general_prompt || '',
-      llm: formValue.llm,
-      intents: formValue.intents.map((intent: any) => ({
-        name: intent.name,
-        caption: intent.caption,
-        detection_prompt: intent.detection_prompt,
-        examples: Array.isArray(intent.examples) ? intent.examples : [],
-        parameters: Array.isArray(intent.parameters) ? intent.parameters : [],
-        action: intent.action,
-        fallback_timeout_prompt: intent.fallback_timeout_prompt,
-        fallback_error_prompt: intent.fallback_error_prompt
-      })),
-      last_update_date: currentVersion.last_update_date || ''
-    };
-  
-    const dialogRef = this.dialog.open(ConfirmDialogComponent, {
-      width: '500px',
-      data: {
-        title: 'Version Modified',
-        message: 'This version was modified by another user. Do you want to reload and lose your changes, or force save?',
-        confirmText: 'Force Save',
-        cancelText: 'Reload',
-        confirmColor: 'warn'
-      }
-    });
-  
-    dialogRef.afterClosed().subscribe(async (forceSave) => {
-      if (forceSave) {
-        try {
-          await this.apiService.updateVersion(
-            this.project.id, 
-            currentVersion.no, 
-            retryUpdateData,
-            true
-          ).toPromise();
-          this.snackBar.open('Version force saved', 'Close', { duration: 3000 });
-          await this.loadVersions();
-        } catch (err: any) {
-          this.snackBar.open(err.error?.detail || 'Force save failed', 'Close', { 
-            duration: 5000,
-            panelClass: 'error-snackbar'
-          });
-        }
-      } else {
-        await this.loadVersions();
-      }
-    });
-  }  
-  
-  async publishVersion() {
-    if (!this.selectedVersion) return;
-
-    const dialogRef = this.dialog.open(ConfirmDialogComponent, {
-      width: '500px',
-      data: {
-        title: 'Publish Version',
-        message: `Are you sure you want to publish version "${this.selectedVersion.caption}"? This will unpublish all other versions.`,
-        confirmText: 'Publish',
-        confirmColor: 'primary'
-      }
-    });
-
-    dialogRef.afterClosed().subscribe(async (confirmed) => {
-      if (confirmed && this.selectedVersion) {
-        this.publishing = true;
-        try {
-          await this.apiService.publishVersion(
-            this.project.id,
-            this.selectedVersion.no
-          ).toPromise();
-
-          this.snackBar.open('Version published successfully', 'Close', { duration: 3000 });
-          
-          // Reload to get updated data
-          await this.reloadProject();
-          
-        } catch (error: any) {
-          this.snackBar.open(error.error?.detail || 'Failed to publish version', 'Close', { 
-            duration: 5000,
-            panelClass: 'error-snackbar'
-          });
-        } finally {
-          this.publishing = false;
-        }
-      }
-    });
-  }
-
-  async deleteVersion() {
-    if (!this.selectedVersion || this.selectedVersion.published) return;
-
-    const dialogRef = this.dialog.open(ConfirmDialogComponent, {
-      width: '400px',
-      data: {
-        title: 'Delete Version',
-        message: `Are you sure you want to delete version "${this.selectedVersion.caption}"?`,
-        confirmText: 'Delete',
-        confirmColor: 'warn'
-      }
-    });
-
-    dialogRef.afterClosed().subscribe(async (confirmed) => {
-      if (confirmed && this.selectedVersion) {
-        try {
-          await this.apiService.deleteVersion(
-            this.project.id,
-            this.selectedVersion.no
-          ).toPromise();
-
-          this.snackBar.open('Version deleted successfully', 'Close', { duration: 3000 });
-          
-          // Reload and select another version
-          await this.reloadProject();
-          
-          if (this.versions.length > 0) {
-            this.loadVersion(this.versions[0]);
-          } else {
-            this.selectedVersion = null;
-          }
-          
-        } catch (error: any) {
-          this.snackBar.open(error.error?.detail || 'Failed to delete version', 'Close', { 
-            duration: 5000,
-            panelClass: 'error-snackbar'
-          });
-        }
-      }
-    });
-  }
-
-  async testIntentDetection() {
-    if (!this.testUserMessage.trim()) {
-      this.snackBar.open('Please enter a test message', 'Close', { duration: 3000 });
-      return;
-    }
-
-    this.testing = true;
-    this.testResult = null;
-
-    // Simulate intent detection test
-    setTimeout(() => {
-      // This is a mock - in real implementation, this would call the Spark service
-      const intents = this.versionForm.get('intents')?.value || [];
-      
-      // Simple matching for demo
-      let detectedIntent = null;
-      let confidence = 0;
-
-      for (const intent of intents) {
-        // Check examples in all locales
-        const allExamples = intent.examples || [];
-        for (const example of allExamples) {
-          const exampleText = typeof example === 'string' ? example : example.example;
-          if (this.testUserMessage.toLowerCase().includes(exampleText.toLowerCase())) {
-            detectedIntent = intent.name;
-            confidence = 0.95;
-            break;
-          }
-        }
-        if (detectedIntent) break;
-      }
-
-      // Random detection for demo
-      if (!detectedIntent && intents.length > 0) {
-        const randomIntent = intents[Math.floor(Math.random() * intents.length)];
-        detectedIntent
+    @classmethod
+    def update_api(cls, api_name: str, update_data: dict, username: str, expected_last_update: Optional[str] = None) -> APIConfig:
+        """Update API with optimistic locking"""
+        with cls._lock:
+            config = cls.get()
+            api = config.get_api(api_name)
+            
+            if not api:
+                raise ResourceNotFoundError("api", api_name)
+            
+            # Check race condition
+            if expected_last_update is not None and expected_last_update != '':
+                if api.last_update_date and not timestamps_equal(expected_last_update, api.last_update_date):
+                    raise RaceConditionError(
+                        f"API '{api.name}' was modified by another user",
+                        current_user=username,
+                        last_update_user=api.last_update_user,
+                        last_update_date=api.last_update_date,
+                        entity_type="api",
+                        entity_id=api.name
+                    )                
+                        
+            # Update fields
+            for key, value in update_data.items():
+                if hasattr(api, key) and key not in ['name', 'created_date', 'created_by', 'last_update_date']:
+                    setattr(api, key, value)
+            
+            api.last_update_date = get_current_timestamp()
+            api.last_update_user = username
+            
+            # Rebuild index
+            config.build_index()
+            
+            # Log activity
+            cls._add_activity(
+                config, username, "UPDATE_API",
+                "api", api.name, api.name
+            )
+            
+            # Save
+            cls.save(config, username)
+            
+            log_info(
+                "API updated",
+                api_name=api.name,
+                user=username
+            )
+            
+            return api
+    
+    @classmethod
+    def delete_api(cls, api_name: str, username: str) -> None:
+        """Soft delete API"""
+        with cls._lock:
+            config = cls.get()
+            api = config.get_api(api_name)
+            
+            if not api:
+                raise ResourceNotFoundError("api", api_name)
+            
+            api.deleted = True
+            api.last_update_date = get_current_timestamp()
+            api.last_update_user = username
+            
+            # Rebuild index
+            config.build_index()
+            
+            # Log activity
+            cls._add_activity(
+                config, username, "DELETE_API",
+                "api", api.name, api.name
+            )
+            
+            # Save
+            cls.save(config, username)
+            
+            log_info(
+                "API deleted",
+                api_name=api.name,
+                user=username
+            )
+    
+    # ===================== Activity Methods =====================
+    @classmethod
+    def _add_activity(
+        cls,
+        config: ServiceConfig,
+        username: str,
+        action: str,
+        entity_type: str,
+        entity_id: Any,
+        entity_name: Optional[str] = None,
+        details: Optional[str] = None
+    ) -> None:
+        """Add activity log entry"""
+        # Activity ID'sini oluştur - mevcut en yüksek ID'yi bul
+        max_id = 0
+        if config.activity_log:
+            max_id = max((entry.id for entry in config.activity_log if entry.id), default=0)
+        
+        activity_id = max_id + 1
+        
+        activity = ActivityLogEntry(
+            id=activity_id,
+            timestamp=get_current_timestamp(),  # utils'ten import etmeyi unutma
+            username=username,
+            action=action,
+            entity_type=entity_type,
+            entity_id=str(entity_id) if entity_id else None,
+            entity_name=entity_name,
+            details=details
+        )
+        
+        config.activity_log.append(activity)
+        
+        # Keep only last 1000 entries
+        if len(config.activity_log) > 1000:
+            config.activity_log = config.activity_log[-1000:]