316 Zeilen
13 KiB
Python
316 Zeilen
13 KiB
Python
"""
|
|
Tab für die Einstellungen der Anwendung.
|
|
"""
|
|
|
|
import logging
|
|
from PyQt5.QtWidgets import (
|
|
QWidget, QVBoxLayout, QHBoxLayout, QFormLayout,
|
|
QGroupBox, QLabel, QLineEdit, QSpinBox, QTextEdit,
|
|
QPushButton, QCheckBox, QComboBox
|
|
)
|
|
from PyQt5.QtCore import pyqtSignal, Qt
|
|
|
|
logger = logging.getLogger("settings_tab")
|
|
|
|
class SettingsTab(QWidget):
|
|
"""Widget für den Einstellungen-Tab."""
|
|
|
|
# Signale
|
|
proxy_settings_saved = pyqtSignal(dict)
|
|
proxy_tested = pyqtSignal(str) # proxy_type
|
|
email_settings_saved = pyqtSignal(dict)
|
|
email_tested = pyqtSignal(dict) # email_settings
|
|
license_activated = pyqtSignal(str) # license_key
|
|
|
|
def __init__(self, platform_name, proxy_rotator=None, email_handler=None, license_manager=None, language_manager=None):
|
|
super().__init__()
|
|
self.platform_name = platform_name
|
|
self.proxy_rotator = proxy_rotator
|
|
self.email_handler = email_handler
|
|
self.license_manager = license_manager
|
|
self.language_manager = language_manager
|
|
self.init_ui()
|
|
if self.language_manager:
|
|
self.language_manager.language_changed.connect(self.update_texts)
|
|
self.update_texts()
|
|
|
|
# Einstellungen laden, falls Handler vorhanden
|
|
self.load_settings()
|
|
|
|
def init_ui(self):
|
|
"""Initialisiert die Benutzeroberfläche."""
|
|
layout = QVBoxLayout(self)
|
|
|
|
# Proxy-Einstellungen
|
|
proxy_group = QGroupBox("Proxy-Einstellungen")
|
|
proxy_layout = QVBoxLayout(proxy_group)
|
|
|
|
# IPv4 Proxies
|
|
ipv4_form = QFormLayout()
|
|
self.ipv4_proxy_input = QTextEdit()
|
|
self.ipv4_proxy_input.setPlaceholderText("Ein Proxy pro Zeile im Format: host:port:username:password")
|
|
ipv4_form.addRow("IPv4 Proxies:", self.ipv4_proxy_input)
|
|
proxy_layout.addLayout(ipv4_form)
|
|
|
|
# IPv6 Proxies
|
|
ipv6_form = QFormLayout()
|
|
self.ipv6_proxy_input = QTextEdit()
|
|
self.ipv6_proxy_input.setPlaceholderText("Ein Proxy pro Zeile im Format: host:port:username:password")
|
|
ipv6_form.addRow("IPv6 Proxies:", self.ipv6_proxy_input)
|
|
proxy_layout.addLayout(ipv6_form)
|
|
|
|
# Mobile Proxies
|
|
mobile_form = QFormLayout()
|
|
self.mobile_proxy_input = QTextEdit()
|
|
self.mobile_proxy_input.setPlaceholderText("Ein Proxy pro Zeile im Format: host:port:username:password")
|
|
mobile_form.addRow("Mobile Proxies:", self.mobile_proxy_input)
|
|
proxy_layout.addLayout(mobile_form)
|
|
|
|
# Mobile Proxy API Keys
|
|
api_key_layout = QFormLayout()
|
|
self.marsproxy_api_input = QLineEdit()
|
|
api_key_layout.addRow("MarsProxies API Key:", self.marsproxy_api_input)
|
|
|
|
self.iproyal_api_input = QLineEdit()
|
|
api_key_layout.addRow("IPRoyal API Key:", self.iproyal_api_input)
|
|
|
|
proxy_layout.addLayout(api_key_layout)
|
|
|
|
# Test-Button
|
|
proxy_button_layout = QHBoxLayout()
|
|
|
|
self.test_proxy_button = QPushButton("Proxy testen")
|
|
self.test_proxy_button.clicked.connect(self.on_test_proxy_clicked)
|
|
|
|
self.save_proxy_button = QPushButton("Proxy-Einstellungen speichern")
|
|
self.save_proxy_button.clicked.connect(self.on_save_proxy_clicked)
|
|
|
|
proxy_button_layout.addWidget(self.test_proxy_button)
|
|
proxy_button_layout.addWidget(self.save_proxy_button)
|
|
|
|
proxy_layout.addLayout(proxy_button_layout)
|
|
|
|
layout.addWidget(proxy_group)
|
|
|
|
# E-Mail-Einstellungen
|
|
email_group = QGroupBox("E-Mail-Einstellungen")
|
|
email_layout = QFormLayout(email_group)
|
|
|
|
self.imap_server_input = QLineEdit("imap.ionos.de")
|
|
email_layout.addRow("IMAP-Server:", self.imap_server_input)
|
|
|
|
self.imap_port_input = QSpinBox()
|
|
self.imap_port_input.setRange(1, 65535)
|
|
self.imap_port_input.setValue(993)
|
|
email_layout.addRow("IMAP-Port:", self.imap_port_input)
|
|
|
|
self.imap_user_input = QLineEdit()
|
|
email_layout.addRow("IMAP-Benutzername:", self.imap_user_input)
|
|
|
|
self.imap_pass_input = QLineEdit()
|
|
self.imap_pass_input.setEchoMode(QLineEdit.Password)
|
|
email_layout.addRow("IMAP-Passwort:", self.imap_pass_input)
|
|
|
|
email_button_layout = QHBoxLayout()
|
|
|
|
self.test_email_button = QPushButton("E-Mail testen")
|
|
self.test_email_button.clicked.connect(self.on_test_email_clicked)
|
|
|
|
self.save_email_button = QPushButton("E-Mail-Einstellungen speichern")
|
|
self.save_email_button.clicked.connect(self.on_save_email_clicked)
|
|
|
|
email_button_layout.addWidget(self.test_email_button)
|
|
email_button_layout.addWidget(self.save_email_button)
|
|
|
|
email_layout.addRow("", email_button_layout)
|
|
|
|
layout.addWidget(email_group)
|
|
|
|
# Plattformspezifische Einstellungen
|
|
if self.platform_name.lower() != "instagram":
|
|
self.add_platform_specific_settings(layout)
|
|
|
|
# Lizenz-Gruppe
|
|
license_group = QGroupBox("Lizenz")
|
|
license_layout = QFormLayout(license_group)
|
|
|
|
self.license_key_input = QLineEdit()
|
|
license_layout.addRow("Lizenzschlüssel:", self.license_key_input)
|
|
|
|
self.activate_license_button = QPushButton("Lizenz aktivieren")
|
|
self.activate_license_button.clicked.connect(self.on_activate_license_clicked)
|
|
license_layout.addRow("", self.activate_license_button)
|
|
|
|
layout.addWidget(license_group)
|
|
|
|
# Stretch am Ende hinzufügen
|
|
layout.addStretch(1)
|
|
|
|
def add_platform_specific_settings(self, layout):
|
|
"""
|
|
Fügt plattformspezifische Einstellungen hinzu.
|
|
Diese Methode kann in abgeleiteten Klassen überschrieben werden.
|
|
|
|
Args:
|
|
layout: Das Layout, zu dem die Einstellungen hinzugefügt werden sollen
|
|
"""
|
|
platform = self.platform_name.lower()
|
|
|
|
platform_settings_group = QGroupBox(f"{self.platform_name}-spezifische Einstellungen")
|
|
platform_settings_layout = QFormLayout(platform_settings_group)
|
|
|
|
# Je nach Plattform unterschiedliche Einstellungen
|
|
if platform == "twitter":
|
|
self.twitter_api_key = QLineEdit()
|
|
platform_settings_layout.addRow("Twitter API Key:", self.twitter_api_key)
|
|
|
|
self.twitter_api_secret = QLineEdit()
|
|
platform_settings_layout.addRow("Twitter API Secret:", self.twitter_api_secret)
|
|
|
|
elif platform == "tiktok":
|
|
self.video_upload = QCheckBox("Video automatisch hochladen")
|
|
platform_settings_layout.addRow("", self.video_upload)
|
|
|
|
self.follower_action = QCheckBox("Automatisch anderen Nutzern folgen")
|
|
platform_settings_layout.addRow("", self.follower_action)
|
|
|
|
elif platform == "facebook":
|
|
self.page_creation = QCheckBox("Seite automatisch erstellen")
|
|
platform_settings_layout.addRow("", self.page_creation)
|
|
|
|
self.privacy_level = QComboBox()
|
|
self.privacy_level.addItems(["Öffentlich", "Freunde", "Nur ich"])
|
|
platform_settings_layout.addRow("Datenschutzeinstellung:", self.privacy_level)
|
|
|
|
# Speichern-Button für plattformspezifische Einstellungen
|
|
self.platform_save_button = QPushButton(f"{self.platform_name}-Einstellungen speichern")
|
|
self.platform_save_button.clicked.connect(self.on_save_platform_settings_clicked)
|
|
platform_settings_layout.addRow("", self.platform_save_button)
|
|
|
|
layout.addWidget(platform_settings_group)
|
|
|
|
def load_settings(self):
|
|
"""Lädt die Einstellungen aus den Handlern."""
|
|
# Proxy-Einstellungen laden
|
|
if self.proxy_rotator:
|
|
try:
|
|
proxy_config = self.proxy_rotator.get_config() or {}
|
|
|
|
# IPv4 Proxies
|
|
ipv4_proxies = proxy_config.get("ipv4", [])
|
|
self.ipv4_proxy_input.setPlainText("\n".join(ipv4_proxies))
|
|
|
|
# IPv6 Proxies
|
|
ipv6_proxies = proxy_config.get("ipv6", [])
|
|
self.ipv6_proxy_input.setPlainText("\n".join(ipv6_proxies))
|
|
|
|
# Mobile Proxies
|
|
mobile_proxies = proxy_config.get("mobile", [])
|
|
self.mobile_proxy_input.setPlainText("\n".join(mobile_proxies))
|
|
|
|
# API Keys
|
|
mobile_api = proxy_config.get("mobile_api", {})
|
|
self.marsproxy_api_input.setText(mobile_api.get("marsproxies", ""))
|
|
self.iproyal_api_input.setText(mobile_api.get("iproyal", ""))
|
|
|
|
except Exception as e:
|
|
logger.error(f"Fehler beim Laden der Proxy-Einstellungen: {e}")
|
|
|
|
# E-Mail-Einstellungen laden
|
|
if self.email_handler:
|
|
try:
|
|
email_config = self.email_handler.get_config() or {}
|
|
|
|
self.imap_server_input.setText(email_config.get("imap_server", "imap.ionos.de"))
|
|
self.imap_port_input.setValue(email_config.get("imap_port", 993))
|
|
self.imap_user_input.setText(email_config.get("imap_user", ""))
|
|
self.imap_pass_input.setText(email_config.get("imap_pass", ""))
|
|
|
|
except Exception as e:
|
|
logger.error(f"Fehler beim Laden der E-Mail-Einstellungen: {e}")
|
|
|
|
# Lizenzeinstellungen laden
|
|
if self.license_manager:
|
|
try:
|
|
license_info = self.license_manager.get_license_info()
|
|
self.license_key_input.setText(license_info.get("key", ""))
|
|
|
|
except Exception as e:
|
|
logger.error(f"Fehler beim Laden der Lizenzeinstellungen: {e}")
|
|
|
|
def on_save_proxy_clicked(self):
|
|
"""Wird aufgerufen, wenn der Proxy-Speichern-Button geklickt wird."""
|
|
# Proxy-Einstellungen sammeln
|
|
settings = {
|
|
"ipv4_proxies": self.ipv4_proxy_input.toPlainText(),
|
|
"ipv6_proxies": self.ipv6_proxy_input.toPlainText(),
|
|
"mobile_proxies": self.mobile_proxy_input.toPlainText(),
|
|
"mobile_api": {
|
|
"marsproxies": self.marsproxy_api_input.text().strip(),
|
|
"iproyal": self.iproyal_api_input.text().strip()
|
|
}
|
|
}
|
|
|
|
# Signal auslösen
|
|
self.proxy_settings_saved.emit(settings)
|
|
|
|
def on_test_proxy_clicked(self):
|
|
"""Wird aufgerufen, wenn der Proxy-Test-Button geklickt wird."""
|
|
# Proxy-Typ aus der Combobox in der Generator-Tab holen
|
|
# Da wir keine direkte Referenz haben, nehmen wir den ersten Eintrag
|
|
proxy_type = "ipv4"
|
|
|
|
# Signal auslösen
|
|
self.proxy_tested.emit(proxy_type)
|
|
|
|
def on_save_email_clicked(self):
|
|
"""Wird aufgerufen, wenn der E-Mail-Speichern-Button geklickt wird."""
|
|
# E-Mail-Einstellungen sammeln
|
|
settings = {
|
|
"imap_server": self.imap_server_input.text().strip(),
|
|
"imap_port": self.imap_port_input.value(),
|
|
"imap_user": self.imap_user_input.text().strip(),
|
|
"imap_pass": self.imap_pass_input.text()
|
|
}
|
|
|
|
# Signal auslösen
|
|
self.email_settings_saved.emit(settings)
|
|
|
|
def on_test_email_clicked(self):
|
|
"""Wird aufgerufen, wenn der E-Mail-Test-Button geklickt wird."""
|
|
# E-Mail-Einstellungen sammeln
|
|
settings = {
|
|
"imap_server": self.imap_server_input.text().strip(),
|
|
"imap_port": self.imap_port_input.value(),
|
|
"imap_user": self.imap_user_input.text().strip(),
|
|
"imap_pass": self.imap_pass_input.text()
|
|
}
|
|
|
|
# Signal auslösen
|
|
self.email_tested.emit(settings)
|
|
|
|
def on_save_platform_settings_clicked(self):
|
|
"""Wird aufgerufen, wenn der Plattform-Einstellungen-Speichern-Button geklickt wird."""
|
|
# Hier könnte ein plattformspezifisches Signal ausgelöst werden
|
|
logger.info(f"{self.platform_name}-Einstellungen gespeichert")
|
|
|
|
def on_activate_license_clicked(self):
|
|
"""Wird aufgerufen, wenn der Lizenz-Aktivieren-Button geklickt wird."""
|
|
license_key = self.license_key_input.text().strip()
|
|
|
|
if not license_key:
|
|
return
|
|
|
|
# Signal auslösen
|
|
self.license_activated.emit(license_key)
|
|
|
|
def update_texts(self):
|
|
"""Aktualisiert UI-Texte gemäß aktueller Sprache."""
|
|
if not self.language_manager:
|
|
return
|
|
self.test_proxy_button.setText(self.language_manager.get_text("buttons.test_proxy", "Proxy testen"))
|
|
self.save_proxy_button.setText(self.language_manager.get_text("buttons.save_proxy", "Proxy-Einstellungen speichern"))
|
|
self.test_email_button.setText(self.language_manager.get_text("buttons.test_email", "E-Mail testen"))
|
|
self.save_email_button.setText(self.language_manager.get_text("buttons.save_email", "E-Mail-Einstellungen speichern"))
|
|
self.activate_license_button.setText(self.language_manager.get_text("buttons.activate_license", "Lizenz aktivieren"))
|