Einkauf_Suche/einkauf_suche.py

from PyQt5.QtWidgets import QApplication, QWidget, QVBoxLayout, QHBoxLayout,QLabel, QLineEdit, QPushButton, QCheckBox, QMessageBox, QGridLayout
from concurrent.futures import ThreadPoolExecutor
from PyQt5.QtCore import Qt, QThread, pyqtSignal
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
from bs4 import BeautifulSoup


import sys
import concurrent.futures

BLANK_PAGE_URL = ""

class SearchThread(QThread):
    search_finished = pyqtSignal()

    def __init__(self, selected_webpages, search_term, parent=None):
        super(SearchThread, self).__init__(parent)
        self.selected_webpages = selected_webpages
        self.search_term = search_term
        self.error_message = None
        self.driver = webdriver.Chrome()

    def run(self):
        try:
            
            for webseite in self.selected_webpages:
                self.start_search_on_webseite(webseite)
        except Exception as e:
            self.error_message = f"Fehler bei der Suche: {e}"
        finally:
            self.search_finished.emit()


    def start_search_on_webseite(self, webseite):
        try:
            self.driver.execute_script(f"window.open('{BLANK_PAGE_URL}', '_blank');")

            self.driver.switch_to.window(self.driver.window_handles[-1])

            if webseite == "Reichelt: Technikbedarf":
                self.suche_auf_reichelt()
            elif webseite == "Conrad: Technik Marktplatz":
                self.suche_auf_conrad()
            elif webseite == "Kosatec: Elektro Artikel":
                self.suche_auf_kosatec()
            elif webseite == "Hornbach: Bad, Baustoffe, Holz, Fenster & Türen, Bodenbeläge, Werkzeug, Farben & Tapeten, Garten, Heizen": 
                self.suche_auf_hornbach()
            elif webseite =="Contorion: Befestigungstechnik, Handwerkzeug, Elektrowerkzeug, Materialbearbeitung, Betriebsausstattung":
                self.suche_auf_contorion()
            elif webseite == "Gastroteile Shop: Geräte/Anwendung, Dichtungs- Elektro- Gas- Wasser-Komponenten, Werkzeuge":
                self.suche_auf_gastroteileshop()
            elif webseite == "TiroLED: LED Beleuchtung, Digital Signage":
                self.suche_auf_tiroled()
            elif webseite == "Megabad: Badarmaturen, Badkeramik, Badmöbel, Badewannen, Duschwannen, Duschkabine, Badheizkörper":
                self.suche_auf_megabad()
            elif webseite == "Baubeschlagshop: Beschläge, Rollen, installationsbedarf":
                self.suche_auf_baubeschlag()
            elif webseite == "IPS: Verbindungs- Befestigungs- Dichtungs- Schlauch-Technik, Gewindefittings, Klemmringverschraubungen, Rohre":
                self.suche_auf_ips_shop()
            elif webseite == "Brewes:  Sicherheitsschilder, Verkehrszeichen, Absperrketten, Prüfplaketten, Lagerkennzeichnung":
                self.suche_auf_brewes()
            elif webseite == "Delker: Baugeräte,Beschlagsysteme und Sicherheitstechnik,Elektro- & Druckluftwerkzeuge,Betriebseinrichtungen":
                self.suche_auf_delker()
            elif webseite == "Knauss: Armaturen, Geschirrbrausen, Reinigung, Haushalt, Wellness, Garten":
                self.suche_auf_knauss()
            elif webseite == "Schildershop24: Beschilderung, Hauseingang, Firma & Gewerbe, KFZ & Straße":
                self.suche_auf_schildershop24()
            elif webseite == "Häfele: Griffe & Türdrücker, Möbelbeschläge & Wohnraumlösungen, Türbeschläge, Schiebebeschläge & Rollläden":
                self.suche_auf_haefele()
            elif webseite == "Esmeyer: Besteck & Geschirr, alles für Getränke, gedeckter Tisch, Essen & Trinken":
                self.suche_auf_esmeyer()
            elif webseite == "Papstar: Bio-Einweggeschirr, Teller & Schalen, Becher & Gläser, Besteck, Fingerfood-Artikel, Servietten":
                 self.suche_auf_papstar()
            elif webseite == "Pacovis: To Go Geschirr, Einweggeschirr Brasserie, Lebensmittelverarbeitung, Lebensmittelverpackungen":     
                self.suche_auf_pacovis()
            elif webseite == "Lusini: Gastrobedarf":
                self.suche_auf_lusini()
            elif webseite == "Hygi: Reinigungsmittel, Pflegemittel & Waschmittel, Desinfektionsmittel, Besen,Müllsäcke & Haushaltswaren":
                self.suche_auf_hygi()
            elif webseite == "Tischwelt: Geschirr, Glas, Besteck, Buffet, Tischzubehör, Tischwäsche, Take Away, Geräte, Küchenbedarf, Möbel":
                self.suche_auf_tischwelt()
            elif webseite == "Schafferer: MARKEN, ESSEN & TRINKEN, WOHNEN & SCHENKEN, KOCHEN & GENIESSE, LUNCH, KINDER, THEMEN":
                self.suche_auf_schafferer()
            elif webseite == "Gastronomie Kaufhaus: Gastrobedarf":
                self.suche_auf_gastronomie_kaufhaus()
            elif webseite == "Arbeitsplatzmatten-profi: Anti-Rutschmatten,Schutz- & Sicherheitsmatten,Schmutzfangmatten,Läufer,Kabelbrücken":
                self.suche_auf_arbeitsplatzmattenprofi()
            elif webseite == "Skiltex: Aufsteller- Plakathalter- Acryl, Aschenbecher, Büroschilder, Doppelseitiger Rahmen, Digital Signage":
                self.suche_auf_skiltex()
            elif webseite == "Franz-Mensch: Handschuhe, Schutzkleidung, Reinigung & Hygiene, Gastronomiebedarf, Medizin- & Pflegebedarf":
                self.suche_auf_franzmensch()
            elif webseite == "Frank-Flechtwaren: Ostern, Garten, Deko, Wohnen, Textilien, Korbwaren, Kollektion":
                self.suche_auf_frankflechtwaren()
            elif webseite == "ARA: Arbeitskleidung, Augenschutz, Atemschutz, Gehörschutz, Kopfschutz, Erste Hilfe, Hautschutz":
                self.suche_auf_ara_arbeitsschutz()
            elif webseite == "VKF-Renzel: Prospekthalter & Warenträger, Werbeaufsteller, Rahmen & Hüllen, Regalordnung, Außenwerbung":
                self.suche_auf_vkf_renzel()
            elif webseite == "Börner: Obst- und Gemüsehobel, Reiben und Schneider, Schäler, Küchenhelfer":
                self.suche_auf_boerner()
            elif webseite == "GGM-Gastro: Kochgeräte, Edelstahlmöbel, Kühlung, Kombidämpfer, Küchengeräte, Töpfe & Pfannen, Lüftung":
                self.suche_auf_ggmgastro()
            elif webseite == "Böttcher: Bürobedarf, Papiere, Folien, Etiketten, Druckerpatronen, Büromöbel & Stahlschränke":
                self.suche_auf_boettcher()
            elif webseite == "Büroshop24: Papier, Tinte & Toner, Ordner & Mappen, Schreibwaren, Versand, Schulbedarf, Bürobedarf":
                self.suche_auf_bueroshop24()
            elif webseite == "Buchhandlung am Markt: Bücher":
                self.suche_buchhandlung_am_markt()
            elif webseite == "Label-Ident: Etikettendrucker, Software & Zubehör, Thermotransfer-Farbbänder, Etiketten auf Rolle":
                self.suche_auf_labelident()
            elif webseite == "Transpak: Kartonage mit FL Logo, Stretchfolie, Packband, Versandverpackungen,Polstern, Folien und Beutel":
                self.suche_auf_transpak()
            elif webseite == "PML: Kassenrollen, Büro- und Funktionspapiere":
                self.suche_auf_pml()
            elif webseite == "DM-Folien: Pressengarn":
                self.suche_auf_dmfolien()
            elif webseite == "Proficleanshop: Reinigung, Desinfektion, Hygienepapier, Medical, Einweg & Deko, Industrie, Maschinen":
                self.suche_auf_proficleanshop()
            elif webseite == "Siepmann: Weidezaun, Schlepperteile, Tiere, Haus & Hof, Hofladen, Lüftung & Windschutz":
                self.suche_auf_siepmann()
            elif webseite == "FK-Söhnchen: Landwirtschaftsbedarf, Elektrik, Landmaschinenteile, Hydraulik, Haus, Hof & Forst":
                self.suche_auf_fksoehnchen
            elif webseite == "Wahl-Agar: Stall, Weidezaun, Forst, Veterinär, Landmaschinen & Co., Arbeitskleidung, Haus & Hof":
                self.suche_auf_wahl_agrar()      
            elif webseite == "TVV-Verpackungen":
                self.suche_auf_tvv() 
            elif webseite == "Eierschachteln.de: Bedarf für Hühnerhaltung":
                self.suche_auf_eierschachteln()  
            elif webseite == "KOX: Gartenbedarf, Schneideblätter Heckenschere, etc.":
                self.suche_auf_kox()
            elif webseite == "Reinigungsberater.de: Ersatzartikel Staubsauger, Reinigungbedarf etc.":
                self.suche_auf_reinigungsberater()
            elif webseite == "VBS-Hobby: Sicherheitsnadeln in gr. Mengen, Handarbeits- und Bastelbedarf":
                self.suche_auf_vbshobby()
            elif webseite == "Ökonomed: Drogentest, med. Bedarf":
                self.suche_auf_oekonomed()
            elif webseite == "Rossmann":
                self.suche_auf_rossmann()
            elif webseite == "Betzold: Lehrmittel, Schulbedarf, Kunst-und Bastelsachen, Dekomaterial":
                self.suche_auf_betzold()

    
        except Exception as e:
            print(f"Fehler bei der Suche auf {webseite}: {e}")

    def suche_auf_haefele(self):

        
        # URL für die Suche generieren
        search_url = 'https://www.haefele.de/'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "inputSearchTerm")))

        # Suchbegriff eingeben und Suche starten
        search_box = self.driver.find_element(By.ID, "inputSearchTerm")
        search_box.clear()  
        search_box.send_keys(self.search_term)
        search_box.send_keys(Keys.RETURN)

    def suche_auf_brewes(self, ):
        

        # URL für die Suche generieren
        search_url = f'https://www.brewes.de/catalogsearch/result?q={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))

    def suche_auf_conrad(self):
        # WebDriver initialisieren
        
        # Such-URL generieren
        search_url = f'https://www.conrad.de/search.html?search={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "header-search")))

        # Suchbegriff eingeben
        search_box = self.driver.find_element(By.ID, "header-search")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)

        # Enter-Taste drücken
        search_box.send_keys(Keys.RETURN)

    def suche_auf_contorion(self):
        
        # Such-URL generieren
        search_url = f'https://www.contorion.de/suche?q={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search-input")))

        # Suchbegriff eingeben
        search_box = self.driver.find_element(By.ID, "search-input")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)

        # Enter-Taste drücken
        search_box.send_keys(Keys.RETURN)

    def suche_auf_reichelt(self):
            # Such-URL generieren
        search_url = f'https://www.reichelt.de/index.html?ACTION=446&LA=446&nbc=1&SEARCH={self.search_term}'

            # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 60).until(EC.presence_of_element_located((By.ID, "searchbutton")))

            # Suchbegriff eingeben und Suche starten
        search_box = self.driver.find_element(By.ID, "quicksearch_new")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)

            # Formular abschicken
        search_button = self.driver.find_element(By.ID, "searchbutton")
        search_button.click()

    def suche_auf_kosatec(self):

        # Such-URL generieren
        search_url = f'https://shop.kosatec.de/search?search={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.CSS_SELECTOR, "input[name='search']")))

    def suche_auf_hornbach(self):

        # URL für die Suche generieren
        search_url = f'https://www.hornbach.de/s/{self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "global_search")))        
        
    def suche_auf_gastroteileshop(self):

        # URL für die Suche generieren
        search_url = f'https://www.gastroteileshop.de/?s={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)

        # Warten, bis das Suchfeld sichtbar ist
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.CLASS_NAME, "search-input")))

        cookie_button = self.driver.find_element(By.CLASS_NAME, "btn.btn-primary.btn-block.btn-appearance")
        cookie_button.click()

        # Suchbegriff eingeben und Suche starten
        search_box = self.driver.find_element(By.CLASS_NAME, "search-input")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)
        search_box.send_keys(Keys.RETURN)

    def suche_auf_tiroled(self):
        # URL für die Suche generieren
        search_url = f'https://www.tiroled.com/de/search?search={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "search")))

        cookie_button = self.driver.find_element(By.CLASS_NAME, "cookie-consent-accept-only-functional-button.btn.btn-primary.cookie-consent-button-margin")
        cookie_button.click()

    def suche_auf_megabad(self):
        # URL für die Suche generieren
        search_url = f'https://www.megabad.com/search/?query=sdyc/#/q/{self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search-bar-input")))

        cookie_button = self.driver.find_element(By.CSS_SELECTOR, ".cmpboxbtn.cmpboxbtnyes.cmptxt_btn_yes")
        cookie_button.click()

    def suche_auf_baubeschlag(self):
        # URL für die Suche generieren
        search_url = f'https://www.baubeschlagshop.de/fts.php?criteria={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "searchcriteria")))

    def suche_auf_ips_shop(self):

        # URL für die Suche generieren
        search_url = f'https://www.ips-kts.com/de/suche?query={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "query")))

    def suche_auf_delker(self):

        # URL für die Suche generieren
        search_url = f'https://www.delker2business.com/nwsearch/execute?query={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "query")))

    def suche_auf_knauss(self):
        # URL für die Suche generieren
        search_url = f'https://knauss.info/dksearch?sSearch={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "sSearch")))

    def suche_auf_schildershop24(self):
        # URL für die Suche generieren
        search_url = f'https://www.schildershop24.de/?action=Query&-query.&query.stichwort=r{self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search-query-stichwort_neu")))

    def suche_auf_esmeyer(self):
        # URL für die Suche generieren
        search_url = f'https://www.esmeyer-shop.de/search?search={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.NAME, "search")))
        
    def suche_auf_papstar(self):
        # URL für die Suche generieren
        search_url = 'https://www.papstar-shop.de/'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))

        # Suchbegriff eingeben und Suche starten
        search_box = self.driver.find_element(By.ID, "search")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)

        # Enter-Taste drücken, um die Suche zu starten
        search_box.send_keys(Keys.RETURN)

    def suche_auf_pacovis(self):
        # URL für die Suche generieren
        search_url = f'https://www.pacovis.com/de-de/suche/1/search={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))

    def suche_auf_lusini(self):

        # URL für die Suche generieren
        search_url = f'https://www.lusini.com/de-de/search/#q={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search-input")))

    def suche_auf_hygi(self):
        # URL für die Suche generieren
        search_url = 'https://www.hygi.de/'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "qbox")))

        # Suchbegriff eingeben und Suche starten
        search_box = self.driver.find_element(By.ID, "qbox")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)

        # Enter-Taste drücken, um die Suche zu starten
        search_box.send_keys(Keys.RETURN)

    def suche_auf_tischwelt(self):
        # URL für die Suche generieren
        search_url = f'https://www.tischwelt.de/shop/Suche/?q={self.search_term}&search=Suchen'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))

    def suche_auf_schafferer(self):

        # URL für die Suche generieren
        search_url = f'https://www.schafferer.de/gastro/Artikel-Suche/?q={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "quicksearch-input")))

    def suche_auf_gastronomie_kaufhaus(self):

        # URL für die Suche generieren
        search_url = 'https://www.gastronomie-kaufhaus.de/' 

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "searchParam")))

        # Suchbegriff eingeben und Suche starten
        search_box = self.driver.find_element(By.ID, "searchParam")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)

        # Enter-Taste drücken, um die Suche zu starten (falls notwendig)
        search_box.send_keys(Keys.RETURN)

    def suche_auf_arbeitsplatzmattenprofi(self):
        

        # URL für die Suche generieren
        search_url = f'https://arbeitsplatzmatten-profi.com/?s={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))

    def suche_auf_skiltex(self):
        
        search_url = 'https://www.skiltex.de/shop/frontpage.html'  # Ersetzen Sie dies durch die tatsächliche URL für Skiltex

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.CLASS_NAME, "SearchField_SearchPage")))

        cookie_button = self.driver.find_element(By.CLASS_NAME, "coi-banner__accept")
        cookie_button.click()

        # Auf die Suchleiste klicken
        search_box = self.driver.find_element(By.CLASS_NAME, "SearchField_SearchPage")
        search_box.click()

        # Suchbegriff eingeben und Suche starten
        search_box.clear()
        search_box.send_keys(self.search_term)
        search_box.send_keys(Keys.RETURN)

    def suche_auf_franzmensch(self):
        # URL für die Suche generieren
        search_url = f'https://www.franz-mensch.de/search?search={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))

    def suche_auf_frankflechtwaren(self):
        # URL für die Suche generieren
        search_url = f'https://www.frank-flechtwaren.de/suchergebnisse/?query={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))

    def suche_auf_ara_arbeitsschutz(self):
        # URL für die Suche generieren
        search_url = f'https://ara-arbeitsschutz.de/navi.php?qs={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))

    def suche_auf_vkf_renzel(self):
        # URL für die Suche generieren
        search_url = f'https://www.vkf-renzel.de/index.php?lang=0&cl=rasearch&searchparam={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))

    def suche_auf_boerner(self):
        # URL für die Suche generieren
        search_url = f'https://www.boerner.de/?s={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))

    def suche_auf_ggmgastro(self):
        # URL für die Suche generieren
        search_url = f'https://www.ggmgastro.com/de-de-eur/search?q={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))

    def suche_auf_boettcher(self):

        # URL für die Suche generieren
        search_url = f'https://www.bueromarkt-ag.de/Artikelsuche_{self.search_term}.html'  # Bitte die tatsächliche URL einsetzen

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "autocomplete-0-input")))

    def suche_auf_bueroshop24(self):

        # URL für die Suche generieren
        search_url = 'https://www.bueroshop24.de/' 

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "searchTerm")))

        # Suchbegriff eingeben und Suche starten
        search_box = self.driver.find_element(By.ID, "searchTerm")
        search_box.clear()  # Falls vorheriger Text vorhanden ist
        search_box.send_keys(self.search_term)

        # Enter-Taste drücken, um die Suche zu starten (falls notwendig)
        search_box.send_keys(Keys.RETURN)

    def suche_buchhandlung_am_markt(self):
        # URL für die Suche generieren
        search_url = f'https://bam-mr.buchkatalog.de/search?q={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "mobile-search")))

    def suche_auf_labelident(self):
        # URL für die Suche generieren
        search_url = f'https://www.labelident.com/catalogsearch/result/?q={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))

    def suche_auf_transpak(self):
         # URL für die Suche generieren
        search_url = f'https://www.shop.transpak.de/search?sSearch={self.search_term}'

         # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.CLASS_NAME, "form-control")))
        try:
            # Warten, bis der Ablehnen-Button sichtbar ist
            cookie_button = WebDriverWait(self.driver, 10).until(
                EC.presence_of_element_located((By.XPATH, "//button[@data-cookiefirst-action='reject']"))
            )
            # Klicken Sie auf den Ablehnen-Button, um Cookies abzulehnen
            cookie_button.click()
        except Exception as e:
            print(f"Fehler beim Akzeptieren von Cookies: {e}")

    def suche_auf_pml(self):
        # URL für die Suche generieren
        search_url = f'https://www.pml-papiere.de/#query={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))

    def suche_auf_dmfolien(self):
        # URL für die Suche generieren
        search_url = f'https://www.dm-folien.com/shop/search?sSearch={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))

    def suche_auf_proficleanshop(self):
        # URL für die Suche generieren
        search_url = f'https://www.proficleanshop.de/searchresults/?q={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))

    def suche_auf_siepmann(self):
        # URL für die Suche generieren
        search_url = f'https://www.siepmann.net/siepmann_shop.php?suchfeld={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))

    def suche_auf_fksoehnchen(self):
        # URL für die Suche generieren
        search_url = f'https://www.fk-soehnchen.de/index.php?stoken=&lang=0&cl=search&searchparam={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))

    def suche_auf_wahl_agrar(self):
        # URL für die Suche generieren
        search_url = 'https://www.agrar-fachversand.com/de/'  # Ersetzen Sie dies durch die tatsächliche URL für Wahl Agrar

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.CLASS_NAME, "main-search--field")))

        # Auf die Suchleiste klicken
        search_box = self.driver.find_element(By.CLASS_NAME, "main-search--field")
        search_box.click()

        # Suchbegriff eingeben und Suche starten
        search_box.clear()
        search_box.send_keys(self.search_term)
        search_box.send_keys(Keys.RETURN)

    def suche_auf_tvv(self):
        # URL für die Suche generieren
        search_url = f'https://www.tvv-verpackungen.de/index.php?jtl_token=86147d041429ad7dafb0c5f1a80e61e089eb4f04ec192b004ba5e69e8aaa45c5&sp_additional_mail=&qs={self.search_term}'  # Ersetzen Sie dies durch die tatsächliche URL für DVV

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search-header-mobile-top")))

    def suche_auf_eierschachteln(self):
        # URL für die Suche generieren
        search_url = f'https://www.eierschachteln.de/search?sSearch={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))

    def suche_auf_kox(self):
        # URL für die Suche generieren
        search_url = f'https://www.kox-direct.de/?query={self.search_term}&sid=6d0b4366af8bb99af514529b7e61ad&act=search'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))

    def suche_auf_reinigungsberater(self):
        # URL für die Suche generieren
        search_url = f'https://www.reinigungsberater.de/{self.search_term}.html'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))
        
    def suche_auf_vbshobby(self):
        # URL für die Suche generieren
        search_url = f'https://www.vbs-hobby.com/suche/?q={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))

    def suche_auf_oekonomed(self):
        # URL für die Suche generieren
        search_url = f'https://shop.oekonomed.de/de/advanced_search_result.php?keywords={self.search_term}&inc_subcat=1'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))

    def suche_auf_rossmann(self):
        # URL für die Suche generieren
        search_url = f'https://www.rossmann.de/de/search/?text={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))

    def suche_auf_betzold(self):
        # URL für die Suche generieren
        search_url = f'https://www.betzold.de/search/?q={self.search_term}'

        # Webseite aufrufen und auf das vollständige Laden warten
        self.driver.get(search_url)
        WebDriverWait(self.driver, 10).until(EC.presence_of_element_located((By.ID, "search")))

