159 Zeilen
6.2 KiB
Python
159 Zeilen
6.2 KiB
Python
"""
|
|
Controller für VK-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.vk.vk_automation import VKAutomation
|
|
from utils.logger import setup_logger
|
|
|
|
logger = setup_logger("vk_controller")
|
|
|
|
class VKWorkerThread(BaseAccountCreationWorkerThread):
|
|
"""Worker-Thread für VK-Account-Erstellung"""
|
|
|
|
def __init__(self, params, session_controller=None, generator_tab=None):
|
|
super().__init__(params, "VK", session_controller, generator_tab)
|
|
|
|
def get_automation_class(self):
|
|
"""Gibt die VK-Automation-Klasse zurück"""
|
|
return VKAutomation
|
|
|
|
def get_error_interpretations(self) -> Dict[str, str]:
|
|
"""VK-spezifische Fehlerinterpretationen"""
|
|
return {
|
|
"phone": "Diese Telefonnummer wird bereits verwendet oder ist ungültig.",
|
|
"code": "Der Verifizierungscode ist ungültig.",
|
|
"blocked": "Zu viele Versuche. Bitte versuchen Sie es später erneut.",
|
|
"captcha": "Bitte lösen Sie das Captcha."
|
|
}
|
|
|
|
|
|
class VKController(BasePlatformController):
|
|
"""Controller für VK-Funktionalität"""
|
|
|
|
def __init__(self, db_manager, proxy_rotator, email_handler, language_manager, theme_manager=None):
|
|
super().__init__("vk", db_manager, proxy_rotator, email_handler, language_manager)
|
|
logger.info("VK Controller initialisiert")
|
|
|
|
def get_worker_thread_class(self):
|
|
"""Gibt die Worker-Thread-Klasse für VK zurück"""
|
|
return VKWorkerThread
|
|
|
|
def get_platform_display_name(self) -> str:
|
|
"""Gibt den Anzeigenamen der Plattform zurück"""
|
|
return "VK"
|
|
|
|
def validate_account_data(self, account_data: Dict[str, Any]) -> Dict[str, Any]:
|
|
"""Validiert die Account-Daten für VK"""
|
|
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")
|
|
|
|
if not account_data.get("phone"):
|
|
errors.append("Telefonnummer ist für VK erforderlich")
|
|
|
|
if errors:
|
|
return {
|
|
"valid": False,
|
|
"errors": errors
|
|
}
|
|
|
|
return {
|
|
"valid": True,
|
|
"errors": []
|
|
}
|
|
|
|
def get_default_settings(self) -> Dict[str, Any]:
|
|
"""Gibt die Standard-Einstellungen für VK zurück"""
|
|
settings = super().get_default_settings()
|
|
settings.update({
|
|
"require_phone": True,
|
|
"require_email": False,
|
|
"default_country_code": "+7", # Russland
|
|
"supported_languages": ["ru", "en", "de"],
|
|
"default_language": "ru"
|
|
})
|
|
return settings
|
|
|
|
def start_account_creation(self, params):
|
|
"""Startet die VK-Account-Erstellung."""
|
|
logger.info(f"Starte VK Account-Erstellung mit Parametern: {params}")
|
|
|
|
# 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, "VK")
|
|
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 VK 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
|
|
|
|
self.worker_thread = VKWorkerThread(
|
|
params,
|
|
session_controller=session_controller,
|
|
generator_tab=generator_tab_ref
|
|
)
|
|
|
|
# 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(self._handle_finished)
|
|
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))
|
|
|
|
self.worker_thread.start()
|
|
|
|
# Dialog anzeigen
|
|
self.forge_dialog.start_animation()
|
|
self.forge_dialog.show() |