Rollbackpunkt, alles außer TikTok geht, die wollen wieder so eine extra locke bei Login

controllers/platform_controllers/base_worker_thread.py

@@ -133,7 +133,7 @@ class BaseAccountCreationWorkerThread(QThread):
                 register_params.update(self.params["additional_params"])
             
             result = automation.register_account(**register_params)
-            
+
             if result["success"]:
                 # Stelle sicher, dass die Datenstruktur kompatibel ist
                 if "account_data" not in result:
@@ -144,19 +144,48 @@ class BaseAccountCreationWorkerThread(QThread):
                         "email": result.get("email", ""),
                         "phone": result.get("phone", "")
                     }
-                
+
+                # KRITISCHE VALIDIERUNG: Prüfe PFLICHTFELDER vor Weitergabe
+                account_data = result.get("account_data", {})
+                validation_errors = []
+
+                # Prüfe Username
+                if not account_data.get("username") or account_data["username"] == "":
+                    validation_errors.append("Username fehlt oder ist leer")
+
+                # Prüfe Password
+                if not account_data.get("password") or account_data["password"] == "":
+                    validation_errors.append("Passwort fehlt oder ist leer")
+
+                # Prüfe Email oder Phone (mindestens eins muss vorhanden sein)
+                if not account_data.get("email") and not account_data.get("phone"):
+                    validation_errors.append("Weder E-Mail noch Telefon vorhanden")
+
+                # Wenn Validierungsfehler existieren, markiere als Fehler
+                if validation_errors:
+                    error_msg = f"Account-Daten unvollständig: {', '.join(validation_errors)}"
+                    self.log_signal.emit(f"VALIDIERUNGSFEHLER: {error_msg}")
+                    self.log_signal.emit(f"Account-Daten: {account_data}")
+                    self.error_signal.emit(error_msg)
+                    self.progress_signal.emit(0)
+                    return  # Breche ab - sende KEIN finished_signal
+
                 fingerprint_data = self.params.get("fingerprint")
                 # Handle BrowserFingerprint object vs dict
                 if fingerprint_data and hasattr(fingerprint_data, 'to_dict'):
                     result["fingerprint"] = fingerprint_data.to_dict()
                 else:
                     result["fingerprint"] = fingerprint_data
+
                 self.log_signal.emit("Account erfolgreich erstellt!")
-                self.finished_signal.emit(result)
                 self.progress_signal.emit(100)
-                
-                # Session-Speicherung wenn verfügbar
-                self._save_session_if_available(result)
+
+                # Session-Speicherung vor Benachrichtigung durchführen
+                save_result = self._save_session_if_available(result)
+                if save_result is not None:
+                    result["save_result"] = save_result
+
+                self.finished_signal.emit(result)
             else:
                 error_msg = result.get("error", "Unbekannter Fehler")
                 interpreted_error = self._interpret_error(error_msg)
@@ -184,12 +213,13 @@ class BaseAccountCreationWorkerThread(QThread):
         return f"Fehler bei der Registrierung: {error_message}"
     
     
-    def _save_session_if_available(self, result: Dict[str, Any]):
-        """Speichert Session wenn Controller verfügbar"""
+    def _save_session_if_available(self, result: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+        """Speichert Session wenn Controller verfügbar und gibt das Ergebnis zurück"""
+        save_result: Optional[Dict[str, Any]] = None
+
         # Session über SessionController speichern wenn verfügbar
         if hasattr(self, 'session_controller') and self.session_controller:
             try:
-                # Verwende den SessionController direkt für Clean Architecture
                 if hasattr(self.session_controller, 'create_and_save_account'):
                     # Account-Daten aus dem korrekten Pfad extrahieren
                     if "account_data" in result:
@@ -201,25 +231,30 @@ class BaseAccountCreationWorkerThread(QThread):
                             'email': result.get("email"),
                             'phone': result.get("phone")
                         }
-                    
+
                     save_result = self.session_controller.create_and_save_account(
                         platform=self.platform_name,
                         account_data=account_data
                     )
-                    
+
                     if save_result.get('success'):
-                        self.log_signal.emit(f"Session erfolgreich gespeichert")
+                        self.log_signal.emit("Session erfolgreich gespeichert")
                     else:
