From 9eb0750ea3038996150f7cd19af3401ae75dbc82 Mon Sep 17 00:00:00 2001 From: Floke Date: Tue, 27 May 2025 05:39:15 +0000 Subject: [PATCH] bugfix --- list_generator.py | 228 ++++++++++++++++++---------------------------- 1 file changed, 90 insertions(+), 138 deletions(-) diff --git a/list_generator.py b/list_generator.py index 9109c837..114fffba 100644 --- a/list_generator.py +++ b/list_generator.py @@ -4,11 +4,11 @@ import collections import os.path from google.oauth2 import service_account -from googleapiclient.discovery import build +from googleapiclient.discovery import build # discovery wird für das resource-Objekt der Lib benötigt from googleapiclient.errors import HttpError -# Importiere die neue Bibliothek -from gdoctableapppy.gdoctableapp import DocsTableApp +# Importiere die neue Bibliothek - KORRIGIERTER IMPORT und KLASSENNAME +from gdoctableapppy.gdoctableapp import gdoctableapp # Klasse ist klein geschrieben # --- Konfiguration --- CSV_FILENAME = 'Namensliste.csv' @@ -41,165 +41,127 @@ def get_services_with_service_account(): except Exception as e: print(f"Fehler Drive Service: {e}") return docs_service, drive_service -def generate_tables_with_gdoctableapp(docs_service, document_id_to_fill): - """ - Befüllt ein existierendes Dokument mit echten Tabellen pro Gruppe - unter Verwendung der gdoctableapppy Bibliothek. - """ - - kinder_nach_gruppen = collections.defaultdict(list) - try: - with open(CSV_FILENAME, mode='r', encoding='utf-8-sig', newline='') as csvfile: - reader = csv.DictReader(csvfile, delimiter=';') - # ... (CSV Leselogik wie gehabt) ... - for row in reader: - vorname = row.get('Vorname','').strip(); nachname = row.get('Nachname','').strip(); gruppe_original = row.get('Gruppe','').strip() - if not vorname or not nachname or not gruppe_original: continue - kinder_nach_gruppen[gruppe_original].append({'Nachname': nachname, 'Vorname': vorname}) - except Exception as e: print(f"FEHLER CSV-Lesen: {e}"); return False - if not kinder_nach_gruppen: print("Keine CSV-Daten."); return False - - for gk_key in kinder_nach_gruppen: - kinder_nach_gruppen[gk_key].sort(key=lambda x: (x['Nachname'].lower(), x['Vorname'].lower())) - sorted_gruppen_namen = sorted(kinder_nach_gruppen.keys()) - stand_zeit = datetime.now().strftime("%d.%m.%Y %H:%M Uhr") +def generate_tables_with_gdoctableapp(docs_api_service, document_id_to_fill): # docs_api_service ist hier unser "docsService" + # ... (CSV-Lesen und Datenaufbereitung in kinder_nach_gruppen bleibt gleich) ... + # sorted_gruppen_namen, stand_zeit bleiben - # Initialisiere DocsTableApp - # Die Bibliothek erwartet 'creds' oder 'service'. Da wir 'service' haben: + # Initialisiere gdoctableapp try: - dta = DocsTableApp(service=docs_service) - #util = Utility() # Für endOfSegmentLocation, falls wir es für Text außerhalb brauchen + resource_for_lib = { + "docsService": docs_api_service, # Unser Service-Objekt + "documentId": document_id_to_fill + } + gtable_manager = gdoctableapp(resource_for_lib) # Instanz der Klasse erstellen except Exception as e_dta_init: - print(f"Fehler bei der Initialisierung von DocsTableApp: {e_dta_init}") + print(f"Fehler bei der Initialisierung von gdoctableapp: {e_dta_init}") return False - # Liste für Requests, die nicht von DocsTableApp direkt gehandhabt werden (z.B. reiner Text, PageBreaks) - additional_requests = [] + additional_requests = [] # Für Text außerhalb von Tabellen und Seitenumbrüche for i, gruppe_original in enumerate(sorted_gruppen_namen): - kinder_liste = kinder_nach_gruppen[gruppe_original] - anzahl_kinder = len(kinder_liste) - gruppe_display_name = gruppe_original + GRUPPENNAME_SUFFIX + # ... (kinder_liste, anzahl_kinder, gruppe_display_name wie zuvor) ... - # 1. Daten für die Tabelle vorbereiten (Liste von Listen) table_values = [] - table_values.append(["Nachname", "Vorname", "Gruppe"]) # Kopfzeile + table_values.append(["Nachname", "Vorname", "Gruppe"]) for kind in kinder_liste: table_values.append([kind['Nachname'], kind['Vorname'], gruppe_display_name]) - # 2. Tabelle mit gdoctableapppy einfügen - # Wir müssen den Einfügeindex bestimmen. - # Für die erste Tabelle (i==0) nach der initialen Info (die in main eingefügt wurde), - # verwenden wir endOfSegmentLocation. Für weitere Tabellen auch. - current_insert_location = util.get_end_of_segment_location() - try: - print(f"Versuche Tabelle für Gruppe '{gruppe_original}' mit gdoctableapppy einzufügen...") + print(f"Versuche Tabelle für Gruppe '{gruppe_original}' mit gdoctableapp einzufügen...") - # Definiere Stil für die Kopfzeile (fett) - # Die Syntax hier ist eine Annahme basierend auf typischen Bibliotheksmustern. - # Ggf. muss dies an die genaue Implementierung von gdoctableapppy angepasst werden. - # Die Bibliothek könnte eine Methode wie `set_range_style` oder `format_cells` haben. - # Tanaikes Bibliotheken sind oft sehr flexibel. - - # `add_table` sendet das BatchUpdate direkt oder gibt Requests zurück. - # Laut Doku: "This method uses Docs API. So when this method is used, the table is directly created to Google Document." - # Das bedeutet, wir müssen die Requests nicht sammeln und selbst senden für die Tabelle. - - # Index für add_table: Wenn None, wird es ans Ende angehängt. - # Da wir die einmalige Info in main eingefügt haben, sollte None hier passen. - # Und für Folgetabellen wird es auch ans Ende (nach dem PageBreak) angehängt. + # Tabelle einfügen. index=None hängt sie ans Ende des Dokuments an (relativ zum aktuellen Inhalt). + # Da wir die "einmalige Info" zuerst schreiben, wird die erste Tabelle danach angehängt. + # Folgende Tabellen werden nach dem PageBreak angehängt. + res_table_obj = gtable_manager.add_table(values=table_values, index=None) - # Einfügen der Tabelle - res_table = dta.add_table(document_id_to_fill, values=table_values, index=None) # index=None hängt ans Ende an - - # Nun versuchen, die Kopfzeile fett zu machen. - # Wir brauchen eine Referenz auf die Tabelle oder ihre Position, um die Kopfzeile zu formatieren. - # `add_table` gibt laut Doku die `startIndex` der Tabelle zurück. - # { "table_object": created_table_object, "startIndex": table_start_index, "endIndex": table_end_index } - # Die Formatierung ist komplexer, da sie Zellbereiche benötigt. - # Die Bibliothek hat `update_text_style_to_range` - # update_text_style_to_range(document_id, text_style, fields, text_range=None, table_range=None) - # table_range = {"table_start_index": tableStartIndex, "row_index": 0, "column_index": 0, "row_span": 1, "column_span": 3} (Beispiel) + if res_table_obj and "table_object" in res_table_obj and "created_table" in res_table_obj["table_object"]: + created_table_info = res_table_obj["table_object"]["created_table"] + table_start_idx = created_table_info.get("startIndex") - if res_table and "startIndex" in res_table: - table_start_idx = res_table["startIndex"] - header_range = { - "table_start_index": table_start_idx, - "row_index": 0, # Erste Zeile (Kopfzeile) - "column_index": 0, # Erste Spalte - "row_span": 1, # Nur eine Zeile - "column_span": 3 # Über alle 3 Spalten der Kopfzeile - } - text_style_bold = {"bold": True} - fields_bold = "bold" - dta.update_text_style_to_range(document_id_to_fill, text_style_bold, fields_bold, table_range=header_range) - print(f" Kopfzeile für Tabelle '{gruppe_original}' versucht fett zu formatieren.") + if table_start_idx is not None: + # Definiere den Bereich für die Kopfzeile + # table_range für update_text_style_to_range braucht tableStartIndex (groß S, kleines i) + header_range_for_style = { + "tableStartIndex": table_start_idx, # Korrekter Schlüsselname + "rowIndex": 0, + "columnIndex": 0, + "rowSpan": 1, + "colSpan": 3 + } + text_style_bold = {"bold": True} + fields_bold = "bold" + # Die Methode update_text_style_to_range ist in gdoctableapp, nicht DocsTableApp + gtable_manager.update_text_style_to_range(text_style_bold, fields_bold, table_range=header_range_for_style) + print(f" Kopfzeile für Tabelle '{gruppe_original}' versucht fett zu formatieren.") + else: + print(f" Konnte startIndex für Tabelle '{gruppe_original}' nicht erhalten, Kopfzeile nicht formatiert.") else: - print(f" Konnte startIndex für Tabelle '{gruppe_original}' nicht erhalten, Kopfzeile nicht formatiert.") - - - # 3. Text unter der Tabelle einfügen (Anzahl Kinder, etc.) - # Dies muss als separater Textblock NACH der Tabelle eingefügt werden. - # Wir verwenden dafür `additional_requests` und `endOfSegmentLocation`. - footer_lines_for_group = [] - footer_lines_for_group.append("") # Leerzeile nach der Tabelle - footer_lines_for_group.append(f"{anzahl_kinder} angemeldete Kinder") - footer_lines_for_group.append("") - footer_lines_for_group.append("Dies ist die Liste der bereits angemeldeten Kinder. Bitte die Eltern der noch fehlenden") - footer_lines_for_group.append("Kinder an die Anmeldung erinnern.") - footer_lines_for_group.append("") - footer_lines_for_group.append(f"Stand {stand_zeit}") - footer_lines_for_group.append("") + print(f" Unerwartete Antwort von add_table, Kopfzeile nicht formatiert: {res_table_obj}") + # Text unter der Tabelle + footer_lines_for_group = [""] # Leerzeile nach Tabelle + footer_lines_for_group.append(f"{anzahl_kinder} angemeldete Kinder") + # ... (Rest des Footers für die Gruppe) ... + footer_lines_for_group.append(""); footer_lines_for_group.append("Dies ist die Liste der bereits angemeldeten Kinder. Bitte die Eltern der noch fehlenden"); footer_lines_for_group.append("Kinder an die Anmeldung erinnern."); footer_lines_for_group.append(""); footer_lines_for_group.append(f"Stand {stand_zeit}"); footer_lines_for_group.append("") full_footer_text_for_group = "\n".join(footer_lines_for_group) + "\n" - additional_requests.append({'insertText': {'endOfSegmentLocation': {}, 'text': full_footer_text_for_group}}) + + # Wichtig: Die Bibliothek gdoctableapp sendet ihre BatchUpdates selbst. + # Wir müssen den Text danach mit einem neuen BatchUpdate oder einer Methode der Lib einfügen. + # `gtable_manager.add_text(text, index=None)` könnte hier verwendet werden. + if full_footer_text_for_group.strip(): # Nur einfügen, wenn Text vorhanden ist + gtable_manager.add_text(text=full_footer_text_for_group, index=None) # index=None hängt an except Exception as e_table: - print(f"Fehler beim Erstellen/Formatieren der Tabelle für Gruppe '{gruppe_original}' mit gdoctableapppy: {e_table}") - # Fallback: Füge die Daten als einfachen Text ein, wenn die Bibliothek fehlschlägt - fallback_text_lines = ["FEHLER BEI TABELLENERSTELLUNG FÜR DIESE GRUPPE"] - kopf_nachname = "Nachname".ljust(25); kopf_vorname = "Vorname".ljust(25) - fallback_text_lines.append(f"{kopf_nachname}\t{kopf_vorname}\tGruppe") - for r in table_values[1:]: fallback_text_lines.append(f"{r[0].ljust(25)}\t{r[1].ljust(25)}\t{r[2]}") - additional_requests.append({'insertText': {'endOfSegmentLocation': {}, 'text': "\n".join(fallback_text_lines) + "\n\n"}}) + print(f"Fehler bei Tabelle für Gruppe '{gruppe_original}': {e_table}") + # Fallback (fügen wir als separaten Request hinzu, falls die Lib-Operationen fehlschlagen) + additional_requests.append({'insertText': {'endOfSegmentLocation': {}, 'text': f"\nFEHLER BEI TABELLE {gruppe_original}\n"}}) - - # 4. Seitenumbruch (wenn nicht die letzte Gruppe) if i < len(sorted_gruppen_namen) - 1: - additional_requests.append({'insertPageBreak': {'endOfSegmentLocation': {}}}) + # PageBreak muss auch über die Lib oder einen separaten Batch erfolgen + # Die Lib hat `gtable_manager.add_page_break(index=None)` + try: + gtable_manager.add_page_break(index=None) # index=None hängt an + except Exception as e_pb: + print(f"Fehler beim Einfügen des PageBreak nach {gruppe_original}: {e_pb}") + additional_requests.append({'insertPageBreak': {'endOfSegmentLocation': {}}}) # Fallback - # Führe die zusätzlichen Requests aus (für Text unter Tabellen und Seitenumbrüche) - if additional_requests: + # Wenn es `additional_requests` gab (z.B. für Fehler-Fallbacks) + if additional_requests and docs_api_service: try: - print(f"Sende zusätzliche Requests (Footer-Texte, PageBreaks) für Doc ID '{document_id_to_fill}'...") - docs_service.documents().batchUpdate(documentId=document_id_to_fill, body={'requests': additional_requests}).execute() - print("Zusätzliche Requests erfolgreich ausgeführt.") + print(f"Sende zusätzliche Fallback-Requests für Doc ID '{document_id_to_fill}'...") + docs_api_service.documents().batchUpdate(documentId=document_id_to_fill, body={'requests': additional_requests}).execute() except HttpError as err: - print(f"Fehler beim Ausführen der zusätzlichen Requests für Doc ID '{document_id_to_fill}': {err}") - # ... (Fehlerdetails) ... - return False # Befüllen war nicht vollständig erfolgreich + print(f"Fehler bei zusätzlichen Requests: {err}") + return False return True # --- Main execution block --- +# (Bleibt weitgehend gleich, ruft generate_tables_with_gdoctableapp auf) if __name__ == "__main__": print(f"Info: Ordner-ID für Dokument: '{TARGET_FOLDER_ID}'") + # Wichtig: discovery.build wird für das resource Objekt der Lib gebraucht, + # unser get_services_with_service_account gibt aber das schon gebaute service Objekt zurück. + # Wir sollten `creds` zurückgeben und den Service ggf. neu bauen oder das `resource` Objekt anpassen. + # Einfacher: `docs_api_service` ist das, was die Lib als `docsService` braucht. + docs_api_service, drive_api_service = get_services_with_service_account() if not docs_api_service: print("Konnte Google Docs API Service nicht initialisieren. Skript wird beendet.") else: document_id = None - # 1. Dokument erstellen + # 1. Dokument erstellen (wie zuvor) + # ... (Code für Dokumenterstellung bleibt gleich) ... if drive_api_service and TARGET_FOLDER_ID: + # ... (Drive API Erstellung) ... file_metadata = {'name': GOOGLE_DOC_TITLE, 'mimeType': 'application/vnd.google-apps.document', 'parents': [TARGET_FOLDER_ID]} try: created_file = drive_api_service.files().create(body=file_metadata, fields='id').execute() document_id = created_file.get('id') print(f"Neues leeres Doc via Drive API in Ordner '{TARGET_FOLDER_ID}' erstellt, ID: {document_id}") except Exception as e: print(f"Fehler Drive API Erstellung: {e}\n Versuche Fallback...") - if not document_id: # Fallback + if not document_id: try: doc = docs_api_service.documents().create(body={'title': GOOGLE_DOC_TITLE}).execute() document_id = doc.get('documentId') @@ -208,28 +170,18 @@ if __name__ == "__main__": except Exception as e: print(f"Konnte leeres Doc auch nicht mit Docs API erstellen: {e}") if document_id: - # 2. Einmalige Info (Kita, Datum) GANZ AM ANFANG des Dokuments einfügen - initial_info_lines = [ - "Info zum Kopieren für Ihre manuelle Kopfzeile:", - EINRICHTUNG_INFO, FOTODATUM_INFO, - "\n" + "="*70 + "\n" - ] - initial_text = "\n".join(initial_info_lines) + "\n" - initial_requests = [{'insertText': {'location': {'index': 1}, 'text': initial_text}}] - try: - docs_api_service.documents().batchUpdate(documentId=document_id, body={'requests': initial_requests}).execute() - print("Einmalige Info am Dokumentanfang eingefügt.") - except HttpError as err: print(f"Fehler beim Einfügen der einmaligen Info: {err}") + # 2. Einmalige Info am Anfang + # ... (Code für initial_info bleibt gleich, wird mit docs_api_service.batchUpdate eingefügt) ... + initial_info_lines = ["Info zum Kopieren für Ihre manuelle Kopfzeile:", EINRICHTUNG_INFO, FOTODATUM_INFO, "\n" + "="*70 + "\n" ] + initial_text = "\n".join(initial_info_lines) + "\n"; initial_requests = [{'insertText': {'location': {'index': 1}, 'text': initial_text}}] + try: docs_api_service.documents().batchUpdate(documentId=document_id, body={'requests': initial_requests}).execute(); print("Einmalige Info eingefügt.") + except HttpError as err: print(f"Fehler bei einmaliger Info: {err}") - # 3. Dokument mit gruppenspezifischen Daten (echte Tabellen) befüllen + # 3. Dokument mit Tabellen befüllen success_filling = generate_tables_with_gdoctableapp(docs_api_service, document_id) if success_filling: - print(f"\n--- SKRIPT BEENDET ---") - print(f"Dokument-ID: {document_id}") - print(f"Link: https://docs.google.com/document/d/{document_id}/edit") - print("HINWEIS: Es wurde versucht, echte Tabellen mit fetter Kopfzeile zu erstellen.") - else: - print("\n--- FEHLER BEIM BEFÜLLEN DES DOKUMENTS MIT TABELLEN ---") - else: - print("\n--- FEHLGESCHLAGEN: Konnte kein Dokument erstellen ---") \ No newline at end of file + print(f"\n--- SKRIPT BEENDET ---"); print(f"Dokument-ID: {document_id}"); print(f"Link: https://docs.google.com/document/d/{document_id}/edit") + print("HINWEIS: Es wurde versucht, echte Tabellen mit fetter Kopfzeile via gdoctableapppy zu erstellen.") + else: print("\n--- FEHLER BEIM BEFÜLLEN MIT TABELLEN ---") + else: print("\n--- FEHLGESCHLAGEN: Kein Dokument erstellt ---") \ No newline at end of file