categories = ["IT/EDV", "Haustechnik","Küche", "Verwaltung", "Transporte", "Landwirtschaft", "SOZ.BETR.-Ginseldorf"]
webpages =  [
        ["Reichelt: Technikbedarf", "Kosatec: Elektro Artikel", "Conrad: Technik Marktplatz"],
        ["Hornbach: Bad, Baustoffe, Holz, Fenster & Türen, Bodenbeläge, Werkzeug, Farben & Tapeten, Garten, Heizen",
         "Contorion: Befestigungstechnik, Handwerkzeug, Elektrowerkzeug, Materialbearbeitung, Betriebsausstattung",
         "Gastroteile Shop: Geräte/Anwendung, Dichtungs- Elektro- Gas- Wasser-Komponenten, Werkzeuge",
         "TiroLED: LED Beleuchtung, Digital Signage", 
         "Megabad: Badarmaturen, Badkeramik, Badmöbel, Badewannen, Duschwannen, Duschkabine, Badheizkörper", 
         "Baubeschlagshop: Beschläge, Rollen, installationsbedarf",
         "IPS: Verbindungs- Befestigungs- Dichtungs- Schlauch-Technik, Gewindefittings, Klemmringverschraubungen, Rohre",
         "Brewes:  Sicherheitsschilder, Verkehrszeichen, Absperrketten, Prüfplaketten, Lagerkennzeichnung", 
         "Delker: Baugeräte,Beschlagsysteme und Sicherheitstechnik,Elektro- & Druckluftwerkzeuge,Betriebseinrichtungen", 
         "Knauss: Armaturen, Geschirrbrausen, Reinigung, Haushalt, Wellness, Garten",
         "Schildershop24: Beschilderung, Hauseingang, Firma & Gewerbe, KFZ & Straße",
         "Häfele: Griffe & Türdrücker, Möbelbeschläge & Wohnraumlösungen, Türbeschläge, Schiebebeschläge & Rollläden"], 
        ["Esmeyer: Besteck & Geschirr, alles für Getränke, gedeckter Tisch, Essen & Trinken", 
         "Papstar: Bio-Einweggeschirr, Teller & Schalen, Becher & Gläser, Besteck, Fingerfood-Artikel, Servietten", 
         "Pacovis: To Go Geschirr, Einweggeschirr Brasserie, Lebensmittelverarbeitung, Lebensmittelverpackungen",
         "Lusini: Gastrobedarf", 
         "Hygi: Reinigungsmittel, Pflegemittel & Waschmittel, Desinfektionsmittel, Besen,Müllsäcke & Haushaltswaren", 
         "Tischwelt: Geschirr, Glas, Besteck, Buffet, Tischzubehör, Tischwäsche, Take Away, Geräte, Küchenbedarf, Möbel",
         "Schafferer: MARKEN, ESSEN & TRINKEN, WOHNEN & SCHENKEN, KOCHEN & GENIESSE, LUNCH, KINDER, THEMEN", 
         "Gastronomie Kaufhaus: Gastrobedarf",
         "Arbeitsplatzmatten-profi: Anti-Rutschmatten,Schutz- & Sicherheitsmatten,Schmutzfangmatten,Läufer,Kabelbrücken",
         "Skiltex: Aufsteller- Plakathalter- Acryl, Aschenbecher, Büroschilder, Doppelseitiger Rahmen, Digital Signage",
         "Franz-Mensch: Handschuhe, Schutzkleidung, Reinigung & Hygiene, Gastronomiebedarf, Medizin- & Pflegebedarf",
         "Frank-Flechtwaren: Ostern, Garten, Deko, Wohnen, Textilien, Korbwaren, Kollektion",
         "ARA: Arbeitskleidung, Augenschutz, Atemschutz, Gehörschutz, Kopfschutz, Erste Hilfe, Hautschutz",
         "VKF-Renzel: Prospekthalter & Warenträger, Werbeaufsteller, Rahmen & Hüllen, Regalordnung, Außenwerbung",
         "Börner: Obst- und Gemüsehobel, Reiben und Schneider, Schäler, Küchenhelfer",
         "GGM-Gastro: Kochgeräte, Edelstahlmöbel, Kühlung, Kombidämpfer, Küchengeräte, Töpfe & Pfannen, Lüftung"],
        ["Böttcher: Bürobedarf, Papiere, Folien, Etiketten, Druckerpatronen, Büromöbel & Stahlschränke", 
         "Buchhandlung am Markt: Bücher",
         "Büroshop24: Papier, Tinte & Toner, Ordner & Mappen, Schreibwaren, Versand, Schulbedarf, Bürobedarf",
         "Label-Ident: Etikettendrucker, Software & Zubehör, Thermotransfer-Farbbänder, Etiketten auf Rolle"],
        ["Transpak: Kartonage mit FL Logo, Stretchfolie, Packband, Versandverpackungen,Polstern, Folien und Beutel",
         "PML: Kassenrollen, Büro- und Funktionspapiere",
         "DM-Folien: Pressengarn"],
        ["Proficleanshop: Reinigung, Desinfektion, Hygienepapier, Medical, Einweg & Deko, Industrie, Maschinen",
         "Siepmann: Weidezaun, Schlepperteile, Tiere, Haus & Hof, Hofladen, Lüftung & Windschutz",
         "FK-Söhnchen: Landwirtschaftsbedarf, Elektrik, Landmaschinenteile, Hydraulik, Haus, Hof & Forst",
         "Wahl-Agar: Stall, Weidezaun, Forst, Veterinär, Landmaschinen & Co., Arbeitskleidung, Haus & Hof",
         "TVV-Verpackungen: Netze & Planen, Folien & Folienartikel, Agrar & Garten, Verpackunsmaterial",
         "Eierschachteln.de: Bedarf für Hühnerhaltung",
         "KOX: Gartenbedarf, Schneideblätter Heckenschere, etc."],
        ["Reinigungsberater.de: Ersatzartikel Staubsauger, Reinigungbedarf etc.",
         "VBS-Hobby: Sicherheitsnadeln in gr. Mengen, Handarbeits- und Bastelbedarf",
         "Ökonomed: Drogentest, med. Bedarf",
         "Rossmann",
         "Betzold: Lehrmittel, Schulbedarf, Kunst-und Bastelsachen, Dekomaterial"]
]