-                        self.log_signal.emit(f"Warnung: Session konnte nicht gespeichert werden")
-                        
+                        self.log_signal.emit("Warnung: Session konnte nicht gespeichert werden")
+
             except Exception as e:
-                self.log_signal.emit(f"Warnung: Session konnte nicht gespeichert werden: {e}")
-                
+                error_msg = f"Warnung: Session konnte nicht gespeichert werden: {e}"
+                self.log_signal.emit(error_msg)
+                save_result = {
+                    'success': False,
+                    'error': str(e),
+                    'message': error_msg
+                }
+
         # Alternativ: Signal an Generator Tab senden
         elif hasattr(self, 'generator_tab') and self.generator_tab:
             try:
                 if hasattr(self.generator_tab, 'account_created'):
-                    # Account-Daten aus dem korrekten Pfad extrahieren
                     if "account_data" in result:
                         account_data = result["account_data"]
                     else:
@@ -232,8 +267,10 @@ class BaseAccountCreationWorkerThread(QThread):
                     self.generator_tab.account_created.emit(self.platform_name, account_data)
             except Exception as e:
                 self.log_signal.emit(f"Warnung: Konnte Account-Daten nicht an UI senden: {e}")
+
+        return save_result
     
     def stop(self):
         """Stoppt den Thread"""
         self.running = False
-        self.terminate()
+        self.terminate()

controllers/platform_controllers/facebook_controller.py

@@ -180,50 +180,28 @@ class FacebookController(BasePlatformController):
         self.forge_dialog.start_animation()
         self.forge_dialog.show()
     
-    def handle_account_created(self, result: Dict[str, Any]):
-        """Verarbeitet erfolgreich erstellte Accounts mit Clean Architecture."""
+    def handle_account_created(self, result: Dict[str, Any]) -> bool:
+        """
+        Verarbeitet erfolgreich erstellte Accounts mit Clean Architecture.
+
+        Returns:
+            bool: True bei erfolgreicher Speicherung, False bei Fehler
+        """
         generator_tab = self.get_generator_tab()
         generator_tab.set_running(False)
 
         # Account-Daten aus dem Ergebnis holen
         account_data = result.get("account_data", {})
 
-        # Account und Session über SessionController speichern (Clean Architecture)
-        if hasattr(self, 'session_controller') and self.session_controller:
+        save_result = result.get("save_result")
+
+        # Account und Session nur speichern, wenn Worker es nicht bereits erledigt hat
+        if save_result is None and hasattr(self, 'session_controller') and self.session_controller:
             try:
-                session_data = result.get("session_data", {})
                 save_result = self.session_controller.create_and_save_account(
                     platform=self.platform_name,
                     account_data=account_data
                 )
-
-                if save_result.get('success'):
-                    logger.info(f"Account und Session erfolgreich gespeichert")
-
-                    # Erfolgsmeldung anzeigen (nur einmal!)
-                    account_info = save_result.get('account_data', {})
-                    from PyQt5.QtWidgets import QMessageBox
-                    QMessageBox.information(
-                        generator_tab,
-                        "Erfolg",
-                        f"Account erfolgreich erstellt!\n\n"
-                        f"Benutzername: {account_info.get('username', '')}\n"
-                        f"Passwort: {account_info.get('password', '')}\n"
-                        f"E-Mail/Telefon: {account_info.get('email') or account_info.get('phone', '')}"
-                    )
-
-                    # Signal senden, um zur Hauptseite zurückzukehren
-                    if hasattr(self, 'return_to_main_requested') and callable(self.return_to_main_requested):
-                        self.return_to_main_requested()
-                else:
-                    error_msg = save_result.get('message', 'Unbekannter Fehler')
-                    logger.error(f"Fehler beim Speichern: {error_msg}")
-                    from views.widgets.modern_message_box import show_error
-                    show_error(
-                        generator_tab,
-                        "Fehler beim Speichern",
-                        f"Beim Speichern des Accounts ist ein Fehler aufgetreten:\n\n{error_msg}"
-                    )
             except Exception as e:
                 logger.error(f"Fehler beim Speichern des Accounts: {e}")
                 from views.widgets.modern_message_box import show_critical
