X-Problem gelöst

application/services/platform_service.py

@@ -0,0 +1,139 @@
+"""
+Platform Service - Business logic for platform management
+"""
+import os
+import yaml
+import logging
+from typing import List, Dict, Any, Optional
+from pathlib import Path
+
+from domain.entities.platform import Platform, PlatformStatus
+
+logger = logging.getLogger("platform_service")
+
+
+class PlatformService:
+    """
+    Service for managing platform configuration and availability.
+    Clean Architecture: Application Service
+    """
+    
+    def __init__(self, db_manager=None):
+        self.db_manager = db_manager
+        self._platforms_cache = None
+        self._config_path = Path(__file__).parent.parent.parent / "config" / "platforms.yaml"
+    
+    def _load_platforms(self) -> Dict[str, Platform]:
+        """Load platforms from configuration file"""
+        if self._platforms_cache is not None:
+            return self._platforms_cache
+        
+        try:
+            with open(self._config_path, 'r', encoding='utf-8') as f:
+                config = yaml.safe_load(f)
+            
+            platforms = {}
+            for platform_id, platform_data in config.get('platforms', {}).items():
+                platform = Platform(
+                    id=platform_data.get('id', platform_id),
+                    display_name=platform_data.get('display_name', platform_id.title()),
+                    enabled=platform_data.get('enabled', False),
+                    icon=platform_data.get('icon', f"{platform_id}.svg"),
+                    color=platform_data.get('color', '#000000')
+                )
+                platforms[platform.id] = platform
+            
+            self._platforms_cache = platforms
+            return platforms
+            
+        except FileNotFoundError:
+            logger.warning(f"Platform config not found at {self._config_path}, using defaults")
+            return self._get_default_platforms()
+        except Exception as e:
+            logger.error(f"Error loading platform config: {e}")
+            return self._get_default_platforms()
+    
+    def _get_default_platforms(self) -> Dict[str, Platform]:
+        """Get default platform configuration"""
+        defaults = {
+            'instagram': Platform('instagram', 'Instagram', True, 'instagram.svg', '#E4405F'),
+            'facebook': Platform('facebook', 'Facebook', True, 'facebook.svg', '#1877F2'),
+            'tiktok': Platform('tiktok', 'TikTok', True, 'tiktok.svg', '#000000'),
+            'x': Platform('x', 'X', True, 'twitter.svg', '#000000'),
+            'gmail': Platform('gmail', 'Gmail', False, 'gmail.svg', '#EA4335'),
+            'vk': Platform('vk', 'VK', False, 'vk.svg', '#0077FF'),
+            'ok': Platform('ok', 'OK.ru', False, 'ok.svg', '#FF6600')
+        }
+        return defaults
+    
+    def get_all_platforms(self) -> List[Platform]:
+        """Get all platforms (enabled and disabled)"""
+        platforms = self._load_platforms()
+        return list(platforms.values())
+    
+    def get_active_platforms(self) -> List[Platform]:
+        """Get only enabled platforms for UI display"""
+        platforms = self._load_platforms()
+        return [p for p in platforms.values() if p.is_enabled]
+    
+    def get_platform_by_id(self, platform_id: str) -> Optional[Platform]:
+        """Get a specific platform by ID"""
+        platforms = self._load_platforms()
+        return platforms.get(platform_id.lower())
+    
+    def is_platform_enabled(self, platform_id: str) -> bool:
+        """Check if a platform is enabled"""
+        platform = self.get_platform_by_id(platform_id)
+        return platform.is_enabled if platform else False
+    
+    def get_filter_platforms(self) -> List[Platform]:
+        """
+        Get platforms for sidebar filters.
+        Shows:
+        - All enabled platforms
+        - Disabled platforms that have existing accounts
+        """
+        platforms = self._load_platforms()
+        filter_platforms = []
+        
+        for platform in platforms.values():
+            if platform.is_enabled:
+                # Always show enabled platforms
+                filter_platforms.append(platform)
+            elif self.db_manager:
+                # Show disabled platforms only if they have accounts
+                try:
+                    count = self.db_manager.get_account_count(platform.id)
+                    if count > 0:
+                        filter_platforms.append(platform)
+                except Exception as e:
+                    logger.error(f"Error checking accounts for {platform.id}: {e}")
+        
+        return filter_platforms
+    
+    def get_platforms_with_accounts(self) -> Dict[str, int]:
+        """
+        Get platform IDs with their account counts.
+        Returns dict: {platform_id: count}
+        """
+        if not self.db_manager:
+            return {}
+        
+        platforms = self._load_platforms()
+        counts = {}
+        
+        for platform_id in platforms.keys():
+            try:
+                count = self.db_manager.get_account_count(platform_id)
+                if count > 0:
+                    counts[platform_id] = count
+            except Exception as e:
+                logger.error(f"Error getting count for {platform_id}: {e}")
+                counts[platform_id] = 0
+        
+        return counts
+    
+    def reload_configuration(self):
+        """Force reload of platform configuration"""
+        self._platforms_cache = None
+        logger.info("Platform configuration reloaded")