""" Controller für Facebook-spezifische Funktionalität. Mit Fingerprint-Protection und Anti-Bot Features. """ import logging import time import random from PyQt5.QtCore import QThread, pyqtSignal from typing import Dict, Any from controllers.platform_controllers.base_controller import BasePlatformController from controllers.platform_controllers.base_worker_thread import BaseAccountCreationWorkerThread from views.tabs.facebook_generator_tab import FacebookGeneratorTab from social_networks.facebook.facebook_automation import FacebookAutomation from utils.birthday_generator import BirthdayGenerator from utils.logger import setup_logger logger = setup_logger("facebook_controller") class FacebookWorkerThread(BaseAccountCreationWorkerThread): """Worker-Thread für die Facebook-Account-Erstellung.""" def __init__(self, params): super().__init__(params, "Facebook") self.birthday_generator = BirthdayGenerator() def get_automation_class(self): """Gibt die Facebook Automation Klasse zurück""" return FacebookAutomation def get_error_interpretations(self) -> Dict[str, str]: """Facebook-spezifische Fehlerinterpretationen""" return { "email already in use": "Diese E-Mail-Adresse wird bereits verwendet", "phone number required": "Telefonnummer erforderlich", "invalid birth date": "Ungültiges Geburtsdatum", "account suspended": "Account wurde gesperrt", "verification required": "Verifizierung erforderlich" } def run(self): """Führt die Account-Erstellung aus.""" try: self.log_signal.emit("Facebook-Account-Erstellung gestartet...") self.progress_signal.emit(10) # Facebook-Automation initialisieren (mit Anti-Bot Features wie Instagram) automation = FacebookAutomation( headless=self.params.get("headless", False), use_proxy=self.params.get("use_proxy", False), proxy_type=self.params.get("proxy_type"), save_screenshots=True, debug=self.params.get("debug", False), email_domain=self.params.get("email_domain", "z5m7q9dk3ah2v1plx6ju.com"), enhanced_stealth=True, # Anti-Bot Features aktivieren fingerprint_noise=0.5, # Fingerprint-Verschleierung language="de" # Deutsche Version ) self.update_signal.emit("Browser wird vorbereitet...") self.progress_signal.emit(20) # Namen aufteilen (falls zusammen übergeben) full_name = self.params.get("full_name", "") name_parts = full_name.split(" ", 1) first_name = name_parts[0] if name_parts else "Test" last_name = name_parts[1] if len(name_parts) > 1 else "User" # Geburtsdatum aus Alter generieren age = self.params.get("age", random.randint(18, 65)) birth_date_components = self.birthday_generator.generate_birthday_components("facebook", age) # Geschlecht aus den Parametern oder default gender = self.params.get("gender", random.choice(["male", "female"])) logger.info(f"Geschlecht: {gender}") self.log_signal.emit(f"Registriere Account für: {first_name} {last_name} (Alter: {age})") # Account registrieren result = automation.register_account( first_name=first_name, last_name=last_name, birth_date=birth_date_components, gender=gender, email=self.params.get("email"), # Wird generiert wenn nicht vorhanden phone_number=self.params.get("phone_number"), password=self.params.get("password"), # Wird generiert wenn nicht vorhanden **self.params.get("additional_params", {}) ) self.progress_signal.emit(100) if result["success"]: self.log_signal.emit("Account erfolgreich erstellt!") self.finished_signal.emit(result) else: error_msg = result.get("error", "Unbekannter Fehler") self.log_signal.emit(f"Fehler bei der Account-Erstellung: {error_msg}") self.error_signal.emit(error_msg) except Exception as e: logger.error(f"Fehler im Worker-Thread: {e}") self.log_signal.emit(f"Schwerwiegender Fehler: {str(e)}") self.error_signal.emit(str(e)) finally: self.running = False class FacebookController(BasePlatformController): """Controller für die Facebook-Plattform.""" def __init__(self, db_manager=None, proxy_rotator=None, email_handler=None, language_manager=None): super().__init__("Facebook", db_manager, proxy_rotator, email_handler, language_manager) self.worker_thread = None logger.info("Facebook Controller initialisiert") def get_generator_tab(self): """ Erstellt und konfiguriert den Generator-Tab für Facebook. Returns: FacebookGeneratorTab: Konfigurierter Tab für Facebook mit Geschlechtsauswahl """ # Erstelle Facebook-spezifischen Generator-Tab mit Geschlechtsfeld generator_tab = FacebookGeneratorTab( "Facebook", self.language_manager ) # Facebook-spezifische Konfiguration self._configure_facebook_fields(generator_tab) # Verbinde Signale generator_tab.start_requested.connect(self.handle_generation_request) generator_tab.stop_requested.connect(self.stop_generation) return generator_tab def _configure_facebook_fields(self, generator_tab): """ Konfiguriert Facebook-spezifische Felder im Generator-Tab. Args: generator_tab: Der zu konfigurierende Tab """ # Facebook-spezifische Konfiguration # Der FacebookGeneratorTab hat bereits das Geschlechtsfeld integriert # Vor- und Nachnamen werden im Worker-Thread aus full_name extrahiert logger.debug("Facebook-spezifische Felder konfiguriert (inkl. Geschlechtsauswahl)") def handle_generation_request(self, params: Dict[str, Any]): """ Behandelt eine Anfrage zur Account-Generierung. Args: params: Parameter für die Generierung """ logger.info(f"Facebook-Account-Generierung angefordert: {params}") # Prüfe ob bereits ein Thread läuft if self.worker_thread and self.worker_thread.isRunning(): logger.warning("Ein Account wird bereits erstellt") return # Facebook-spezifische Parameter hinzufügen params["platform"] = "facebook" # Starte Worker-Thread self.worker_thread = FacebookWorkerThread(params) # Verbinde Signale self.worker_thread.update_signal.connect( lambda msg: self.status_update.emit(msg) ) self.worker_thread.log_signal.connect( lambda msg: self.log_message.emit(msg) ) self.worker_thread.progress_signal.connect( lambda val: self.progress_update.emit(val) ) self.worker_thread.finished_signal.connect( self._handle_generation_success ) self.worker_thread.error_signal.connect( self._handle_generation_error ) # Starte Thread self.worker_thread.start() self.generation_started.emit() def _handle_generation_success(self, result: Dict[str, Any]): """ Behandelt erfolgreiche Account-Erstellung. Args: result: Ergebnis der Erstellung """ logger.info("Facebook-Account erfolgreich erstellt") # Speichere Account in Datenbank if self.db_manager and result.get("account_data"): account_data = result["account_data"] account_data["platform"] = "facebook" # Speichere in DB # TODO: DB-Integration self.generation_completed.emit(result) def _handle_generation_error(self, error_msg: str): """ Behandelt Fehler bei der Account-Erstellung. Args: error_msg: Fehlermeldung """ logger.error(f"Fehler bei Facebook-Account-Erstellung: {error_msg}") self.generation_failed.emit(error_msg) def stop_generation(self): """Stoppt die laufende Account-Generierung.""" if self.worker_thread and self.worker_thread.isRunning(): logger.info("Stoppe Facebook-Account-Generierung") self.worker_thread.stop() self.worker_thread.wait() def cleanup(self): """Räumt Ressourcen auf.""" self.stop_generation() logger.info("Facebook Controller aufgeräumt")