@@ -232,12 +210,47 @@ class FacebookController(BasePlatformController):
                     "Unerwarteter Fehler",
                     f"Ein unerwarteter Fehler ist beim Speichern des Accounts aufgetreten:\n\n{str(e)}"
                 )
+                return False  # FEHLER
+
+        if save_result is not None:
+            if save_result.get('success'):
+                logger.info("Account und Session erfolgreich gespeichert")
+
+                account_info = save_result.get('account_data', account_data)
+                from PyQt5.QtWidgets import QMessageBox
+                QMessageBox.information(
+                    generator_tab,
+                    "Erfolg",
+                    f"Account erfolgreich erstellt!\n\n"
+                    f"Benutzername: {account_info.get('username', '')}\n"
+                    f"Passwort: {account_info.get('password', '')}\n"
+                    f"E-Mail/Telefon: {account_info.get('email') or account_info.get('phone', '')}"
+                )
+
+                if hasattr(self, 'return_to_main_requested') and callable(self.return_to_main_requested):
+                    self.return_to_main_requested()
+
+                return True
+
+            error_msg = save_result.get('message') or save_result.get('error') or 'Unbekannter Fehler'
+            error_code = save_result.get('error_code', 0)
+            logger.error(f"Fehler beim Speichern (Code {error_code}): {error_msg}")
+
+            from views.widgets.modern_message_box import show_error
+            show_error(
+                generator_tab,
+                "Fehler beim Speichern",
+                f"Beim Speichern des Accounts ist ein Fehler aufgetreten:\n\n{error_msg}"
+            )
+            return False
+
         else:
             # Fallback: Alte Methode falls SessionController nicht verfügbar
             logger.warning("SessionController nicht verfügbar, verwende alte Methode")
             generator_tab.account_created.emit(self.platform_name, account_data)
             if hasattr(self, 'return_to_main_requested') and callable(self.return_to_main_requested):
                 self.return_to_main_requested()
+            return True  # Annahme: Erfolgreich (keine Validierung möglich)
     
     def _handle_error(self, error_msg: str):
         """Behandelt Fehler während der Account-Erstellung"""
@@ -253,13 +266,25 @@ class FacebookController(BasePlatformController):
     
     def _handle_finished(self, result: dict):
         """Behandelt das Ende der Account-Erstellung"""
-        # Forge-Dialog schließen
+        # Dialog NICHT schließen - zeige Speicherstatus
         if hasattr(self, 'forge_dialog') and self.forge_dialog:
-            self.forge_dialog.close()
-            self.forge_dialog = None
+            self.forge_dialog.set_status("Speichere Account in Datenbank...")
+            self.forge_dialog.add_log("Prüfe Account-Daten...")
 
-        # Normale Verarbeitung
-        self.handle_account_created(result)
+        # Account-Speicherung durchführen
+        save_success = self.handle_account_created(result)
+
+        # JETZT erst Dialog schließen (nach Speicherung)
+        if hasattr(self, 'forge_dialog') and self.forge_dialog:
+            if save_success:
+                self.forge_dialog.add_log("Account erfolgreich gespeichert!")
+                # Kurz warten, damit User die Meldung sieht
+                from PyQt5.QtCore import QTimer
+                QTimer.singleShot(1000, self.forge_dialog.close)
+            else:
+                # Bei Fehler sofort schließen (Fehler-Dialog wird separat angezeigt)
+                self.forge_dialog.close()
+            self.forge_dialog = None
 
     def stop_account_creation(self):
         """Stoppt die Facebook-Account-Erstellung."""
@@ -301,4 +326,4 @@ class FacebookController(BasePlatformController):
     def cleanup(self):
         """Räumt Ressourcen auf."""
         self.stop_account_creation()
-        logger.info("Facebook Controller aufgeräumt")
+        logger.info("Facebook Controller aufgeräumt")

controllers/platform_controllers/instagram_controller.py

@@ -290,42 +290,14 @@ class InstagramController(BasePlatformController):
         # Account-Daten aus dem Ergebnis holen
         account_data = result.get("account_data", {})
         
-        # Account und Session über SessionController speichern (Clean Architecture)
-        if hasattr(self, 'session_controller') and self.session_controller:
+        save_result = result.get("save_result")
+
+        if save_result is None and hasattr(self, 'session_controller') and self.session_controller:
             try:
