Initial commit

social_networks/x/x_ui_helper.py

@@ -0,0 +1,424 @@
+# social_networks/x/x_ui_helper.py
+
+"""
+X (Twitter) UI Helper - Hilfsklasse für UI-Interaktionen bei X
+"""
+
+import time
+from typing import Optional, List, Dict, Any, Tuple
+from playwright.sync_api import Page, ElementHandle
+
+from .x_selectors import XSelectors
+from utils.logger import setup_logger
+
+# Konfiguriere Logger
+logger = setup_logger("x_ui_helper")
+
+class XUIHelper:
+    """
+    Hilfsklasse für UI-Interaktionen mit X.
+    Bietet wiederverwendbare Methoden für häufige UI-Operationen.
+    """
+    
+    def __init__(self, automation):
+        """
+        Initialisiert den X UI Helper.
+        
+        Args:
+            automation: Referenz auf die Hauptautomatisierungsklasse
+        """
+        self.automation = automation
+        self.selectors = XSelectors()
+        
+        logger.debug("X UI Helper initialisiert")
+    
+    def wait_for_element(self, selector: str, timeout: int = 10000, 
+                        state: str = "visible") -> Optional[ElementHandle]:
+        """
+        Wartet auf ein Element und gibt es zurück.
+        
+        Args:
+            selector: CSS-Selektor
+            timeout: Timeout in Millisekunden
+            state: Gewünschter Zustand ("visible", "attached", "detached", "hidden")
+            
+        Returns:
+            Optional[ElementHandle]: Element oder None
+        """
+        try:
+            page = self.automation.browser.page
+            element = page.wait_for_selector(selector, timeout=timeout, state=state)
+            return element
+        except Exception as e:
+            logger.debug(f"Element nicht gefunden: {selector} - {e}")
+            return None
+    
+    def click_element_safely(self, selector: str, timeout: int = 10000, 
+                           retry_count: int = 3) -> bool:
+        """
+        Klickt sicher auf ein Element mit Retry-Logik.
+        
+        Args:
+            selector: CSS-Selektor
+            timeout: Timeout in Millisekunden
+            retry_count: Anzahl der Wiederholungsversuche
+            
+        Returns:
+            bool: True bei Erfolg, False bei Fehler
+        """
+        page = self.automation.browser.page
+        
+        for attempt in range(retry_count):
+            try:
+                # Warte auf Element
+                element = self.wait_for_element(selector, timeout)
+                if not element:
+                    logger.warning(f"Element nicht gefunden beim {attempt + 1}. Versuch: {selector}")
+                    continue
+                
+                # Scrolle zum Element
+                element.scroll_into_view_if_needed()
+                
+                # Warte kurz
+                self.automation.human_behavior.random_delay(0.3, 0.7)
+                
+                # Klicke
+                element.click()
+                logger.info(f"Element erfolgreich geklickt: {selector}")
+                return True
+                
+            except Exception as e:
+                logger.warning(f"Fehler beim Klicken (Versuch {attempt + 1}): {e}")
+                if attempt < retry_count - 1:
+                    self.automation.human_behavior.random_delay(1, 2)
+                    continue
+        
+        logger.error(f"Konnte Element nicht klicken nach {retry_count} Versuchen: {selector}")
+        return False
+    
+    def type_text_safely(self, selector: str, text: str, clear_first: bool = True,
+                        timeout: int = 10000) -> bool:
+        """
+        Gibt Text sicher in ein Eingabefeld ein.
+        
+        Args:
+            selector: CSS-Selektor
+            text: Einzugebender Text
+            clear_first: Ob das Feld zuerst geleert werden soll
+            timeout: Timeout in Millisekunden
+            
+        Returns:
+            bool: True bei Erfolg, False bei Fehler
+        """
+        try:
+            element = self.wait_for_element(selector, timeout)
+            if not element:
+                logger.error(f"Eingabefeld nicht gefunden: {selector}")
+                return False
+            
+            # Fokussiere das Element
+            element.focus()
+            self.automation.human_behavior.random_delay(0.2, 0.5)
+            
+            # Leere das Feld wenn gewünscht
+            if clear_first:
+                element.click(click_count=3)  # Alles auswählen
+                self.automation.human_behavior.random_delay(0.1, 0.3)
+                element.press("Delete")
+                self.automation.human_behavior.random_delay(0.2, 0.5)
+            
+            # Tippe den Text
+            self.automation.human_behavior.type_text(element, text)
+            
+            logger.info(f"Text erfolgreich eingegeben in: {selector}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Fehler beim Texteingeben: {e}")
+            return False
+    
+    def select_dropdown_option(self, selector: str, value: str, timeout: int = 10000) -> bool:
+        """
+        Wählt eine Option aus einem Dropdown-Menü.
+        
+        Args:
+            selector: CSS-Selektor des Select-Elements
+            value: Wert der zu wählenden Option
+            timeout: Timeout in Millisekunden
+            
+        Returns:
+            bool: True bei Erfolg, False bei Fehler
+        """
+        try:
+            page = self.automation.browser.page
+            
+            # Warte auf Select-Element
+            select = self.wait_for_element(selector, timeout)
+            if not select:
+                logger.error(f"Dropdown nicht gefunden: {selector}")
+                return False
+            
+            # Wähle Option
+            page.select_option(selector, value)
+            
+            logger.info(f"Option '{value}' ausgewählt in: {selector}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Fehler beim Auswählen der Dropdown-Option: {e}")
+            return False
+    
+    def handle_modal(self, action: str = "accept", timeout: int = 5000) -> bool:
+        """
+        Behandelt modale Dialoge.
+        
+        Args:
+            action: "accept", "dismiss" oder "close"
+            timeout: Timeout in Millisekunden
+            
+        Returns:
+            bool: True wenn Modal behandelt wurde, False sonst
+        """
+        try:
+            page = self.automation.browser.page
+            
+            # Prüfe ob Modal vorhanden
+            modal = self.wait_for_element(self.selectors.MODALS["modal_container"], timeout)
+            if not modal:
+                logger.debug("Kein Modal gefunden")
+                return False
+            
+            if action == "accept":
+                # Suche Bestätigen-Button
+                if self.click_element_safely(self.selectors.MODALS["confirm_button"], timeout=3000):
+                    logger.info("Modal bestätigt")
+                    return True
+                    
+            elif action == "dismiss":
+                # Suche Abbrechen-Button
+                if self.click_element_safely(self.selectors.MODALS["cancel_button"], timeout=3000):
+                    logger.info("Modal abgebrochen")
+                    return True
+                    
+            elif action == "close":
+                # Suche Schließen-Button
+                close_selectors = [
+                    self.selectors.MODALS["modal_close_button"],
+                    self.selectors.MODALS["modal_close_button_en"]
+                ]
+                for selector in close_selectors:
+                    if self.click_element_safely(selector, timeout=3000):
+                        logger.info("Modal geschlossen")
+                        return True
+            
+            logger.warning(f"Konnte Modal nicht mit Aktion '{action}' behandeln")
+            return False
+            
+        except Exception as e:
+            logger.error(f"Fehler bei Modal-Behandlung: {e}")
+            return False
+    
+    def check_for_errors(self, timeout: int = 2000) -> Optional[str]:
+        """
+        Prüft auf Fehlermeldungen auf der Seite.
+        
+        Args:
+            timeout: Timeout in Millisekunden
+            
+        Returns:
+            Optional[str]: Fehlermeldung wenn gefunden, sonst None
+        """
+        try:
+            page = self.automation.browser.page
+            
+            # Prüfe alle Fehler-Selektoren
+            for category, selector in [
+                ("error_message", self.selectors.ERRORS["error_message"]),
+                ("error_alert", self.selectors.ERRORS["error_alert"]),
+                ("rate_limit", self.selectors.ERRORS["rate_limit_message"]),
+                ("suspended", self.selectors.ERRORS["suspended_message"]),
+                ("email_taken", self.selectors.ERRORS["email_taken"]),
+                ("invalid_credentials", self.selectors.ERRORS["invalid_credentials"])
+            ]:
+                error_element = self.wait_for_element(selector, timeout=timeout)
+                if error_element:
+                    error_text = error_element.text_content()
+                    logger.warning(f"Fehler gefunden ({category}): {error_text}")
+                    return error_text
+            
+            return None
+            
+        except Exception as e:
+            logger.debug(f"Fehler bei Fehlerprüfung: {e}")
+            return None
+    
+    def wait_for_navigation(self, timeout: int = 30000) -> bool:
+        """
+        Wartet auf Navigation/Seitenwechsel.
+        
+        Args:
+            timeout: Timeout in Millisekunden
+            
+        Returns:
+            bool: True wenn Navigation erfolgt ist
+        """
+        try:
+            page = self.automation.browser.page
+            
+            with page.expect_navigation(timeout=timeout):
+                pass
+            
+            logger.info("Navigation abgeschlossen")
+            return True
+            
+        except Exception as e:
+            logger.debug(f"Keine Navigation erkannt: {e}")
+            return False
+    
+    def scroll_to_bottom(self, smooth: bool = True, pause_time: float = 1.0):
+        """
+        Scrollt zum Ende der Seite.
+        
+        Args:
+            smooth: Ob sanft gescrollt werden soll
+            pause_time: Pausenzeit nach dem Scrollen
+        """
+        try:
+            page = self.automation.browser.page
+            
+            if smooth:
+                # Sanftes Scrollen in Schritten
+                page.evaluate("""
+                    async () => {
+                        const distance = 100;
+                        const delay = 50;
+                        const timer = setInterval(() => {
+                            window.scrollBy(0, distance);
+                            if ((window.innerHeight + window.scrollY) >= document.body.offsetHeight) {
+                                clearInterval(timer);
+                            }
+                        }, delay);
+                    }
+                """)
+            else:
+                # Direktes Scrollen
+                page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
+            
+            time.sleep(pause_time)
+            logger.debug("Zum Seitenende gescrollt")
+            
+        except Exception as e:
+            logger.error(f"Fehler beim Scrollen: {e}")
+    
+    def take_element_screenshot(self, selector: str, filename: str, 
+                              timeout: int = 10000) -> bool:
+        """
+        Macht einen Screenshot von einem spezifischen Element.
+        
+        Args:
+            selector: CSS-Selektor
+            filename: Dateiname für den Screenshot
+            timeout: Timeout in Millisekunden
+            
+        Returns:
+            bool: True bei Erfolg, False bei Fehler
+        """
+        try:
+            element = self.wait_for_element(selector, timeout)
+            if not element:
+                logger.error(f"Element für Screenshot nicht gefunden: {selector}")
+                return False
+            
+            # Screenshot vom Element
+            element.screenshot(path=f"{self.automation.screenshots_dir}/{filename}")
+            logger.info(f"Element-Screenshot gespeichert: {filename}")
+            return True
+            
+        except Exception as e:
+            logger.error(f"Fehler beim Element-Screenshot: {e}")
+            return False
+    
+    def get_element_text(self, selector: str, timeout: int = 10000) -> Optional[str]:
+        """
+        Holt den Text eines Elements.
+        
+        Args:
+            selector: CSS-Selektor
+            timeout: Timeout in Millisekunden
+            
+        Returns:
+            Optional[str]: Text des Elements oder None
+        """
+        try:
+            element = self.wait_for_element(selector, timeout)
+            if element:
+                return element.text_content()
+            return None
+        except Exception as e:
+            logger.error(f"Fehler beim Abrufen des Element-Texts: {e}")
+            return None
+    
+    def is_element_visible(self, selector: str, timeout: int = 1000) -> bool:
+        """
+        Prüft ob ein Element sichtbar ist.
+        
+        Args:
+            selector: CSS-Selektor
+            timeout: Timeout in Millisekunden
+            
+        Returns:
+            bool: True wenn sichtbar, False sonst
+        """
+        try:
+            page = self.automation.browser.page
+            # is_visible hat kein timeout parameter in Playwright
+            # Verwende wait_for_selector für timeout-Funktionalität
+            try:
+                element = page.wait_for_selector(selector, timeout=timeout, state="visible")
+                return element is not None
+            except:
+                return False
+        except Exception as e:
+            logger.debug(f"Element nicht sichtbar: {selector} - {e}")
+            return False
+    
+    def wait_for_any_selector(self, selectors: List[str], timeout: int = 10000) -> Optional[Tuple[str, ElementHandle]]:
+        """
+        Wartet auf eines von mehreren Elementen.
+        
+        Args:
+            selectors: Liste von CSS-Selektoren
+            timeout: Timeout in Millisekunden
+            
+        Returns:
+            Optional[Tuple[str, ElementHandle]]: Tuple aus Selektor und Element oder None
+        """
+        try:
+            page = self.automation.browser.page
+            
+            # Erstelle Promise für jeden Selektor
+            promises = []
+            for selector in selectors:
+                promises.append(page.wait_for_selector(selector, timeout=timeout))
+            
+            # Warte auf das erste Element
+            element = page.evaluate(f"""
+                () => {{
+                    const selectors = {selectors};
+                    for (const selector of selectors) {{
+                        const element = document.querySelector(selector);
+                        if (element) return {{selector, found: true}};
+                    }}
+                    return {{found: false}};
+                }}
+            """)
+            
+            if element["found"]:
+                actual_element = page.query_selector(element["selector"])
+                return (element["selector"], actual_element)
+            
+            return None
+            
+        except Exception as e:
+            logger.debug(f"Keines der Elemente gefunden: {e}")
+            return None