class WebseitenSucheApp(QWidget):
    def __init__(self):
        super().__init__()

        self.category_webpages_mapping = {category: webpages for category, webpages in zip(categories, webpages)}

        self.selected_webpages = {webpage: False for category_webpages in webpages for webpage in category_webpages}

        self.search_term = ""
        self.driver = None

        self.init_ui()

    def init_ui(self):
        self.setStyleSheet("background-color: black; color: white;")
        layout = QVBoxLayout()

        # Kategorien und Webseiten in zwei vertikalen Spalten
        grid_layout = QGridLayout()

        # Add category in the first column#############################################################
        category = "Haustechnik"
        category_label = QLabel(category)
        grid_layout.addWidget(category_label, 0, 0, 1, 2)

        # Add corresponding webpages in the first column
        for row, webpage in enumerate(self.category_webpages_mapping[category]):
            checkbox = QCheckBox(webpage)
            checkbox.setChecked(self.selected_webpages[webpage])
            checkbox.stateChanged.connect(self.make_checkbox_callback(webpage))
            checkbox.setStyleSheet("color: white; border: 1px solid white;")

            green_webpages = ["Hornbach", "Contorion", "Gastroteile Shop", "TiroLED", "Megabad", "Baubeschlagshop" ]
            if any(green_webpage in webpage for green_webpage in green_webpages):
                checkbox.setStyleSheet("color: green;")

            yellow_webpages = ["IPS", "Brewes","Delker", "Knauss", "Schildershop24", "Häfele"]
            if any(yellow_webpage in webpage for yellow_webpage in yellow_webpages):
                checkbox.setStyleSheet("color: yellow;")

            grid_layout.addWidget(checkbox, row + 1, 0, 1, 2)

        category = "Küche"
        category_label = QLabel(category)
        grid_layout.addWidget(category_label, 13, 0, 1, 2)

        for row, webpage in enumerate(self.category_webpages_mapping[category]):
            checkbox = QCheckBox(webpage)
            checkbox.setChecked(self.selected_webpages[webpage])
            checkbox.stateChanged.connect(self.make_checkbox_callback(webpage))
            checkbox.setStyleSheet("color: white; border: 1px solid white;")

            green_webpages = ["Esmeyer", "Papstar", "Pacovis", "Lusini", "Hygi", "Tischwelt", "Schafferer", "Gastronomie Kaufhaus"]
            if any(green_webpage in webpage for green_webpage in green_webpages):
                checkbox.setStyleSheet("color: green;")

            yellow_webpages = ["Arbeitsplatzmatten-profi","Skiltex","Franz-Mensch", "Frank-Flechtwaren", "ARA", "VKF-Renzel", "Börner", "GGM-Gastro"]
            if any(yellow_webpage in webpage for yellow_webpage in yellow_webpages):
                checkbox.setStyleSheet("color: yellow;")

            grid_layout.addWidget(checkbox, row + 14, 0, 1, 2)

        # Add "IT/EDV" category in the second column#############################################################
        category = "IT/EDV"
        category_label = QLabel(category)
        grid_layout.addWidget(category_label, 0, 2, 1, 2)

        # Add corresponding webpages in the second column
        for row, webpage in enumerate(self.category_webpages_mapping[category]):
            checkbox = QCheckBox(webpage)
            checkbox.setChecked(self.selected_webpages[webpage])
            checkbox.stateChanged.connect(self.make_checkbox_callback(webpage))
            checkbox.setStyleSheet("color: white; border: 1px solid white;")

            green_webpages = ["Reichelt", "Kosatec" ]
            if any(green_webpage in webpage for green_webpage in green_webpages):
                checkbox.setStyleSheet("color: green;")

            yellow_webpages = ["Conrad"]
            if any(yellow_webpage in webpage for yellow_webpage in yellow_webpages):
                checkbox.setStyleSheet("color: yellow;")

            grid_layout.addWidget(checkbox, row+ 1, 2, 1, 2)


        category = "Verwaltung"
        category_label = QLabel(category)
        grid_layout.addWidget(category_label, 4, 2, 1, 2)

        # Add corresponding webpages in the second column
        for row, webpage in enumerate(self.category_webpages_mapping[category]):
            checkbox = QCheckBox(webpage)
            checkbox.setChecked(self.selected_webpages[webpage])
            checkbox.stateChanged.connect(self.make_checkbox_callback(webpage))
            checkbox.setStyleSheet("color: white; border: 1px solid white;")

            green_webpages = ["Böttcher", "Buchhandlung am Markt"]
            if any(green_webpage in webpage for green_webpage in green_webpages):
                checkbox.setStyleSheet("color: green;")

            yellow_webpages = ["Büroshop24", "Label-Ident"]
            if any(yellow_webpage in webpage for yellow_webpage in yellow_webpages):
                checkbox.setStyleSheet("color: yellow;")

            grid_layout.addWidget(checkbox, row+ 5, 2, 1, 2)

        category = "Transporte"
        category_label = QLabel(category)
        grid_layout.addWidget(category_label, 9, 2, 1, 2)

        # Add corresponding webpages in the second column
        for row, webpage in enumerate(self.category_webpages_mapping[category]):
            checkbox = QCheckBox(webpage)
            checkbox.setChecked(self.selected_webpages[webpage])
            checkbox.stateChanged.connect(self.make_checkbox_callback(webpage))
            checkbox.setStyleSheet("color: white; border: 1px solid white;")

            green_webpages = ["Transpak", "PML", "DM-Folien" ]
            if any(green_webpage in webpage for green_webpage in green_webpages):
                checkbox.setStyleSheet("color: green;")

            yellow_webpages = []
            if any(yellow_webpage in webpage for yellow_webpage in yellow_webpages):
                checkbox.setStyleSheet("color: yellow;")

            grid_layout.addWidget(checkbox, row+ 10, 2, 1, 2)


        category = "Landwirtschaft"
        category_label = QLabel(category)
        grid_layout.addWidget(category_label, 13, 2, 1, 2)

        # Add corresponding webpages in the second column
        for row, webpage in enumerate(self.category_webpages_mapping[category]):
            checkbox = QCheckBox(webpage)
            checkbox.setChecked(self.selected_webpages[webpage])
            checkbox.stateChanged.connect(self.make_checkbox_callback(webpage))
            checkbox.setStyleSheet("color: white; border: 1px solid white;")

            green_webpages = ["Proficleanshop", "Siepmann", "FK-Söhnchen", "Wahl-Agar", "TVV-Verpackungen", "Eierschachteln.de", "KOX"]
            if any(green_webpage in webpage for green_webpage in green_webpages):
                checkbox.setStyleSheet("color: green;")

            yellow_webpages = []
            if any(yellow_webpage in webpage for yellow_webpage in yellow_webpages):
                checkbox.setStyleSheet("color: yellow;")

            grid_layout.addWidget(checkbox, row+ 14, 2, 1, 2)

        category = "SOZ.BETR.-Ginseldorf"
        category_label = QLabel(category)
        grid_layout.addWidget(category_label, 21, 2, 1, 2)

        # Add corresponding webpages in the second column
        for row, webpage in enumerate(self.category_webpages_mapping[category]):
            checkbox = QCheckBox(webpage)
            checkbox.setChecked(self.selected_webpages[webpage])
            checkbox.stateChanged.connect(self.make_checkbox_callback(webpage))
            checkbox.setStyleSheet("color: white; border: 1px solid white;")

            green_webpages = ["Reinigungsberater.de", "VBS-Hobby", "Ökonomed", "Rossmann", "Betzold"]
            if any(green_webpage in webpage for green_webpage in green_webpages):
                checkbox.setStyleSheet("color: green;")

            yellow_webpages = []
            if any(yellow_webpage in webpage for yellow_webpage in yellow_webpages):
                checkbox.setStyleSheet("color: yellow;")

            grid_layout.addWidget(checkbox, row+ 22, 2, 1, 2)


        
        ##########################################################################################################################

        layout.addLayout(grid_layout)

        # Suchbegriff-Eingabe
        search_label = QLabel("Geben Sie den Suchbegriff ein:")
        layout.addWidget(search_label)

        search_input = QLineEdit(self)
        search_input.textChanged.connect(self.update_search_term)
        layout.addWidget(search_input)
        search_input.setStyleSheet("color: white; border: 1px solid white;")

        # Suchen-Button
        search_button = QPushButton("Suche starten", self)
        search_button.clicked.connect(self.start_search)
        layout.addWidget(search_button)
        search_button.setStyleSheet("color: white; border: 1px solid white;")


        # Neues Suche-Button
        new_search_button = QPushButton("Neue Suche starten", self)
        new_search_button.clicked.connect(self.new_search)
        layout.addWidget(new_search_button)
        new_search_button.setStyleSheet("color: white; border: 1px solid white;")


        self.setLayout(layout)
        self.setGeometry(300, 300, 400, 200)
        self.setWindowTitle('Webseiten Suche App')
        self.show()


    def make_checkbox_callback(self, webpage):
        def checkbox_callback(state):
            self.update_webpage_state(webpage, state)
        return checkbox_callback

    def update_webpage_state(self, webpage, state):
        self.selected_webpages[webpage] = state == 2  # 2 entspricht dem Zustand "ausgewählt"

    def update_search_term(self, text):
        self.search_term = text

    def start_search(self):
        selected_webpages = [webpage for webpage, selected in self.selected_webpages.items() if selected]

        if not selected_webpages:
            QMessageBox.warning(self, "Fehler", "Bitte wählen Sie mindestens eine Webseite aus.")
            return

        if not self.search_term:
            QMessageBox.warning(self, "Fehler", "Bitte geben Sie einen Suchbegriff ein.")
            return

        # Starte den Such-Thread
        self.search_thread = SearchThread(selected_webpages, self.search_term)
        self.search_thread.search_finished.connect(self.search_finished)
        self.search_thread.start()

    def search_finished(self):
        self.search_thread.quit()
        self.search_thread.wait()
        if hasattr(self.search_thread, 'error_message') and self.search_thread.error_message:
            QMessageBox.critical(None, "Fehler", self.search_thread.error_message)
        

    

    def new_search(self):
        self.close_driver()
        print("Neue Suche starten")

if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = WebseitenSucheApp()
    sys.exit(app.exec_())