240 Zeilen
9.5 KiB
Python
240 Zeilen
9.5 KiB
Python
"""
|
|
VK Automatisierung - Hauptklasse
|
|
"""
|
|
|
|
import logging
|
|
import time
|
|
import random
|
|
from typing import Dict, Optional, Tuple
|
|
from playwright.sync_api import Page
|
|
|
|
from social_networks.base_automation import BaseAutomation
|
|
from social_networks.vk import vk_selectors as selectors
|
|
from social_networks.vk.vk_ui_helper import VKUIHelper
|
|
from social_networks.vk.vk_registration import VKRegistration
|
|
from social_networks.vk.vk_login import VKLogin
|
|
from social_networks.vk.vk_verification import VKVerification
|
|
from social_networks.vk.vk_utils import VKUtils
|
|
|
|
logger = logging.getLogger("vk_automation")
|
|
|
|
class VKAutomation(BaseAutomation):
|
|
"""
|
|
VK-spezifische Automatisierung
|
|
"""
|
|
|
|
def __init__(self, **kwargs):
|
|
"""
|
|
Initialisiert die VK-Automatisierung
|
|
"""
|
|
super().__init__(**kwargs)
|
|
self.platform_name = "vk"
|
|
self.ui_helper = None
|
|
self.registration = None
|
|
self.login_helper = None
|
|
self.verification = None
|
|
self.utils = None
|
|
|
|
def _initialize_helpers(self, page: Page):
|
|
"""
|
|
Initialisiert die Hilfsklassen
|
|
"""
|
|
self.ui_helper = VKUIHelper(page, self.screenshots_dir, self.save_screenshots)
|
|
self.registration = VKRegistration(page, self.ui_helper, self.screenshots_dir, self.save_screenshots)
|
|
self.login_helper = VKLogin(page, self.ui_helper, self.screenshots_dir, self.save_screenshots)
|
|
self.verification = VKVerification(page, self.ui_helper, self.email_handler, self.screenshots_dir, self.save_screenshots)
|
|
self.utils = VKUtils()
|
|
|
|
def register_account(self, full_name: str, age: int, registration_method: str = "phone",
|
|
phone_number: str = None, **kwargs) -> Dict[str, any]:
|
|
"""
|
|
Erstellt einen neuen VK-Account
|
|
|
|
Args:
|
|
full_name: Vollständiger Name für den Account
|
|
age: Alter des Benutzers
|
|
registration_method: Registrierungsmethode (nur "phone" für VK)
|
|
phone_number: Telefonnummer (erforderlich für VK)
|
|
**kwargs: Weitere optionale Parameter
|
|
"""
|
|
try:
|
|
logger.info(f"Starte VK Account-Registrierung für {full_name}")
|
|
|
|
# Erstelle account_data aus den Parametern
|
|
account_data = {
|
|
"full_name": full_name,
|
|
"first_name": kwargs.get("first_name", full_name.split()[0] if full_name else ""),
|
|
"last_name": kwargs.get("last_name", full_name.split()[-1] if full_name and len(full_name.split()) > 1 else ""),
|
|
"age": age,
|
|
"birthday": kwargs.get("birthday", self._generate_birthday(age)),
|
|
"gender": kwargs.get("gender", random.choice(["male", "female"])),
|
|
"username": kwargs.get("username", ""),
|
|
"password": kwargs.get("password", ""),
|
|
"email": kwargs.get("email", ""),
|
|
"phone": phone_number or ""
|
|
}
|
|
|
|
# Initialisiere Browser, falls noch nicht geschehen
|
|
if not self.browser or not hasattr(self.browser, 'page'):
|
|
if not self._initialize_browser():
|
|
return {
|
|
"success": False,
|
|
"error": "Browser konnte nicht initialisiert werden",
|
|
"message": "Browser-Initialisierung fehlgeschlagen"
|
|
}
|
|
|
|
# Page-Objekt holen
|
|
page = self.browser.page
|
|
self._initialize_helpers(page)
|
|
|
|
# VK Homepage öffnen
|
|
logger.info("Navigiere zu VK Homepage")
|
|
page.goto(selectors.BASE_URL, wait_until="domcontentloaded")
|
|
time.sleep(random.uniform(2, 4))
|
|
|
|
# Screenshot der Startseite
|
|
self.ui_helper.take_screenshot("vk_homepage")
|
|
|
|
# Cookie Banner handhaben
|
|
self._handle_cookie_banner(page)
|
|
|
|
# "Konto erstellen" Button klicken
|
|
logger.info("Suche 'Konto erstellen' Button")
|
|
try:
|
|
# Versuche verschiedene Selektoren
|
|
create_button_clicked = False
|
|
|
|
# Versuche CSS Selektor
|
|
if page.locator(selectors.CREATE_ACCOUNT_BUTTON).count() > 0:
|
|
page.click(selectors.CREATE_ACCOUNT_BUTTON)
|
|
create_button_clicked = True
|
|
logger.info("Button mit CSS Selektor gefunden und geklickt")
|
|
|
|
# Versuche XPath wenn CSS nicht funktioniert
|
|
elif page.locator(selectors.CREATE_ACCOUNT_BUTTON_XPATH).count() > 0:
|
|
page.click(selectors.CREATE_ACCOUNT_BUTTON_XPATH)
|
|
create_button_clicked = True
|
|
logger.info("Button mit XPath gefunden und geklickt")
|
|
|
|
# Versuche alternativen Selektor
|
|
elif page.locator(selectors.CREATE_ACCOUNT_BUTTON_ALTERNATE).count() > 0:
|
|
page.click(selectors.CREATE_ACCOUNT_BUTTON_ALTERNATE)
|
|
create_button_clicked = True
|
|
logger.info("Button mit alternativem Selektor gefunden und geklickt")
|
|
|
|
if not create_button_clicked:
|
|
raise Exception("'Konto erstellen' Button nicht gefunden")
|
|
|
|
time.sleep(random.uniform(2, 3))
|
|
|
|
except Exception as e:
|
|
logger.error(f"Fehler beim Klicken des 'Konto erstellen' Buttons: {e}")
|
|
self.ui_helper.take_screenshot("create_account_button_error")
|
|
raise
|
|
|
|
# Registrierungsformular ausfüllen
|
|
registration_result = self.registration.fill_registration_form(account_data)
|
|
if not registration_result["success"]:
|
|
return registration_result
|
|
|
|
# Telefonnummer-Verifizierung
|
|
verification_result = self.verification.handle_phone_verification(account_data)
|
|
if not verification_result["success"]:
|
|
return verification_result
|
|
|
|
# Erfolg
|
|
logger.info("VK Account-Registrierung erfolgreich abgeschlossen")
|
|
return {
|
|
"success": True,
|
|
"username": account_data.get("username"),
|
|
"password": account_data.get("password"),
|
|
"email": account_data.get("email"),
|
|
"phone": account_data.get("phone"),
|
|
"message": "Account erfolgreich erstellt"
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Fehler bei der VK-Registrierung: {str(e)}")
|
|
return {
|
|
"success": False,
|
|
"error": str(e),
|
|
"message": f"Registrierung fehlgeschlagen: {str(e)}"
|
|
}
|
|
finally:
|
|
self._close_browser()
|
|
|
|
def login(self, username: str, password: str) -> Dict[str, any]:
|
|
"""
|
|
Meldet sich bei einem bestehenden VK-Account an
|
|
"""
|
|
try:
|
|
logger.info(f"Starte VK Login für {username}")
|
|
|
|
# Initialisiere Browser, falls noch nicht geschehen
|
|
if not self.browser or not hasattr(self.browser, 'page'):
|
|
if not self._initialize_browser():
|
|
return {
|
|
"success": False,
|
|
"error": "Browser konnte nicht initialisiert werden",
|
|
"message": "Browser-Initialisierung fehlgeschlagen"
|
|
}
|
|
|
|
# Page-Objekt holen
|
|
page = self.browser.page
|
|
self._initialize_helpers(page)
|
|
|
|
# Login durchführen
|
|
return self.login_helper.login(username, password)
|
|
|
|
except Exception as e:
|
|
logger.error(f"Fehler beim VK Login: {str(e)}")
|
|
return {
|
|
"success": False,
|
|
"error": str(e),
|
|
"message": f"Login fehlgeschlagen: {str(e)}"
|
|
}
|
|
finally:
|
|
self._close_browser()
|
|
|
|
def _handle_cookie_banner(self, page: Page):
|
|
"""
|
|
Handhabt Cookie-Banner falls vorhanden
|
|
"""
|
|
try:
|
|
if page.locator(selectors.COOKIE_BANNER).count() > 0:
|
|
logger.info("Cookie Banner gefunden")
|
|
if page.locator(selectors.COOKIE_ACCEPT_BUTTON).count() > 0:
|
|
page.click(selectors.COOKIE_ACCEPT_BUTTON)
|
|
logger.info("Cookie Banner akzeptiert")
|
|
time.sleep(random.uniform(1, 2))
|
|
except Exception as e:
|
|
logger.warning(f"Fehler beim Handhaben des Cookie Banners: {e}")
|
|
|
|
def get_account_info(self) -> Dict[str, any]:
|
|
"""
|
|
Ruft Informationen über den aktuellen Account ab
|
|
"""
|
|
# TODO: Implementierung
|
|
return {
|
|
"success": False,
|
|
"message": "Noch nicht implementiert"
|
|
}
|
|
|
|
def logout(self) -> bool:
|
|
"""
|
|
Meldet sich vom aktuellen Account ab
|
|
"""
|
|
# TODO: Implementierung
|
|
return False
|
|
|
|
def _generate_birthday(self, age: int) -> str:
|
|
"""
|
|
Generiert ein Geburtsdatum basierend auf dem Alter
|
|
"""
|
|
from datetime import datetime, timedelta
|
|
today = datetime.now()
|
|
birth_year = today.year - age
|
|
# Zufälliger Tag im Jahr
|
|
random_days = random.randint(0, 364)
|
|
birthday = datetime(birth_year, 1, 1) + timedelta(days=random_days)
|
|
return birthday.strftime("%Y-%m-%d") |