Initial commit

controllers/platform_controllers/vk_controller.py

@@ -0,0 +1,159 @@
+"""
+Controller für VK-spezifische Funktionalität
+"""
+
+import logging
+from typing import Dict, Any
+
+from controllers.platform_controllers.base_controller import BasePlatformController
+from controllers.platform_controllers.base_worker_thread import BaseAccountCreationWorkerThread
+from social_networks.vk.vk_automation import VKAutomation
+from utils.logger import setup_logger
+
+logger = setup_logger("vk_controller")
+
+class VKWorkerThread(BaseAccountCreationWorkerThread):
+    """Worker-Thread für VK-Account-Erstellung"""
+    
+    def __init__(self, params, session_controller=None, generator_tab=None):
+        super().__init__(params, "VK", session_controller, generator_tab)
+    
+    def get_automation_class(self):
+        """Gibt die VK-Automation-Klasse zurück"""
+        return VKAutomation
+    
+    def get_error_interpretations(self) -> Dict[str, str]:
+        """VK-spezifische Fehlerinterpretationen"""
+        return {
+            "phone": "Diese Telefonnummer wird bereits verwendet oder ist ungültig.",
+            "code": "Der Verifizierungscode ist ungültig.",
+            "blocked": "Zu viele Versuche. Bitte versuchen Sie es später erneut.",
+            "captcha": "Bitte lösen Sie das Captcha."
+        }
+    
+
+class VKController(BasePlatformController):
+    """Controller für VK-Funktionalität"""
+    
+    def __init__(self, db_manager, proxy_rotator, email_handler, language_manager, theme_manager=None):
+        super().__init__("vk", db_manager, proxy_rotator, email_handler, language_manager)
+        logger.info("VK Controller initialisiert")
+    
+    def get_worker_thread_class(self):
+        """Gibt die Worker-Thread-Klasse für VK zurück"""
+        return VKWorkerThread
+    
+    def get_platform_display_name(self) -> str:
+        """Gibt den Anzeigenamen der Plattform zurück"""
+        return "VK"
+    
+    def validate_account_data(self, account_data: Dict[str, Any]) -> Dict[str, Any]:
+        """Validiert die Account-Daten für VK"""
+        errors = []
+        
+        # Pflichtfelder prüfen
+        if not account_data.get("first_name"):
+            errors.append("Vorname ist erforderlich")
+        
+        if not account_data.get("last_name"):
+            errors.append("Nachname ist erforderlich")
+            
+        if not account_data.get("phone"):
+            errors.append("Telefonnummer ist für VK erforderlich")
+        
+        if errors:
+            return {
+                "valid": False,
+                "errors": errors
+            }
+        
+        return {
+            "valid": True,
+            "errors": []
+        }
+    
+    def get_default_settings(self) -> Dict[str, Any]:
+        """Gibt die Standard-Einstellungen für VK zurück"""
+        settings = super().get_default_settings()
+        settings.update({
+            "require_phone": True,
+            "require_email": False,
+            "default_country_code": "+7",  # Russland
+            "supported_languages": ["ru", "en", "de"],
+            "default_language": "ru"
+        })
+        return settings
+    
+    def start_account_creation(self, params):
+        """Startet die VK-Account-Erstellung."""
+        logger.info(f"Starte VK Account-Erstellung mit Parametern: {params}")
+        
+        # Validiere Eingaben
+        is_valid, error_msg = self.validate_inputs(params)
+        if not is_valid:
+            self.get_generator_tab().show_error(error_msg)
+            return
+        
+        # UI aktualisieren
+        generator_tab = self.get_generator_tab()
+        generator_tab.set_running(True)
+        generator_tab.clear_log()
+        generator_tab.set_progress(0)
+        
+        # Schmiedeanimation-Dialog erstellen und anzeigen
+        from views.widgets.forge_animation_widget import ForgeAnimationDialog
+        parent_widget = generator_tab.window()
+        self.forge_dialog = ForgeAnimationDialog(parent_widget, "VK")
+        self.forge_dialog.cancel_clicked.connect(self.stop_account_creation)
+        self.forge_dialog.closed.connect(self.stop_account_creation)
+        
+        # Fensterposition vom Hauptfenster holen
+        if parent_widget:
+            window_pos = parent_widget.pos()
+            params["window_position"] = (window_pos.x(), window_pos.y())
+        
+        # Fingerprint generieren
+        try:
+            from infrastructure.services.fingerprint.fingerprint_generator_service import FingerprintGeneratorService
+            from domain.entities.browser_fingerprint import BrowserFingerprint
+            import uuid
+            
+            fingerprint_service = FingerprintGeneratorService()
+            fingerprint_data = fingerprint_service.generate_fingerprint()
+            
+            fingerprint = BrowserFingerprint.from_dict(fingerprint_data)
+            fingerprint.fingerprint_id = str(uuid.uuid4())
+            fingerprint.account_bound = True
+            fingerprint.rotation_seed = str(uuid.uuid4())
+            
+            params["fingerprint"] = fingerprint.to_dict()
+            logger.info(f"Fingerprint für VK Account-Erstellung generiert: {fingerprint.fingerprint_id}")
+        except Exception as e:
+            logger.error(f"Fehler beim Generieren des Fingerprints: {e}")
+        
+        # Worker-Thread starten
+        session_controller = getattr(self, 'session_controller', None)
+        generator_tab_ref = generator_tab if hasattr(generator_tab, 'store_created_account') else None
+        
+        self.worker_thread = VKWorkerThread(
+            params,
+            session_controller=session_controller,
+            generator_tab=generator_tab_ref
+        )
+        
+        # Signals verbinden
+        self.worker_thread.update_signal.connect(self.forge_dialog.set_status)
+        self.worker_thread.log_signal.connect(self.forge_dialog.add_log)
+        self.worker_thread.error_signal.connect(self._handle_error)
+        self.worker_thread.finished_signal.connect(self._handle_finished)
+        self.worker_thread.progress_signal.connect(self.forge_dialog.set_progress)
+        
+        # Auch an Generator-Tab
+        self.worker_thread.log_signal.connect(lambda msg: generator_tab.add_log(msg))
+        self.worker_thread.progress_signal.connect(lambda value: generator_tab.set_progress(value))
+        
+        self.worker_thread.start()
+        
+        # Dialog anzeigen
+        self.forge_dialog.start_animation()
+        self.forge_dialog.show()