""" Controller für Gmail/Google Account-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.gmail.gmail_automation import GmailAutomation from utils.logger import setup_logger logger = setup_logger("gmail_controller") class GmailWorkerThread(BaseAccountCreationWorkerThread): """Worker-Thread für Gmail-Account-Erstellung""" def __init__(self, params, session_controller=None, generator_tab=None): logger.info(f"[GMAIL WORKER] __init__ aufgerufen") logger.info(f"[GMAIL WORKER] params: {params}") logger.info(f"[GMAIL WORKER] session_controller: {session_controller}") logger.info(f"[GMAIL WORKER] generator_tab: {generator_tab}") super().__init__(params, "Gmail", session_controller, generator_tab) logger.info(f"[GMAIL WORKER] Initialisierung abgeschlossen") def get_automation_class(self): """Gibt die Gmail-Automation-Klasse zurück""" logger.info(f"[GMAIL WORKER] get_automation_class aufgerufen") logger.info(f"[GMAIL WORKER] Gebe zurück: {GmailAutomation}") return GmailAutomation def get_error_interpretations(self) -> Dict[str, str]: """Gmail-spezifische Fehlerinterpretationen""" return { "captcha": "Google hat ein Captcha angefordert. Bitte versuchen Sie es später erneut.", "phone": "Eine Telefonnummer ist zur Verifizierung erforderlich.", "age": "Sie müssen mindestens 13 Jahre alt sein.", "taken": "Diese E-Mail-Adresse ist bereits vergeben." } class GmailController(BasePlatformController): """Controller für Gmail-Funktionalität""" def __init__(self, db_manager, proxy_rotator, email_handler, language_manager, theme_manager=None): super().__init__("gmail", db_manager, proxy_rotator, email_handler, language_manager) logger.info("Gmail Controller initialisiert") def get_worker_thread_class(self): """Gibt die Worker-Thread-Klasse für Gmail zurück""" return GmailWorkerThread def get_platform_display_name(self) -> str: """Gibt den Anzeigenamen der Plattform zurück""" return "Gmail" def validate_account_data(self, account_data: Dict[str, Any]) -> Dict[str, Any]: """Validiert die Account-Daten für Gmail""" 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") # Prüfe Geburtsdatum (muss mindestens 13 Jahre alt sein) if account_data.get("birthday"): from datetime import datetime try: birth_date = datetime.strptime(account_data["birthday"], "%Y-%m-%d") age = (datetime.now() - birth_date).days / 365.25 if age < 13: errors.append("Sie müssen mindestens 13 Jahre alt sein") except: errors.append("Ungültiges Geburtsdatum") if errors: return { "valid": False, "errors": errors } return { "valid": True, "errors": [] } def create_generator_tab(self): """Erstellt den Generator-Tab und verbindet die Signale""" from views.tabs.generator_tab import GeneratorTab generator_tab = GeneratorTab(self.platform_name, self.language_manager) # Signal verbinden generator_tab.start_requested.connect(self.start_account_creation) generator_tab.stop_requested.connect(self.stop_account_creation) return generator_tab def get_default_settings(self) -> Dict[str, Any]: """Gibt die Standard-Einstellungen für Gmail zurück""" settings = super().get_default_settings() settings.update({ "require_phone": False, # Optional, aber oft erforderlich "require_email": False, # Gmail erstellt die Email "min_age": 13, "supported_languages": ["de", "en", "es", "fr", "it", "pt", "ru"], "default_language": "de", "captcha_warning": True # Gmail verwendet oft Captchas }) return settings def start_account_creation(self, params): """Startet die Gmail-Account-Erstellung.""" logger.info(f"[GMAIL] start_account_creation aufgerufen") logger.info(f"[GMAIL] Parameter: {params}") logger.info(f"[GMAIL] Controller-Typ: {type(self)}") # 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, "Gmail") 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 Gmail 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 logger.info(f"[GMAIL] Erstelle Worker Thread...") logger.info(f"[GMAIL] session_controller: {session_controller}") logger.info(f"[GMAIL] generator_tab_ref: {generator_tab_ref}") self.worker_thread = GmailWorkerThread( params, session_controller=session_controller, generator_tab=generator_tab_ref ) logger.info(f"[GMAIL] Worker Thread erstellt: {self.worker_thread}") # 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(lambda result: self._handle_finished(result.get("success", False), result)) 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)) logger.info(f"[GMAIL] Starte Worker Thread...") self.worker_thread.start() logger.info(f"[GMAIL] Worker Thread gestartet!") # Dialog anzeigen logger.info(f"[GMAIL] Zeige Forge Dialog...") self.forge_dialog.start_animation() self.forge_dialog.show() logger.info(f"[GMAIL] start_account_creation abgeschlossen") def stop_account_creation(self): """Stoppt die laufende Account-Erstellung""" logger.info("[GMAIL] Stoppe Account-Erstellung") if self.worker_thread and self.worker_thread.isRunning(): self.worker_thread.stop() self.worker_thread.wait() if hasattr(self, 'forge_dialog') and self.forge_dialog: self.forge_dialog.close() # UI zurücksetzen generator_tab = self.get_generator_tab() generator_tab.set_running(False) def _handle_error(self, error_msg): """Behandelt Fehler während der Account-Erstellung""" logger.error(f"[GMAIL] Fehler: {error_msg}") # Dialog schließen if hasattr(self, 'forge_dialog') and self.forge_dialog: self.forge_dialog.close() # UI aktualisieren generator_tab = self.get_generator_tab() generator_tab.set_running(False) generator_tab.show_error(f"Fehler: {error_msg}") def _handle_finished(self, success, result_data): """Behandelt das Ende der Account-Erstellung""" logger.info(f"[GMAIL] Account-Erstellung beendet. Erfolg: {success}") # Dialog schließen if hasattr(self, 'forge_dialog') and self.forge_dialog: self.forge_dialog.close() # UI aktualisieren generator_tab = self.get_generator_tab() generator_tab.set_running(False) if success: generator_tab.show_success("Gmail Account erfolgreich erstellt!") else: # Fehlertext aus Resultat ziehen, falls vorhanden error_msg = "Unbekannter Fehler bei der Gmail-Registrierung" try: error_msg = result_data.get("error") or result_data.get("message") or error_msg except Exception: pass logger.error(f"[GMAIL] Registrierung fehlgeschlagen: {error_msg}") generator_tab.show_error(f"Fehler: {error_msg}")