231 Zeilen
8.8 KiB
Python
231 Zeilen
8.8 KiB
Python
"""
|
|
Hauptcontroller für die Social Media Account Generator Anwendung.
|
|
"""
|
|
|
|
import logging
|
|
from PyQt5.QtWidgets import QMessageBox, QApplication
|
|
|
|
from views.main_window import MainWindow
|
|
from controllers.platform_controllers.instagram_controller import InstagramController
|
|
from controllers.platform_controllers.tiktok_controller import TikTokController
|
|
from controllers.account_controller import AccountController
|
|
from controllers.settings_controller import SettingsController
|
|
|
|
from database.db_manager import DatabaseManager
|
|
from utils.proxy_rotator import ProxyRotator
|
|
from utils.email_handler import EmailHandler
|
|
from utils.theme_manager import ThemeManager
|
|
from localization.language_manager import LanguageManager
|
|
from licensing.license_manager import LicenseManager
|
|
from updates.update_checker import UpdateChecker
|
|
|
|
logger = logging.getLogger("main")
|
|
|
|
class MainController:
|
|
"""Hauptcontroller, der die Anwendung koordiniert."""
|
|
|
|
def __init__(self, app):
|
|
# QApplication Referenz speichern
|
|
self.app = app
|
|
|
|
# Theme Manager initialisieren
|
|
self.theme_manager = ThemeManager(app)
|
|
|
|
# Language Manager initialisieren
|
|
self.language_manager = LanguageManager(app)
|
|
|
|
# Modelle initialisieren
|
|
self.db_manager = DatabaseManager()
|
|
self.proxy_rotator = ProxyRotator()
|
|
self.email_handler = EmailHandler()
|
|
self.license_manager = LicenseManager()
|
|
self.update_checker = UpdateChecker()
|
|
|
|
# Haupt-View erstellen
|
|
self.view = MainWindow(self.theme_manager, self.language_manager, self.db_manager)
|
|
|
|
# Untercontroller erstellen
|
|
self.account_controller = AccountController(self.db_manager)
|
|
self.settings_controller = SettingsController(
|
|
self.proxy_rotator,
|
|
self.email_handler,
|
|
self.license_manager
|
|
)
|
|
|
|
# Plattform-Controller initialisieren
|
|
self.platform_controllers = {}
|
|
|
|
# Instagram Controller hinzufügen
|
|
self.platform_controllers["instagram"] = InstagramController(
|
|
self.db_manager,
|
|
self.proxy_rotator,
|
|
self.email_handler,
|
|
self.language_manager
|
|
)
|
|
|
|
# TikTok Controller hinzufügen
|
|
self.platform_controllers["tiktok"] = TikTokController(
|
|
self.db_manager,
|
|
self.proxy_rotator,
|
|
self.email_handler,
|
|
self.language_manager
|
|
)
|
|
|
|
# Hier können in Zukunft weitere Controller hinzugefügt werden:
|
|
# self.platform_controllers["facebook"] = FacebookController(...)
|
|
# self.platform_controllers["twitter"] = TwitterController(...)
|
|
# self.platform_controllers["tiktok"] = TikTokController(...)
|
|
|
|
# Signals verbinden
|
|
self.connect_signals()
|
|
|
|
# Lizenz überprüfen
|
|
self.check_license()
|
|
|
|
# Auf Updates prüfen
|
|
self.check_for_updates()
|
|
|
|
# Hauptfenster anzeigen
|
|
self.view.show()
|
|
|
|
def connect_signals(self):
|
|
"""Verbindet alle Signale mit den entsprechenden Slots."""
|
|
# Plattformauswahl-Signal verbinden
|
|
self.view.platform_selected.connect(self.on_platform_selected)
|
|
|
|
# Zurück-Button verbinden
|
|
self.view.back_to_selector_requested.connect(self.show_platform_selector)
|
|
|
|
# Theme-Toggle verbinden
|
|
self.view.theme_toggled.connect(self.on_theme_toggled)
|
|
|
|
def on_platform_selected(self, platform: str):
|
|
"""Wird aufgerufen, wenn eine Plattform ausgewählt wird."""
|
|
logger.info(f"Plattform ausgewählt: {platform}")
|
|
|
|
# Aktuelle Plattform setzen
|
|
self.current_platform = platform.lower()
|
|
|
|
# Prüfen, ob die Plattform unterstützt wird
|
|
if self.current_platform not in self.platform_controllers:
|
|
logger.error(f"Plattform '{platform}' wird nicht unterstützt")
|
|
QMessageBox.critical(
|
|
self.view,
|
|
"Nicht unterstützt",
|
|
f"Die Plattform '{platform}' ist noch nicht implementiert."
|
|
)
|
|
return
|
|
|
|
# Plattformspezifischen Controller abrufen
|
|
platform_controller = self.platform_controllers.get(self.current_platform)
|
|
|
|
# Plattform-View initialisieren
|
|
self.view.init_platform_ui(platform, platform_controller)
|
|
|
|
# Tab-Hooks verbinden
|
|
self.connect_tab_hooks(platform_controller)
|
|
|
|
# Plattformspezifische Ansicht anzeigen
|
|
self.view.show_platform_ui()
|
|
|
|
def on_theme_toggled(self):
|
|
"""Wird aufgerufen, wenn das Theme gewechselt wird."""
|
|
if self.theme_manager:
|
|
theme_name = self.theme_manager.get_current_theme()
|
|
logger.info(f"Theme gewechselt zu: {theme_name}")
|
|
|
|
# Hier kann zusätzliche Logik für Theme-Wechsel hinzugefügt werden
|
|
# z.B. UI-Elemente aktualisieren, die nicht automatisch aktualisiert werden
|
|
|
|
def connect_tab_hooks(self, platform_controller):
|
|
"""Verbindet die Tab-Hooks mit dem Plattform-Controller."""
|
|
# Generator-Tab-Hooks
|
|
if hasattr(platform_controller, "get_generator_tab"):
|
|
generator_tab = platform_controller.get_generator_tab()
|
|
generator_tab.account_created.connect(self.account_controller.on_account_created)
|
|
|
|
# Einstellungen-Tab-Hooks
|
|
if hasattr(platform_controller, "get_settings_tab"):
|
|
settings_tab = platform_controller.get_settings_tab()
|
|
settings_tab.proxy_settings_saved.connect(self.settings_controller.save_proxy_settings)
|
|
settings_tab.proxy_tested.connect(self.settings_controller.test_proxy)
|
|
settings_tab.email_settings_saved.connect(self.settings_controller.save_email_settings)
|
|
settings_tab.email_tested.connect(self.settings_controller.test_email)
|
|
settings_tab.license_activated.connect(self.settings_controller.activate_license)
|
|
|
|
def show_platform_selector(self):
|
|
"""Zeigt den Plattform-Selektor an."""
|
|
logger.info("Zurück zur Plattformauswahl")
|
|
self.view.show_platform_selector()
|
|
if hasattr(self.view, "platform_selector"):
|
|
self.view.platform_selector.load_accounts()
|
|
|
|
def check_license(self):
|
|
"""Überprüft, ob eine gültige Lizenz vorhanden ist."""
|
|
is_licensed = self.license_manager.is_licensed()
|
|
|
|
if not is_licensed:
|
|
license_info = self.license_manager.get_license_info()
|
|
status = license_info.get("status_text", "Inaktiv")
|
|
|
|
# Wenn keine Lizenz vorhanden ist, zeigen wir eine Warnung an
|
|
QMessageBox.warning(
|
|
self.view,
|
|
"Keine gültige Lizenz",
|
|
f"Status: {status}\n\nBitte aktivieren Sie eine Lizenz, um die Software zu nutzen."
|
|
)
|
|
return False
|
|
|
|
return True
|
|
|
|
def check_for_updates(self):
|
|
"""Prüft auf Updates."""
|
|
try:
|
|
update_info = self.update_checker.check_for_updates()
|
|
|
|
if update_info["has_update"]:
|
|
reply = QMessageBox.question(
|
|
self.view,
|
|
"Update verfügbar",
|
|
f"Eine neue Version ist verfügbar: {update_info['latest_version']}\n"
|
|
f"(Aktuelle Version: {update_info['current_version']})\n\n"
|
|
f"Release-Datum: {update_info['release_date']}\n"
|
|
f"Release-Notes:\n{update_info['release_notes']}\n\n"
|
|
"Möchten Sie das Update jetzt herunterladen?",
|
|
QMessageBox.Yes | QMessageBox.No,
|
|
QMessageBox.Yes
|
|
)
|
|
|
|
if reply == QMessageBox.Yes:
|
|
self.download_update(update_info)
|
|
except Exception as e:
|
|
logger.error(f"Fehler bei der Update-Prüfung: {e}")
|
|
|
|
def download_update(self, update_info):
|
|
"""Lädt ein Update herunter."""
|
|
try:
|
|
download_result = self.update_checker.download_update(
|
|
update_info["download_url"],
|
|
update_info["latest_version"]
|
|
)
|
|
|
|
if download_result["success"]:
|
|
QMessageBox.information(
|
|
self.view,
|
|
"Download erfolgreich",
|
|
f"Update wurde heruntergeladen: {download_result['file_path']}\n\n"
|
|
"Bitte schließen Sie die Anwendung und führen Sie das Update aus."
|
|
)
|
|
else:
|
|
QMessageBox.warning(
|
|
self.view,
|
|
"Download fehlgeschlagen",
|
|
f"Fehler beim Herunterladen des Updates:\n{download_result['error']}"
|
|
)
|
|
except Exception as e:
|
|
logger.error(f"Fehler beim Herunterladen des Updates: {e}")
|
|
QMessageBox.critical(
|
|
self.view,
|
|
"Fehler",
|
|
f"Fehler beim Herunterladen des Updates:\n{str(e)}"
|
|
) |