Update config_provider.py

config_provider.py

@@ -525,6 +525,651 @@ class ConfigProvider:
                 
                 log("✅ Default environment variables set.")
 
+    @classmethod
+    def update_user_password(cls, username: str, new_hash: str, new_salt: str) -> None:
+        """Update user password"""
+        if cls._instance is None:
+            cls.get()
+            
+        user = next((u for u in cls._instance.global_config.users if u.username == username), None)
+        if user:
+            user.password_hash = new_hash
+            user.salt = new_salt
+            cls._instance.save()
+            cls.add_activity_log(username, "CHANGE_PASSWORD", "user", None, username)
+    
+    @classmethod
+    def update_environment(cls, update_data: dict, username: str) -> None:
+        """Update environment configuration"""
+        if cls._instance is None:
+            cls.get()
+        
+        config = cls._instance.global_config
+        
+        # Update fields
+        if 'work_mode' in update_data:
+            config.work_mode = update_data['work_mode']
+        if 'cloud_token' in update_data:
+            from encryption_utils import encrypt
+            config.cloud_token = encrypt(update_data['cloud_token']) if update_data['cloud_token'] else ""
+        if 'spark_endpoint' in update_data:
+            config.spark_endpoint = update_data['spark_endpoint']
+        if 'internal_prompt' in update_data:
+            config.internal_prompt = update_data['internal_prompt']
+        
+        # TTS/STT settings
+        if 'tts_engine' in update_data:
+            config.tts_engine = update_data['tts_engine']
+        if 'tts_engine_api_key' in update_data and update_data['tts_engine_api_key'] != "***":
+            from encryption_utils import encrypt
+            config.tts_engine_api_key = encrypt(update_data['tts_engine_api_key']) if update_data['tts_engine_api_key'] else ""
+        if 'tts_settings' in update_data:
+            config.tts_settings = update_data['tts_settings']
+            
+        if 'stt_engine' in update_data:
+            config.stt_engine = update_data['stt_engine']
+        if 'stt_engine_api_key' in update_data:
+            from encryption_utils import encrypt
+            config.stt_engine_api_key = encrypt(update_data['stt_engine_api_key']) if update_data['stt_engine_api_key'] else ""
+        if 'stt_settings' in update_data:
+            config.stt_settings = update_data['stt_settings']
+            
+        if 'parameter_collection_config' in update_data:
+            config.parameter_collection_config = ParameterCollectionConfig(**update_data['parameter_collection_config'])
+        
+        # Update metadata
+        cls._instance.last_update_date = datetime.now().isoformat()
+        cls._instance.last_update_user = username
+        
+        # Add activity log
+        cls.add_activity_log(username, "UPDATE_ENVIRONMENT", "config", None, "environment", 
+                           f"Changed to {config.work_mode}, TTS: {config.tts_engine}, STT: {config.stt_engine}")
+        
+        # Save to file
+        cls._instance.save()
+        
+        # Reload to ensure consistency
+        cls.reload()
+        
+    @classmethod
+    def add_activity_log(cls, username: str, action: str, entity_type: str, 
+                        entity_id: Any = None, entity_name: str = None, details: str = "") -> None:
+        """Add activity log entry"""
+        if cls._instance is None:
+            cls.get()
+            
+        entry = ActivityLogEntry(
+            timestamp=datetime.now().isoformat() + "Z",
+            username=username,
+            action=action,
+            entity_type=entity_type,
+            entity_id=entity_id,
+            entity_name=entity_name,
+            details=details
+        )
+        
+        cls._instance.activity_log.append(entry)
+        
+        # Keep only last 1000 entries
+        if len(cls._instance.activity_log) > 1000:
+            cls._instance.activity_log = cls._instance.activity_log[-1000:]
+    
+    @classmethod
+    def get_project(cls, project_id: int) -> Optional[ProjectConfig]:
+        """Get project by ID"""
+        if cls._instance is None:
+            cls.get()
+        return next((p for p in cls._instance.projects if p.id == project_id), None)
+    
+    @classmethod
+    def get_project_by_name(cls, name: str) -> Optional[ProjectConfig]:
+        """Get project by name"""
+        if cls._instance is None:
+            cls.get()
+        return next((p for p in cls._instance.projects if p.name == name), None)
+    
+    @classmethod
+    def create_project(cls, project_data: dict, username: str) -> ProjectConfig:
+        """Create new project"""
+        if cls._instance is None:
+            cls.get()
+        
+        # Check duplicate name
+        existing = [p.name for p in cls._instance.projects if not getattr(p, 'deleted', False)]
+        if project_data['name'] in existing:
+            raise ValueError(f"Project name '{project_data['name']}' already exists")
+            
+        # Get new project ID
+        project_id = cls._instance.project_id_counter
+        cls._instance.project_id_counter += 1
+        
+        # Create project
+        new_project = ProjectConfig(
+            id=project_id,
+            name=project_data['name'],
+            caption=project_data.get('caption', ''),
+            icon=project_data.get('icon', 'folder'),
+            description=project_data.get('description', ''),
+            default_language=project_data.get('default_language', 'Türkçe'),
+            supported_languages=project_data.get('supported_languages', ['tr-TR']),
+            timezone=project_data.get('timezone', 'Europe/Istanbul'),
+            region=project_data.get('region', 'tr-TR'),
+            enabled=True,
+            deleted=False,
+            version_id_counter=2,  # Start from 2 since we create version 1
+            last_version_number=1,
+            created_date=datetime.now().isoformat() + "Z",
+            created_by=username,
+            last_update_date=datetime.now().isoformat() + "Z",
+            last_update_user=username,
+            versions=[
+                VersionConfig(
+                    id=1,
+                    version_number=1,
+                    no=1,
+                    caption="Version 1",
+                    published=False,
+                    created_date=datetime.now().isoformat() + "Z",
+                    created_by=username,
+                    last_update_date=datetime.now().isoformat() + "Z",
+                    last_update_user=username,
+                    general_prompt="",
+                    llm=LLMConfig(
+                        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=[]
+                )
+            ]
+        )
+        
+        cls._instance.projects.append(new_project)
+        
+        # Add activity log
+        cls.add_activity_log(username, "CREATE_PROJECT", "project", project_id, project_data['name'])
+        
+        # Save
+        cls._instance.save()
+        
+        return new_project
+    
+    @classmethod
+    def update_project(cls, project_id: int, update_data: dict, username: str) -> ProjectConfig:
+        """Update project"""
+        if cls._instance is None:
+            cls.get()
+            
+        project = cls.get_project(project_id)
+        if not project:
+            raise ValueError(f"Project {project_id} not found")
+            
+        # Check race condition
+        if project.last_update_date != update_data.get('last_update_date'):
+            raise ValueError("Project was modified by another user")
+        
+        # Update fields
+        project.caption = update_data['caption']
+        project.icon = update_data.get('icon', project.icon)
+        project.description = update_data.get('description', project.description)
+        project.default_language = update_data.get('default_language', project.default_language)
+        project.supported_languages = update_data.get('supported_languages', project.supported_languages)
+        project.timezone = update_data.get('timezone', project.timezone)
+        project.region = update_data.get('region', project.region)
+        project.last_update_date = datetime.now().isoformat() + "Z"
+        project.last_update_user = username
+        
+        # Add activity log
+        cls.add_activity_log(username, "UPDATE_PROJECT", "project", project_id, project.name)
+        
+        # Save
+        cls._instance.save()
+        
+        return project
+    
+    @classmethod
+    def delete_project(cls, project_id: int, username: str) -> None:
+        """Delete project (soft delete)"""
+        if cls._instance is None:
+            cls.get()
+            
+        project = cls.get_project(project_id)
+        if not project:
+            raise ValueError(f"Project {project_id} not found")
+        
+        project.deleted = True
+        project.last_update_date = datetime.now().isoformat() + "Z"
+        project.last_update_user = username
+        
+        # Add activity log
+        cls.add_activity_log(username, "DELETE_PROJECT", "project", project_id, project.name)
+        
+        # Save
+        cls._instance.save()
+    
+    @classmethod
+    def toggle_project(cls, project_id: int, username: str) -> bool:
+        """Toggle project enabled status"""
+        if cls._instance is None:
+            cls.get()
+            
+        project = cls.get_project(project_id)
+        if not project:
+            raise ValueError(f"Project {project_id} not found")
+        
+        project.enabled = not project.enabled
+        project.last_update_date = datetime.now().isoformat() + "Z"
+        project.last_update_user = username
+        
+        # Add activity log
+        action = "ENABLE_PROJECT" if project.enabled else "DISABLE_PROJECT"
+        cls.add_activity_log(username, action, "project", project_id, project.name)
+        
+        # Save
+        cls._instance.save()
+        
+        return project.enabled
+    
+    @classmethod
+    def create_version(cls, project_id: int, version_data: dict, username: str) -> VersionConfig:
+        """Create new version"""
+        if cls._instance is None:
+            cls.get()
+            
+        project = cls.get_project(project_id)
+        if not project:
+            raise ValueError(f"Project {project_id} not found")
+        
+        # Get next version ID
+        version_id = project.version_id_counter
+        project.version_id_counter += 1
+        
+        # Get next version number
+        existing_versions = [v for v in project.versions if not getattr(v, 'deleted', False)]
+        version_no = max([v.no for v in existing_versions], default=0) + 1
+        
+        # Create base version
+        new_version = VersionConfig(
+            id=version_id,
+            version_number=version_id,
+            no=version_no,
+            caption=version_data['caption'],
+            description=f"Version {version_no}",
+            published=False,
+            deleted=False,
+            created_date=datetime.now().isoformat() + "Z",
+            created_by=username,
+            last_update_date=datetime.now().isoformat() + "Z",
+            last_update_user=username,
+            general_prompt="",
+            llm=LLMConfig(
+                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=[]
+        )
+        
+        # Copy from source version if specified
+        if version_data.get('source_version_id'):
+            source_version = next(
+                (v for v in project.versions if v.id == version_data['source_version_id']),
+                None
+            )
+            if source_version:
+                new_version.general_prompt = source_version.general_prompt
+                new_version.llm = source_version.llm.model_copy(deep=True)
+                new_version.intents = [i.model_copy(deep=True) for i in source_version.intents]
+        
+        project.versions.append(new_version)
+        project.last_update_date = datetime.now().isoformat() + "Z"
+        project.last_update_user = username
+        
+        # Add activity log
+        cls.add_activity_log(username, "CREATE_VERSION", "version", version_id,
+                           f"{project.name} v{version_no}")
+        
+        # Save
+        cls._instance.save()
+        
+        return new_version
+    
+    @classmethod
+    def update_version(cls, project_id: int, version_id: int, update_data: dict, username: str) -> VersionConfig:
+        """Update version"""
+        if cls._instance is None:
+            cls.get()
+            
+        project = cls.get_project(project_id)
+        if not project:
+            raise ValueError(f"Project {project_id} not found")
+            
+        version = next((v for v in project.versions if v.id == version_id), None)
+        if not version:
+            raise ValueError(f"Version {version_id} not found")
+        
+        # Check race condition
+        if version.last_update_date != update_data.get('last_update_date'):
+            raise ValueError("Version was modified by another user")
+        
+        # Cannot update published version
+        if version.published:
+            raise ValueError("Cannot modify published version")
+        
+        # Update version
+        version.caption = update_data['caption']
+        version.general_prompt = update_data['general_prompt']
+        version.llm = LLMConfig(**update_data['llm'])
+        version.intents = [IntentConfig(**i) for i in update_data['intents']]
+        version.last_update_date = datetime.now().isoformat() + "Z"
+        version.last_update_user = username
+        
+        # Update project timestamp
+        project.last_update_date = datetime.now().isoformat() + "Z"
+        project.last_update_user = username
+        
+        # Add activity log
+        cls.add_activity_log(username, "UPDATE_VERSION", "version", version_id,
+                           f"{project.name} v{version.no}")
+        
+        # Save
+        cls._instance.save()
+        
+        return version
+    
+    @classmethod
+    def publish_version(cls, project_id: int, version_id: int, username: str) -> tuple[ProjectConfig, VersionConfig]:
+        """Publish version"""
+        if cls._instance is None:
+            cls.get()
+            
+        project = cls.get_project(project_id)
+        if not project:
+            raise ValueError(f"Project {project_id} not found")
+            
+        version = next((v for v in project.versions if v.id == version_id), None)
+        if not version:
+            raise ValueError(f"Version {version_id} not found")
+        
+        # Unpublish all other versions
+        for v in project.versions:
+            if v.id != version_id:
+                v.published = False
+        
+        # Publish this version
+        version.published = True
+        version.publish_date = datetime.now().isoformat() + "Z"
+        version.published_by = username
+        version.last_update_date = datetime.now().isoformat() + "Z"
+        version.last_update_user = username
+        
+        # Update project timestamp
+        project.last_update_date = datetime.now().isoformat() + "Z"
+        project.last_update_user = username
+        
+        # Add activity log
+        cls.add_activity_log(username, "PUBLISH_VERSION", "version", version_id,
+                           f"{project.name} v{version.no}")
+        
+        # Save
+        cls._instance.save()
+        
+        return project, version
+    
+    @classmethod
+    def delete_version(cls, project_id: int, version_id: int, username: str) -> None:
+        """Delete version (soft delete)"""
+        if cls._instance is None:
+            cls.get()
+            
+        project = cls.get_project(project_id)
+        if not project:
+            raise ValueError(f"Project {project_id} not found")
+            
+        version = next((v for v in project.versions if v.id == version_id), None)
+        if not version:
+            raise ValueError(f"Version {version_id} not found")
+        
+        # Cannot delete published version
+        if version.published:
+            raise ValueError("Cannot delete published version")
+        
+        version.deleted = True
+        version.last_update_date = datetime.now().isoformat() + "Z"
+        version.last_update_user = username
+        
+        project.last_update_date = datetime.now().isoformat() + "Z"
+        project.last_update_user = username
+        
+        # Add activity log
+        cls.add_activity_log(username, "DELETE_VERSION", "version", version_id,
+                           f"{project.name} v{version.no}")
+        
+        # Save
+        cls._instance.save()
+    
+    @classmethod
+    def create_api(cls, api_data: dict, username: str) -> APIConfig:
+        """Create new API"""
+        if cls._instance is None:
+            cls.get()
+        
+        # Check duplicate name
+        existing = [a.name for a in cls._instance.apis if not getattr(a, 'deleted', False)]
+        if api_data['name'] in existing:
+            raise ValueError(f"API name '{api_data['name']}' already exists")
+        
+        # Create API
+        new_api = APIConfig(
+            **api_data,
+            deleted=False,
+            created_date=datetime.now().isoformat() + "Z",
+            created_by=username,
+            last_update_date=datetime.now().isoformat() + "Z",
+            last_update_user=username
+        )
+        
+        cls._instance.apis.append(new_api)
+        cls._instance.build_index()  # Rebuild index
+        
+        # Add activity log
+        cls.add_activity_log(username, "CREATE_API", "api", None, api_data['name'])
+        
+        # Save
+        cls._instance.save()
+        
+        return new_api
+    
+    @classmethod
+    def update_api(cls, api_name: str, update_data: dict, username: str) -> APIConfig:
+        """Update API"""
+        if cls._instance is None:
+            cls.get()
+            
+        api = cls._instance.get_api(api_name)
+        if not api:
+            raise ValueError(f"API '{api_name}' not found")
+        
+        # Check race condition
+        if api.last_update_date != update_data.get('last_update_date'):
+            raise ValueError("API was modified by another user")
+        
+        # Check if API is in use in published versions
+        for project in cls._instance.projects:
+            for version in project.versions:
+                if version.published:
+                    for intent in version.intents:
+                        if intent.action == api_name:
+                            raise ValueError(f"API is used in published version of project '{project.name}'")
+        
+        # Update API
+        for key, value in update_data.items():
+            if key != 'last_update_date' and hasattr(api, key):
+                setattr(api, key, value)
+        
+        api.last_update_date = datetime.now().isoformat() + "Z"
+        api.last_update_user = username
+        
+        # Add activity log
+        cls.add_activity_log(username, "UPDATE_API", "api", None, api_name)
+        
+        # Save
+        cls._instance.save()
+        
+        return api
+    
+    @classmethod
+    def delete_api(cls, api_name: str, username: str) -> None:
+        """Delete API (soft delete)"""
+        if cls._instance is None:
+            cls.get()
+            
+        api = cls._instance.get_api(api_name)
+        if not api:
+            raise ValueError(f"API '{api_name}' not found")
+        
+        # Check if API is in use
+        for project in cls._instance.projects:
+            if getattr(project, 'deleted', False):
+                continue
+                
+            for version in project.versions:
+                if getattr(version, 'deleted', False):
+                    continue
+                
+                for intent in version.intents:
+                    if intent.action == api_name:
+                        raise ValueError(f"API is used in intent '{intent.name}' in project '{project.name}' version {version.no}")
+        
+        api.deleted = True
+        api.last_update_date = datetime.now().isoformat() + "Z"
+        api.last_update_user = username
+        
+        # Add activity log
+        cls.add_activity_log(username, "DELETE_API", "api", None, api_name)
+        
+        # Save
+        cls._instance.save()
+    
+    @classmethod
+    def import_project(cls, project_data: dict, username: str) -> ProjectConfig:
+        """Import project from JSON"""
+        if cls._instance is None:
+            cls.get()
+        
+        # Validate structure
+        if "name" not in project_data:
+            raise ValueError("Invalid project data")
+        
+        # Create new project with imported data
+        imported_data = {
+            "name": project_data["name"],
+            "caption": project_data.get("caption", ""),
+            "icon": project_data.get("icon", "folder"),
+            "description": project_data.get("description", "")
+        }
+        
+        # Create project
+        new_project = cls.create_project(imported_data, username)
+        
+        # Clear default version
+        new_project.versions = []
+        
+        # Import versions
+        for idx, version_data in enumerate(project_data.get("versions", [])):
+            new_version = VersionConfig(
+                id=idx + 1,
+                version_number=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=datetime.now().isoformat() + "Z",
+                created_by=username,
+                last_update_date=datetime.now().isoformat() + "Z",
+                last_update_user=username,
+                general_prompt=version_data.get("general_prompt", ""),
+                llm=LLMConfig(**version_data.get("llm", {})) if version_data.get("llm") else LLMConfig(
+                    repo_id="",
+                    generation_config={},
+                    use_fine_tune=False,
+                    fine_tune_zip=""
+                ),
+                intents=[IntentConfig(**i) for i in version_data.get("intents", [])]
+            )
+            new_project.versions.append(new_version)
+            new_project.version_id_counter = idx + 2
+        
+        # Add activity log (already added in create_project)
+        cls.add_activity_log(username, "IMPORT_PROJECT", "project", new_project.id, new_project.name)
+        
+        # Save
+        cls._instance.save()
+        
+        return new_project
+    
+    @classmethod
+    def export_project(cls, project_id: int, username: str) -> dict:
+        """Export project as JSON"""
+        if cls._instance is None:
+            cls.get()
+            
+        project = cls.get_project(project_id)
+        if not project:
+            raise ValueError(f"Project {project_id} not found")
+        
+        # Create export data
+        export_data = {
+            "name": project.name,
+            "caption": project.caption,
+            "icon": project.icon,
+            "description": project.description,
+            "versions": []
+        }
+        
+        # Export versions
+        for version in project.versions:
+            if not getattr(version, 'deleted', False):
+                export_version = {
+                    "caption": version.caption,
+                    "description": getattr(version, 'description', ''),
+                    "general_prompt": version.general_prompt,
+                    "llm": version.llm.model_dump(),
+                    "intents": [i.model_dump() for i in version.intents]
+                }
+                export_data["versions"].append(export_version)
+        
+        # Add activity log
+        cls.add_activity_log(username, "EXPORT_PROJECT", "project", project_id, project.name)
+        cls._instance.save()
+        
+        return export_data
+    
+    @classmethod
+    def cleanup_activity_logs(cls, keep_count: int = 1000) -> None:
+        """Cleanup old activity logs"""
+        if cls._instance is None:
+            cls.get()
+        
+        if len(cls._instance.activity_log) > keep_count:
+            # Keep only last entries
+            cls._instance.activity_log = cls._instance.activity_log[-keep_count:]
+            cls._instance.save()
+
 # Forward references
 GlobalConfig.model_rebuild()
 VersionConfig.model_rebuild()