-                session_data = result.get("session_data", {})
                 save_result = self.session_controller.create_and_save_account(
                     platform=self.platform_name,
                     account_data=account_data
                 )
-                
-                if save_result.get('success'):
-                    logger.info(f"Account und Session erfolgreich gespeichert")
-                    
-                    # Erfolgsmeldung anzeigen (nur einmal!)
-                    account_info = save_result.get('account_data', {})
-                    from PyQt5.QtWidgets import QMessageBox
-                    QMessageBox.information(
-                        generator_tab,
-                        "Erfolg",
-                        f"Account erfolgreich erstellt!\n\n"
-                        f"Benutzername: {account_info.get('username', '')}\n"
-                        f"Passwort: {account_info.get('password', '')}\n"
-                        f"E-Mail/Telefon: {account_info.get('email') or account_info.get('phone', '')}"
-                    )
-                    
-                    # Signal senden, um zur Hauptseite zurückzukehren
-                    if hasattr(self, 'return_to_main_requested') and callable(self.return_to_main_requested):
-                        self.return_to_main_requested()
-                else:
-                    error_msg = save_result.get('message', 'Unbekannter Fehler')
-                    logger.error(f"Fehler beim Speichern: {error_msg}")
-                    from views.widgets.modern_message_box import show_error
-                    show_error(
-                        generator_tab,
-                        "Fehler beim Speichern",
-                        f"Beim Speichern des Accounts ist ein Fehler aufgetreten:\n\n{error_msg}"
-                    )
             except Exception as e:
                 logger.error(f"Fehler beim Speichern des Accounts: {e}")
                 from views.widgets.modern_message_box import show_critical
@@ -334,12 +306,41 @@ class InstagramController(BasePlatformController):
                     "Unerwarteter Fehler", 
                     f"Ein unerwarteter Fehler ist beim Speichern des Accounts aufgetreten:\n\n{str(e)}"
                 )
-        else:
-            # Fallback: Alte Methode falls SessionController nicht verfügbar
-            logger.warning("SessionController nicht verfügbar, verwende alte Methode")
-            generator_tab.account_created.emit(self.platform_name, account_data)
-            if hasattr(self, 'return_to_main_requested') and callable(self.return_to_main_requested):
-                self.return_to_main_requested()
+                return
+
+        if save_result is not None:
+            if save_result.get('success'):
+                logger.info("Account und Session erfolgreich gespeichert")
+
+                account_info = save_result.get('account_data', account_data)
+                from PyQt5.QtWidgets import QMessageBox
+                QMessageBox.information(
+                    generator_tab,
+                    "Erfolg",
+                    f"Account erfolgreich erstellt!\n\n"
+                    f"Benutzername: {account_info.get('username', '')}\n"
+                    f"Passwort: {account_info.get('password', '')}\n"
+                    f"E-Mail/Telefon: {account_info.get('email') or account_info.get('phone', '')}"
+                )
+
+                if hasattr(self, 'return_to_main_requested') and callable(self.return_to_main_requested):
+                    self.return_to_main_requested()
+            else:
+                error_msg = save_result.get('message') or save_result.get('error') or 'Unbekannter Fehler'
+                logger.error(f"Fehler beim Speichern: {error_msg}")
+                from views.widgets.modern_message_box import show_error
+                show_error(
+                    generator_tab,
+                    "Fehler beim Speichern",
+                    f"Beim Speichern des Accounts ist ein Fehler aufgetreten:\n\n{error_msg}"
+                )
+            return
+
+        # Fallback: Alte Methode falls SessionController nicht verfügbar
+        logger.warning("SessionController nicht verfügbar, verwende alte Methode")
+        generator_tab.account_created.emit(self.platform_name, account_data)
+        if hasattr(self, 'return_to_main_requested') and callable(self.return_to_main_requested):
+            self.return_to_main_requested()
 
     # save_account_to_db wurde entfernt - Accounts werden jetzt über SessionController gespeichert
 

controllers/platform_controllers/tiktok_controller.py

@@ -294,42 +294,14 @@ class TikTokController(BasePlatformController):
         # Account-Daten aus dem Ergebnis holen
         account_data = result.get("account_data", {})
         
