sync_manager.py aktualisiert

sync_manager.py

@@ -84,41 +84,67 @@ class SyncManager:
         self.smart_merge_cols = ["CRM Website"]
 
     def _load_data(self):
-        """
+        """Lädt und bereitet die Daten aus D365 (Excel) und Google Sheets vor. Hart gegen „verschmutzte“ Header im Sheet."""
-        Lädt Daten aus D365-Export und Google Sheet.
+        # ----------------------------
-        WICHTIG: Header aus dem GSheet werden normalisiert und auf kanonische Namen (COLUMN_ORDER) gemappt,
+        # D365-EXPORT LADEN (Excel)
-        damit unsichtbare Zeichen (NBSP, Zero-Width, BOM etc.) keine Schatten-Spalten erzeugen.
+        # ----------------------------
-        """
+        self.logger.info(f"Lade Daten aus D365-Export: '{self.d365_export_path}'...")
-        self.logger.info("Starte _load_data()...")
+        try:
+            # Alles als String laden und NaN -> '' setzen, damit Vergleiche stabil sind
+            temp_d365_df = pd.read_excel(self.d365_export_path, dtype=str).fillna('')
 
-        # 1) D365-Daten laden (unverändert)
+            # Erwartete Spalten aus dem D365-Export prüfen
-        self.logger.debug("Lade D365-Export...")
+            for d365_col in self.d365_to_gsheet_map.keys():
-        self.d365_df = self._load_d365_export()  # erwartet bestehende Implementierung
+                if d365_col not in temp_d365_df.columns:
-        if self.d365_df is None or self.d365_df.empty:
+                    raise ValueError(f"Erwartete Spalte '{d365_col}' nicht in der D365-Exportdatei gefunden.")
-            self.logger.warning("D365-DataFrame ist leer oder None.")
 
-        # 2) Google Sheet Rohdaten holen (mit Headern)
+            # Auf die relevanten Spalten reduzieren und auf GSheet-Namen umbenennen
-        self.logger.debug("Lade Google Sheet Rohdaten (inkl. Header)...")
+            self.d365_df = temp_d365_df[list(self.d365_to_gsheet_map.keys())].copy()
+            self.d365_df.rename(columns=self.d365_to_gsheet_map, inplace=True)
+
+            # GUID-Format vereinheitlichen (lowercase, Trim) und nur gültige GUIDs behalten
+            if 'CRM ID' not in self.d365_df.columns:
+                raise ValueError("Nach dem Umbenennen fehlt die Spalte 'CRM ID' im D365-DataFrame.")
+            self.d365_df['CRM ID'] = self.d365_df['CRM ID'].str.strip().str.lower()
+            self.d365_df = self.d365_df[self.d365_df['CRM ID'].str.match(r'^[0-9a-f]{8}-([0-9a-f]{4}-){3}[0-9a-f]{12}$', na=False)]
+
+            # Leere DataFrames vermeiden: fehlende Spalten aus COLUMN_ORDER ergänzen
+            for col_name in COLUMN_ORDER:
+                if col_name not in self.d365_df.columns:
+                    self.d365_df[col_name] = ''
+
+        except Exception as e:
+            self.logger.critical(f"Fehler beim Laden der Excel-Datei: {e}", exc_info=True)
+            return False
+
+        # ----------------------------
+        # GOOGLE SHEET LADEN + HEADER NORMALISIEREN
+        # ----------------------------
+        self.logger.info("Lade bestehende Daten aus dem Google Sheet...")
+        try:
             all_data_with_headers = self.sheet_handler.get_all_data_with_headers()
-        if not all_data_with_headers or len(all_data_with_headers) < self.sheet_handler._header_rows:
-            self.logger.error("Google Sheet enthält keine gültige Header-Zeile.")
-            self.gsheet_df = pd.DataFrame(columns=COLUMN_ORDER)
-            return
 