-        # Account und Session über SessionController speichern (Clean Architecture)
-        if hasattr(self, 'session_controller') and self.session_controller:
+        save_result = result.get("save_result")
+
+        if save_result is None and hasattr(self, 'session_controller') and self.session_controller:
             try:
-                session_data = result.get("session_data", {})
                 save_result = self.session_controller.create_and_save_account(
                     platform=self.platform_name,
                     account_data=account_data
                 )
-                
-                if save_result.get('success'):
-                    logger.info(f"Account und Session erfolgreich gespeichert")
-                    
-                    # Erfolgsmeldung anzeigen (nur einmal!)
-                    account_info = save_result.get('account_data', {})
-                    from PyQt5.QtWidgets import QMessageBox
-                    QMessageBox.information(
-                        generator_tab,
-                        "Erfolg",
-                        f"Account erfolgreich erstellt!\n\n"
-                        f"Benutzername: {account_info.get('username', '')}\n"
-                        f"Passwort: {account_info.get('password', '')}\n"
-                        f"E-Mail/Telefon: {account_info.get('email') or account_info.get('phone', '')}"
-                    )
-                    
-                    # Signal senden, um zur Hauptseite zurückzukehren
-                    if hasattr(self, 'return_to_main_requested') and callable(self.return_to_main_requested):
-                        self.return_to_main_requested()
-                else:
-                    error_msg = save_result.get('message', 'Unbekannter Fehler')
-                    logger.error(f"Fehler beim Speichern: {error_msg}")
-                    from views.widgets.modern_message_box import show_error
-                    show_error(
-                        generator_tab,
-                        "Fehler beim Speichern",
-                        f"Beim Speichern des Accounts ist ein Fehler aufgetreten:\n\n{error_msg}"
-                    )
             except Exception as e:
                 logger.error(f"Fehler beim Speichern des Accounts: {e}")
                 from views.widgets.modern_message_box import show_critical
@@ -338,12 +310,41 @@ class TikTokController(BasePlatformController):
                     "Unerwarteter Fehler", 
                     f"Ein unerwarteter Fehler ist beim Speichern des Accounts aufgetreten:\n\n{str(e)}"
                 )
-        else:
-            # Fallback: Alte Methode falls SessionController nicht verfügbar
-            logger.warning("SessionController nicht verfügbar, verwende alte Methode")
-            generator_tab.account_created.emit(self.platform_name, account_data)
-            if hasattr(self, 'return_to_main_requested') and callable(self.return_to_main_requested):
-                self.return_to_main_requested()
+                return
+
+        if save_result is not None:
+            if save_result.get('success'):
+                logger.info("Account und Session erfolgreich gespeichert")
+
+                account_info = save_result.get('account_data', account_data)
+                from PyQt5.QtWidgets import QMessageBox
+                QMessageBox.information(
+                    generator_tab,
+                    "Erfolg",
+                    f"Account erfolgreich erstellt!\n\n"
+                    f"Benutzername: {account_info.get('username', '')}\n"
+                    f"Passwort: {account_info.get('password', '')}\n"
+                    f"E-Mail/Telefon: {account_info.get('email') or account_info.get('phone', '')}"
+                )
+
+                if hasattr(self, 'return_to_main_requested') and callable(self.return_to_main_requested):
+                    self.return_to_main_requested()
+            else:
+                error_msg = save_result.get('message') or save_result.get('error') or 'Unbekannter Fehler'
+                logger.error(f"Fehler beim Speichern: {error_msg}")
+                from views.widgets.modern_message_box import show_error
+                show_error(
+                    generator_tab,
+                    "Fehler beim Speichern",
+                    f"Beim Speichern des Accounts ist ein Fehler aufgetreten:\n\n{error_msg}"
+                )
+            return
+
+        # Fallback: Alte Methode falls SessionController nicht verfügbar
+        logger.warning("SessionController nicht verfügbar, verwende alte Methode")
+        generator_tab.account_created.emit(self.platform_name, account_data)
+        if hasattr(self, 'return_to_main_requested') and callable(self.return_to_main_requested):
+            self.return_to_main_requested()
 
     # save_account_to_db wurde entfernt - Accounts werden jetzt über SessionController gespeichert
 

controllers/platform_controllers/x_controller.py

@@ -292,42 +292,14 @@ class XController(BasePlatformController):
         # Account-Daten aus dem Ergebnis holen
         account_data = result.get("account_data", {})
         
-        # Account und Session über SessionController speichern (Clean Architecture)
-        if hasattr(self, 'session_controller') and self.session_controller:
+        save_result = result.get("save_result")
+
+        if save_result is None and hasattr(self, 'session_controller') and self.session_controller:
             try:
-                session_data = result.get("session_data", {})
                 save_result = self.session_controller.create_and_save_account(
                     platform=self.platform_name,
                     account_data=account_data
                 )
-                
-                if save_result.get('success'):
-                    logger.info(f"Account und Session erfolgreich gespeichert")
-                    
-                    # Erfolgsmeldung anzeigen (nur einmal!)
-                    account_info = save_result.get('account_data', {})
-                    from PyQt5.QtWidgets import QMessageBox
-                    QMessageBox.information(
-                        generator_tab,
-                        "Erfolg",
-                        f"Account erfolgreich erstellt!\n\n"
-                        f"Benutzername: {account_info.get('username', '')}\n"
-                        f"Passwort: {account_info.get('password', '')}\n"
-                        f"E-Mail/Telefon: {account_info.get('email') or account_info.get('phone', '')}"
-                    )
-                    
-                    # Signal senden, um zur Hauptseite zurückzukehren
-                    if hasattr(self, 'return_to_main_requested') and callable(self.return_to_main_requested):
-                        self.return_to_main_requested()
-                else:
-                    error_msg = save_result.get('message', 'Unbekannter Fehler')
-                    logger.error(f"Fehler beim Speichern: {error_msg}")
-                    from views.widgets.modern_message_box import show_error
-                    show_error(
-                        generator_tab,
-                        "Fehler beim Speichern",
-                        f"Beim Speichern des Accounts ist ein Fehler aufgetreten:\n\n{error_msg}"
-                    )
             except Exception as e:
                 logger.error(f"Fehler beim Speichern des Accounts: {e}")
                 from views.widgets.modern_message_box import show_critical
@@ -336,12 +308,41 @@ class XController(BasePlatformController):
                     "Unerwarteter Fehler", 
                     f"Ein unerwarteter Fehler ist beim Speichern des Accounts aufgetreten:\n\n{str(e)}"
                 )
-        else:
-            # Fallback: Alte Methode falls SessionController nicht verfügbar
-            logger.warning("SessionController nicht verfügbar, verwende alte Methode")
-            generator_tab.account_created.emit(self.platform_name, account_data)
-            if hasattr(self, 'return_to_main_requested') and callable(self.return_to_main_requested):
-                self.return_to_main_requested()
+                return
+
+        if save_result is not None:
+            if save_result.get('success'):
+                logger.info("Account und Session erfolgreich gespeichert")
+
+                account_info = save_result.get('account_data', account_data)
+                from PyQt5.QtWidgets import QMessageBox
+                QMessageBox.information(
+                    generator_tab,
+                    "Erfolg",
+                    f"Account erfolgreich erstellt!\n\n"
+                    f"Benutzername: {account_info.get('username', '')}\n"
+                    f"Passwort: {account_info.get('password', '')}\n"
+                    f"E-Mail/Telefon: {account_info.get('email') or account_info.get('phone', '')}"
+                )
+
+                if hasattr(self, 'return_to_main_requested') and callable(self.return_to_main_requested):
+                    self.return_to_main_requested()
+            else:
+                error_msg = save_result.get('message') or save_result.get('error') or 'Unbekannter Fehler'
+                logger.error(f"Fehler beim Speichern: {error_msg}")
+                from views.widgets.modern_message_box import show_error
+                show_error(
+                    generator_tab,
+                    "Fehler beim Speichern",
+                    f"Beim Speichern des Accounts ist ein Fehler aufgetreten:\n\n{error_msg}"
+                )
+            return
+
+        # Fallback: Alte Methode falls SessionController nicht verfügbar
+        logger.warning("SessionController nicht verfügbar, verwende alte Methode")
+        generator_tab.account_created.emit(self.platform_name, account_data)
+        if hasattr(self, 'return_to_main_requested') and callable(self.return_to_main_requested):
+            self.return_to_main_requested()
 
     # save_account_to_db wurde entfernt - Accounts werden jetzt über SessionController gespeichert