+            if not all_data_with_headers or len(all_data_with_headers) < self.sheet_handler._header_rows:
+                # Kein valider Header -> leeres DF mit korrekter Spaltenreihenfolge
+                self.gsheet_df = pd.DataFrame(columns=COLUMN_ORDER)
+            else:
                 actual_header = all_data_with_headers[self.sheet_handler._header_rows - 1]
                 data_rows = all_data_with_headers[self.sheet_handler._header_rows:]
 
-        # Debug: zeige die Roh-Header repräsentiert (um unsichtbare Zeichen sichtbar zu machen)
+                # Header im Log als repr ausgeben, um unsichtbare Zeichen später schnell zu finden
+                try:
                     self.logger.debug("Roh-Header (repr): " + " | ".join(repr(h) for h in actual_header))
+                except Exception:
+                    pass
 
-        # 3) Header-Normalisierung
+                # ---- Header-Normalisierung (NBSP, Zero-Width, BOM, überflüssige Spaces) ----
                 def _norm_header(s: str) -> str:
                     if s is None:
                         return ""
                     s = str(s)
-            # NBSP -> Space, Zero-Width/RTL/BOM entfernen
+                    s = s.replace("\u00A0", " ")  # NBSP -> Space
-            s = s.replace("\u00A0", " ").replace("\u200B", "").replace("\u200E", "").replace("\u200F", "").replace("\ufeff", "")
+                    s = s.replace("\u200B", "").replace("\u200E", "").replace("\u200F", "").replace("\ufeff", "")  # ZWSP/RTL/BOM raus
-            # Control/Format-Zeichen entfernen
+                    # Control/Format Zeichen entfernen
                     s = "".join(ch for ch in s if unicodedata.category(ch) not in ("Cf", "Cc", "Cs"))
                     # Whitespace normalisieren
                     s = re.sub(r"\s+", " ", s).strip()
@@ -126,7 +152,7 @@ class SyncManager:
 
                 norm_header = [_norm_header(h) for h in actual_header]
 
-        # 4) Duplikate in den (normalisierten) Headern eindeutig machen
+                # Evtl. doppelte (normalisierte) Header technisch eindeutig machen
                 seen = {}
                 unique_norm_header = []
                 for h in norm_header:
@@ -134,7 +160,7 @@ class SyncManager:
                     unique_norm_header.append(h if n == 0 else f"{h}__dup{n}")
                     seen[h] = n + 1
 
-        # 5) Datenzeilen auf Header-Länge bringen + zu Strings casten (robust ggü. zu kurzen Zeilen)
+                # Datenzeilen auf Header-Länge bringen und direkt zu Strings casten
                 fixed_rows = []
                 target_len = len(unique_norm_header)
                 for r in data_rows:
@@ -146,9 +172,10 @@ class SyncManager:
 
                 temp_df = pd.DataFrame(fixed_rows, columns=unique_norm_header)
 
-        # 6) Mapping: normalisierte Header -> kanonische Spaltennamen (COLUMN_ORDER)
+                # Kanonische Namen (COLUMN_ORDER) vorbereiten: normalisiert -> Original
-        canon_map = {_norm_header(c): c for c in COLUMN_ORDER}  # z. B. {"CRM Anzahl Techniker": "CRM Anzahl Techniker", ...}
+                canon_map = {_norm_header(c): c for c in COLUMN_ORDER}
 
+                # Spalten umbenennen (normalisierte -> kanonische Namen) und unmappbare loggen
                 rename_map = {}
                 unmapped_cols = []
                 for col in list(temp_df.columns):
@@ -161,7 +188,6 @@ class SyncManager:
                 if rename_map:
                     temp_df.rename(columns=rename_map, inplace=True)
 
-        # Debug: nicht gemappte Spalten melden (einmalig extrem hilfreich zur Ursachenanalyse)
                 if unmapped_cols:
                     self.logger.warning(
                         "Folgende GSheet-Spalten konnten NICHT auf COLUMN_ORDER gemappt werden "
@@ -169,28 +195,62 @@ class SyncManager:
                         + ", ".join([f"{c!r}" for c in unmapped_cols])
                     )
 
-        # 7) Fehlende Spalten (gegenüber COLUMN_ORDER) hinzufügen
+                # Fehlende Spalten (gegenüber COLUMN_ORDER) ergänzen
                 for col_name in COLUMN_ORDER:
                     if col_name not in temp_df.columns:
                         temp_df[col_name] = ""
 
-        # 8) Final in die gewünschte Spaltenreihenfolge bringen
+                # Final in gewünschte Reihenfolge bringen
                 self.gsheet_df = temp_df[COLUMN_ORDER]
 
-        # 9) Optional: Sanity-Check auf das bekannte Problemfeld
+                # Sanity-Check für den gemeldeten Fall (nur Info-Log)
-        if "CRM Anzahl Techniker" in self.gsheet_df.columns:
+                try:
-            # Beispielhafte Debug-Ausgabe für den vom User genannten GUID-Datensatz
+                    if "CRM Anzahl Techniker" in self.gsheet_df.columns and "CRM ID" in self.gsheet_df.columns:
-            guid_col = "accountid" if "accountid" in self.gsheet_df.columns else None
-            if guid_col:
                         probe_guid = "0f68a69d-e330-ec11-b6e6-000d3adbc80e"
-                probe_row = self.gsheet_df[self.gsheet_df[guid_col] == probe_guid]
+                        probe_row = self.gsheet_df[self.gsheet_df["CRM ID"].str.lower() == probe_guid]
                         if not probe_row.empty:
                             val = probe_row.iloc[0]["CRM Anzahl Techniker"]
                             self.logger.info(
                                 f"Sanity-Check: GSheet['CRM Anzahl Techniker'] für {probe_guid} -> {val!r} (Typ: {type(val)})"
                             )
+                except Exception:
+                    # Nur zur Sicherheit – Sync soll nicht am Check scheitern
+                    pass
+
+        except Exception as e:
+            self.logger.critical(f"Fehler beim Laden/Umwandeln der GSheet-Daten: {e}", exc_info=True)
+            return False
+
+        # ----------------------------
+        # ZIEL-SHEET ERMITTELN & SYNC-BASIS BESTIMMEN
+        # ----------------------------
+        self.target_sheet_name = self.sheet_handler.get_main_sheet_name()
+        if not self.target_sheet_name:
+            self.logger.critical("Konnte Namen des Ziel-Sheets nicht ermitteln. Abbruch.")
+            return False
+
+        # IDs bestimmen (nur auf gefüllte CRM IDs)
+        d365_ids = set(self.d365_df['CRM ID'].dropna()) if 'CRM ID' in self.d365_df.columns else set()
+        gsheet_ids = set(self.gsheet_df['CRM ID'].dropna()) if 'CRM ID' in self.gsheet_df.columns else set()
+
+        new_ids = d365_ids - gsheet_ids
+        existing_ids = d365_ids.intersection(gsheet_ids)
+
+        # Archivierung wird (wie bisher) übersprungen – Teil-Export angenommen
+        deleted_ids = set()
+        self.logger.info("Archivierungs-Schritt wird übersprungen (Teil-Export angenommen).")
+
+        self.logger.info(
+            f"Sync-Basis: {len(new_ids)} neu, {len(existing_ids)} vorhanden, {len(deleted_ids)} gelöscht (übersprungen)."
+        )
+
+        # Ergebnisse in Objekt speichern
+        self.new_ids = new_ids
+        self.existing_ids = existing_ids
+        self.deleted_ids = deleted_ids
+
+        return True
 
-        self.logger.info("_load_data() abgeschlossen.")
 
     def run_sync(self):
         """Führt den gesamten Synchronisationsprozess aus."""