dogfather-universe/server/pruef-xlsx.mjs

/* EXCEL-DATEIEN LESEN (14.09.2026)

   Filipe: "mach doch bitte so dass man alle dateien hoch laden könne
   auch excel dateien. gib gas und krieg das hin."

   ---------------------------------------------------------------------
   WOGEGEN HIER GEPRÜFT WIRD

   Die Vorlage sind ZWEI ECHTE Backstage-Ausgaben (11. und 12.09.2026),
   die auf dem Rechner lagen. Sie haben mir gesagt, was Backstage
   wirklich schreibt – und das war an drei Stellen anders, als ich es
   mir gedacht hätte:

     * ALLE Zellen sind `t="s"` (Zeichenkettentabelle). Backstage legt
       sogar Zahlen als Text ab.
     * "Creator:innen verwalten" hat in Zeile 1 nur einen Titel
       ("Exportiert am :…"), die Überschriften stehen in Zeile 2.
     * Die Spalte "LIVE-Dauer" enthält `86Std. 10Min. 52Sek.` und
       "Datenzeitraum" einen ZEITRAUM: `2026-09-01 ~ 2026-09-11`.

   DIE ECHTEN DATEIEN STEHEN NICHT IM REPO – in ihnen stehen die Namen
   und Zahlen von Filipes Creator:innen. Stattdessen baut diese Prüfung
   eine .xlsx mit **derselben Form** und erfundenen Namen. Die echten
   Dateien haben die Form belegt; die Prüfung hält sie fest.

   WARUM DIE DATEI HIER GEBAUT WIRD UND NICHT DANEBEN LIEGT: Eine
   Beispieldatei im Repo altert unbemerkt. Eine, die im Lauf entsteht,
   sagt in ihrem Quelltext, was sie darstellt – und wer sie ändert,
   sieht sofort, was er ändert.

   Aufruf:  node server/pruef-xlsx.mjs
   ===================================================================== */


let fehler = 0;
let geprueft = 0;
const ok = (b, t) => { geprueft++; console.log((b ? "  ok   " : "  FEHL ") + t); if (!b) fehler++; };

const { xlsxLesen, tabelleAbKopf, alsText, istZip, istAltesExcel, XlsxFehler } =
  await import("./workspace-xlsx.js");
const { dauerLesen, zeitraumLesen, datumLesen, zahlLesen, csvZerlegen, spaltenRaten } =
  await import("./workspace-leistung.js");

/* =======================================================================
   EIN ZIP-SCHREIBER — damit die Prüfung ECHTE Dateien erzeugt
   =======================================================================
   Ohne ihn müsste ich eine fertige .xlsx ins Repo legen und hoffen,
   dass sie die Wirklichkeit trifft. So steht jedes Byte hier im
   Quelltext, und die Prüfung kann Fälle bauen, die es als Datei gar
   nicht gibt (kaputtes Verzeichnis, fehlendes Blatt, leere Tabelle).

   `crc32` gibt es in Node seit v22 – fällt es aus, sagt die Prüfung
   das (dritter Ausgang) statt stillschweigend etwas Falsches zu bauen.
   ======================================================================= */
const { zipBauen, xlsxBauen, RELS, kannXlsxBauen } =
  await import("./helfer-xlsx-bauen.mjs");
if (!kannXlsxBauen) {
  console.error("KONNTE NICHT NACHSEHEN: node:zlib kennt kein crc32 "
    + "(gebraucht wird Node 22+). Die Pruefung baut ihre Dateien selbst "
    + "und kann ohne Pruefsumme keine gueltige .xlsx erzeugen.");
  process.exit(2);
}

/* =======================================================================
   1. Die Form, die Backstage wirklich liefert
   ======================================================================= */
console.log("\n=== Die Backstage-Form ===");
const BACKSTAGE = [
  ["Datenzeitraum", "Creator*in-ID", "Creator*innen-Anmeldename", "Gruppe",
   "Diamanten", "LIVE-Dauer", "Gültige LIVE-Gehen-Tage", "Neue Follower*innen"],
  ["2026-09-06 ~ 2026-09-06", "700001", "nova_live", "Spicy",
   "12.480", "86Std. 10Min. 52Sek.", "11", "205"],
  ["2026-09-06 ~ 2026-09-06", "700002", "kiro_on", "Spicy",
   "3.900", "2Std. 5Min.", "4", "18"],
];
{
  const datei = xlsxBauen(BACKSTAGE);
  ok(istZip(datei), "die gebaute Datei ist ein ZIP (wie eine echte .xlsx)");
  const { blatt, zeilen } = xlsxLesen(datei);
  ok(blatt === "Sheet1", `das Blatt heisst "${blatt}"`);
  ok(zeilen.length === 3, `drei Zeilen gelesen (${zeilen.length})`);
  ok(zeilen[0].length === 8, `acht Spalten (${zeilen[0].length})`);
  ok(zeilen[0][0] === "Datenzeitraum" && zeilen[0][6] === "Gültige LIVE-Gehen-Tage",
    "die Umlaute kommen heil an");
  ok(zeilen[1][5] === "86Std. 10Min. 52Sek.",
    `die LIVE-Dauer steht woertlich da ("${zeilen[1][5]}")`);
}

/* =======================================================================
   2. Die Titelzeile, über die ich gestolpert wäre
   ======================================================================= */
console.log("\n=== Eine Titelzeile über der Tabelle ===");
{
  /* So sieht "Creator:innen verwalten" aus: Zeile 1 eine einzige
     Zelle, die Überschriften erst darunter. */
  const mitTitel = [["Exportiert am :2026-09-11 13:10:35"], ...BACKSTAGE];
  const { zeilen } = xlsxLesen(xlsxBauen(mitTitel));
  ok(zeilen.length === 4, `vier Zeilen in der Datei (${zeilen.length})`);

  const t = tabelleAbKopf(zeilen);
  ok(t.uebersprungen === 1, `eine Titelzeile faellt weg (${t.uebersprungen})`);
  ok(t.zeilen[0][0] === "Datenzeitraum",
    `die Ueberschrift ist jetzt die richtige ("${t.zeilen[0][0]}")`);

  /* GEGENPROBE: Ohne Titelzeile darf NICHTS wegfallen -- sonst waere
     die Regel eine, die immer eine Zeile frisst. */
  const ohne = tabelleAbKopf(xlsxLesen(xlsxBauen(BACKSTAGE)).zeilen);
  ok(ohne.uebersprungen === 0, `ohne Titel faellt nichts weg (${ohne.uebersprungen})`);

  /* UND EINE ECHTE SCHMALE TABELLE bleibt ganz. Drei Spalten sind eine
     Tabelle, keine Ueberschrift. */
  const schmal = tabelleAbKopf(
    xlsxLesen(xlsxBauen([["Datum", "Diamanten", "Dauer"], ["2026-09-06", "10", "20"]])).zeilen);
  ok(schmal.uebersprungen === 0, `eine schmale Tabelle bleibt unangetastet (${schmal.uebersprungen})`);
}

/* =======================================================================
   3. Der teuerste Fehler: ein Zeitraum, der wie ein Tag aussieht
   ======================================================================= */
console.log("\n=== Zeitraum ist kein Tag ===");
{
  ok(datumLesen("2026-09-01 ~ 2026-09-11") === "2026-09-01",
    "datumLesen allein greift sich weiterhin den ersten Tag – deshalb braucht es zeitraumLesen");
  const z = zeitraumLesen("2026-09-01 ~ 2026-09-11");
  ok(z?.von === "2026-09-01" && z?.bis === "2026-09-11",
    `der Zeitraum wird als solcher erkannt (${z?.von} bis ${z?.bis})`);
  const einTag = zeitraumLesen("2026-09-06 ~ 2026-09-06");
  ok(einTag?.von === einTag?.bis,
    "ein Zeitraum von EINEM Tag ist kein Zeitraum -- der geht durch");
  ok(zeitraumLesen("2026-09-06") === null,
    "ein einzelnes Datum faellt nicht darauf herein");
  ok(zeitraumLesen("Diamanten") === null, "und Text erst recht nicht");
  const deutsch = zeitraumLesen("01.09.2026 - 11.09.2026");
  ok(deutsch?.von === "2026-09-01" && deutsch?.bis === "2026-09-11",
    "auch die deutsche Schreibweise");
}

/* =======================================================================
   4. Die Einheit ist die Falle
   ======================================================================= */
console.log("\n=== Dauer mit Einheit ===");
{
  const faelle = [
    ["86Std. 10Min. 52Sek.", 5171, "die echte Backstage-Schreibweise"],
    ["86 Std 10 Min", 5170, "mit Leerzeichen"],
    ["2 Stunden 5 Minuten", 125, "ausgeschrieben"],
    ["3h 20m", 200, "englisch kurz"],
    ["86:10:52", 5171, "als Uhrzeit"],
    ["184", 184, "blosse Zahl bleibt eine Zahl (Minuten, wie bisher)"],
    ["0", 0, "Null ist ein Wert, nicht nichts"],
  ];
  for (const [text, soll, warum] of faelle) {
    const ist = dauerLesen(text);
    ok(ist === soll, `"${text}" -> ${ist} (erwartet ${soll}) – ${warum}`);
  }
  ok(dauerLesen("") === null && dauerLesen(null) === null,
    "leer bleibt leer -- und wird nicht zu 0");

  /* WARUM DAS EINE EIGENE FUNKTION BRAUCHTE: Der alte Weg ergab hier
     nichts. Haette er "86" geliefert, stuenden 86 Minuten statt 5171
     in der Datenbank -- plausibel und um Faktor 60 daneben. */
  ok(zahlLesen("86Std. 10Min. 52Sek.") === null,
    "zahlLesen allein kommt damit nicht klar -- das ist der Grund fuer dauerLesen");
}

/* =======================================================================
   5. Der ganze Weg: Datei -> Text -> Zerlegung -> Spalten
   ======================================================================= */
console.log("\n=== Vom Excel bis zur Spaltenzuordnung ===");
{
  const { zeilen } = xlsxLesen(xlsxBauen([["Exportiert am :…"], ...BACKSTAGE]));
  const text = alsText(tabelleAbKopf(zeilen).zeilen);
  ok(text.split("\n").length === 3, `drei Textzeilen (${text.split("\n").length})`);
  ok(text.includes("\t"), "TAB-getrennt -- genau wie eine eingefuegte Tabelle");

  const tabelle = csvZerlegen(text);
  ok(tabelle.length === 3, `csvZerlegen findet drei Zeilen (${tabelle.length})`);
  ok(tabelle[0].length === 8, `und acht Spalten (${tabelle[0].length})`);

  const zu = spaltenRaten(tabelle[0]);
  ok(tabelle[0][zu.diamanten] === "Diamanten", "die Diamanten-Spalte wird gefunden");
  ok(tabelle[0][zu.dauer_min] === "LIVE-Dauer", "die Dauer-Spalte ebenfalls");
  ok(tabelle[0][zu.follower_neu] === "Neue Follower*innen", "und die Follower-Spalte");
  ok(tabelle[0][zu.tag] === "Datenzeitraum", "und der Zeitraum als Datumsspalte");

  /* GEFUNDEN AM ECHTEN EXPORT (14.09.2026): Das alte Muster
     `/datum|date|tag|day/i` erklaerte "Tage seit dem Beitritt" zur
     Datumsspalte -- Wert "65". In der Leistungstabelle daneben traefe
     es "Gueltige LIVE-Gehen-Tage" genauso. Beide sind Zaehlungen, kein
     Datum.

     Die Gegenprobe steht daneben, damit "trifft nicht" nicht einfach
     heisst, dass gar nichts mehr trifft. */
  for (const [name, sollTreffen] of [
    ["Datenzeitraum", true], ["Datum", true], ["Tag", true], ["Day", true],
    ["Tage seit dem Beitritt", false], ["Gültige LIVE-Gehen-Tage", false],
    ["Livestreams", false],
  ]) {
    const trifft = spaltenRaten([name]).tag === 0;
    ok(trifft === sollTreffen,
      `"${name}" ${sollTreffen ? "ist" : "ist NICHT"} die Datumsspalte (erkannt: ${trifft})`);
  }

  /* Und die Werte, die dahinter herauskommen. */
  ok(zahlLesen(tabelle[1][zu.diamanten]) === 12480,
    `"12.480" wird zu ${zahlLesen(tabelle[1][zu.diamanten])} und nicht zu 12,48`);
  ok(dauerLesen(tabelle[1][zu.dauer_min]) === 5171,
    `und die Dauer zu ${dauerLesen(tabelle[1][zu.dauer_min])} Minuten`);
}

/* =======================================================================
   6. Lücken, Zahlen, Datumsformate
   ======================================================================= */
console.log("\n=== Was eine Tabelle sonst noch enthaelt ===");
{
  /* FEHLENDE ZELLEN VERSCHIEBEN NICHTS. In der Datei steht eine leere
     Zelle gar nicht -- wer stur der Reihe nach liest, schiebt ab dort
     jede Spalte um eins. Die Zeile sieht danach voll aus. */
  const loecher = [["A", "B", "C", "D"], ["1", "", "", "4"]];
  const { zeilen } = xlsxLesen(xlsxBauen(loecher));
  ok(zeilen[1].length === 4, `die Luecken-Zeile hat vier Felder (${zeilen[1].length})`);
  ok(zeilen[1][0] === "1" && zeilen[1][3] === "4",
    `und "4" steht in Spalte 4, nicht in Spalte 2 ("${zeilen[1][3]}")`);
}
{
  /* ECHTE ZAHLEN UND ECHTE DATEN -- also nicht die Backstage-Form,
     sondern das, was entsteht, sobald jemand die Datei in Excel
     oeffnet und speichert. Dann stehen dort Seriennummern. */
  const blatt = `<?xml version="1.0" encoding="UTF-8"?>
<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"><sheetData>
<row r="1"><c r="A1" t="inlineStr"><is><t>Datum</t></is></c><c r="B1" t="inlineStr"><is><t>Diamanten</t></is></c></row>
<row r="2"><c r="A2" s="1"><v>46271</v></c><c r="B2"><v>12480</v></c></row>
<row r="3"><c r="A3" s="0"><v>46271</v></c><c r="B3" t="b"><v>1</v></c></row>
</sheetData></worksheet>`;
  const styles = `<?xml version="1.0" encoding="UTF-8"?>
<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
<cellXfs count="2"><xf numFmtId="0"/><xf numFmtId="14"/></cellXfs></styleSheet>`;
  const mappe = `<?xml version="1.0" encoding="UTF-8"?>
<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><sheets><sheet name="Zahlen" sheetId="1" r:id="rId1"/></sheets></workbook>`;
  const datei = zipBauen([
    ["xl/workbook.xml", mappe],
    ["xl/_rels/workbook.xml.rels", RELS],
    ["xl/styles.xml", styles],
    ["xl/worksheets/sheet1.xml", blatt],
  ]);
  const { blatt: name, zeilen } = xlsxLesen(datei);
  ok(name === "Zahlen", `der Blattname kommt aus der Mappe ("${name}")`);
  ok(zeilen[0][0] === "Datum", "eingebettete Zeichenketten (inlineStr) werden gelesen");
  ok(zeilen[1][0] === "2026-09-06",
    `die Seriennummer 46271 wird zum Datum ("${zeilen[1][0]}")`);
  ok(zeilen[1][1] === "12480", `eine gewoehnliche Zahl bleibt eine Zahl ("${zeilen[1][1]}")`);
  /* GEGENPROBE ZUM DATUM: DIESELBE Zahl ohne Datumsformat bleibt eine
     Zahl. Ohne sie hiesse die Zeile darueber nur, dass alles zu einem
     Datum wird. */
  ok(zeilen[2][0] === "46271",
    `dieselbe Zahl ohne Datumsformat bleibt eine Zahl ("${zeilen[2][0]}")`);
  ok(zeilen[2][1] === "WAHR", `ein Wahrheitswert wird lesbar ("${zeilen[2][1]}")`);
}

/* =======================================================================
   7. Was schiefgehen kann, muss SAGEN was schiefging
   ======================================================================= */
console.log("\n=== Der dritte Ausgang ===");
{
  const versuch = (puffer, was) => {
    try { xlsxLesen(puffer); return { ok: true }; }
    catch (f) { return { ok: false, name: f?.name, text: f?.message }; }
  };
  const alt = Buffer.from([0xd0, 0xcf, 0x11, 0xe0, 0xa1, 0xb1, 0x1a, 0xe1, 0, 0]);
  ok(istAltesExcel(alt), "eine alte .xls wird am Inhalt erkannt");
  const a = versuch(alt);
  ok(!a.ok && a.name === "XlsxFehler" && /\.xlsx|CSV/.test(a.text),
    `und bekommt eine Antwort, die weiterhilft ("${(a.text || "").slice(0, 46)}…")`);

  const b = versuch(Buffer.from("Datum;Diamanten\n2026-09-06;10\n", "utf8"));
  ok(!b.ok && /keine Excel-Datei/i.test(b.text || ""),
    `eine CSV wird nicht fuer eine Excel-Datei gehalten ("${(b.text || "").slice(0, 40)}…")`);

  /* Ein ZIP, in dem kein Tabellenblatt steckt. */
  const c = versuch(zipBauen([["xl/workbook.xml", "<workbook/>"]]));
  ok(!c.ok && /Tabellenblatt/.test(c.text || ""),
    `ein ZIP ohne Blatt sagt genau das ("${(c.text || "").slice(0, 40)}…")`);

  /* Ein abgeschnittenes ZIP -- die haeufigste kaputte Datei ueberhaupt. */
  const heil = xlsxBauen(BACKSTAGE);
  const d = versuch(heil.subarray(0, Math.floor(heil.length / 2)));
  ok(!d.ok && d.name === "XlsxFehler",
    `eine abgeschnittene Datei wird abgewiesen ("${(d.text || "").slice(0, 40)}…")`);

  /* GEGENPROBE: Die heile Datei geht durch. Ohne sie hiesse alles
     oben nur, dass gar nichts gelesen wird. */
  ok(versuch(heil).ok, "die heile Datei dagegen wird gelesen");
}

/* =======================================================================
   8. Die Datumsrechnung, an bekannten Punkten festgenagelt
   =======================================================================
   Beim Schreiben dieser Datei habe ich mich selbst vertan: Ich hielt
   46264 fuer den 06.09.2026, es ist der 30.08. Der Code hatte recht,
   meine Erwartung war falsch.

   Damit vor allem der NULLPUNKT nicht unbemerkt verrutscht, stehen hier
   zwei Werte, die jeder nachschlagen kann. Verrutscht die Basis um
   einen Tag, faellt es hier auf und nicht erst in einer Tabelle.
   ======================================================================= */
console.log("");
console.log("=== Die eine Regel fuer den Tag ===");
{
  /* DIE LUECKE, DIE FILIPE GEFUNDEN HAT (14.09.2026).

     Der Zeitraum-Schutz stand am Vormittag nur im Backstage-Weg. Er
     schickte seine echte Datei durch den EINZEL-Import -- dort fehlte
     er, und es entstand eine Zeile mit lauter Nullen auf dem
     1. September. Sichtbar war davon nichts: Der Tag lag 13 Tage
     zurueck, und die Liste zeigt sieben.

     Dieselbe Regel, zweimal aufgeschrieben, und die zweite Abschrift
     war die unvollstaendige -- zum dritten Mal an einem Tag. Jetzt
     steht sie EINMAL in tagAusZelle(), und diese Pruefung haelt fest,
     dass sie beides kann: ablehnen UND durchlassen. */
  const { tagAusZelle } = await import("./workspace-leistung.js");
  const faelle = [
    /* GEDREHT AM NACHMITTAG DES 14.09.2026, nicht geloescht.
       Vormittags wurde ein Zeitraum ueber mehrere Tage ABGELEHNT --
       richtig, denn auf einen Tag geschrieben waeren es elf Tage auf
       einmal gewesen. Filipe: "ich will dass das auch so geht." Jetzt
       kommt er als ZEITRAUM zurueck und wird als solcher abgelegt. */
    ["2026-09-01 ~ 2026-09-11", "ZEITRAUM", null],
    ["2026-09-06 ~ 2026-09-06", "2026-09-06", null],
    ["2026-09-06", "2026-09-06", null],
    ["06.09.2026", "2026-09-06", null],
    ["65", null, "unlesbar"],
    ["", null, "unlesbar"],
  ];
  for (const [text, sollTag, sollFehler] of faelle) {
    const r = tagAusZelle(text);
    if (sollTag === "ZEITRAUM") {
      ok(!!r.zeitraum && !r.tag && !r.fehler,
        `"${text}" kommt als Zeitraum zurueck `
        + `(${r.zeitraum ? r.zeitraum.von + " bis " + r.zeitraum.bis : r.tag || r.fehler})`);
    } else if (sollTag) {
      ok(r.tag === sollTag && !r.fehler && !r.zeitraum,
        `"${text}" wird zum Tag ${sollTag} (${r.tag || r.fehler})`);
    } else {
      ok(!r.tag && typeof r.fehler === "string" && r.fehler.includes(sollFehler),
        `"${text}" wird abgelehnt und begruendet ("${(r.fehler || "").slice(0, 42)}…")`);
    }
  }
  /* DREI AUSGAENGE, NIE ZWEI DAVON GLEICHZEITIG: Tag, Zeitraum oder
     Grund. Gaebe es zwei auf einmal, entschiede jeder Aufrufer selbst,
     was Vorrang hat -- und der zweite entschiede anders als der erste.
     Genau daran ist heute frueh der Zeitraum-Schutz gescheitert. */
  const alle = faelle.map(([t]) => tagAusZelle(t));
  ok(alle.every((r) => [r.tag, r.zeitraum, r.fehler].filter(Boolean).length === 1),
    "sie liefert immer genau EINES von dreien: Tag, Zeitraum oder Grund");
}

console.log("");
console.log("=== Der Nullpunkt der Excel-Zeitrechnung ===");
{
  const alsDatum = (n) => {
    const blatt = '<?xml version="1.0" encoding="UTF-8"?>'
      + '<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">'
      + '<sheetData><row r="1"><c r="A1" s="1"><v>' + n + '</v></c></row></sheetData></worksheet>';
    const styles = '<?xml version="1.0" encoding="UTF-8"?>'
      + '<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">'
      + '<cellXfs count="2"><xf numFmtId="0"/><xf numFmtId="14"/></cellXfs></styleSheet>';
    const mappe = '<?xml version="1.0"?>'
      + '<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" '
      + 'xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">'
      + '<sheets><sheet name="X" sheetId="1" r:id="rId1"/></sheets></workbook>';
    return xlsxLesen(zipBauen([
      ["xl/workbook.xml", mappe],
      ["xl/_rels/workbook.xml.rels", RELS],
      ["xl/styles.xml", styles],
      ["xl/worksheets/sheet1.xml", blatt],
    ])).zeilen[0][0];
  };
  for (const [n, soll] of [[36526, "2000-01-01"], [45292, "2024-01-01"]]) {
    const ist = alsDatum(n);
    ok(ist === soll, `Seriennummer ${n} ist der ${soll} (gelesen: ${ist})`);
  }
  /* DIE EINE STELLE, AN DER ES NICHT STIMMT -- und sie steht hier,
     damit niemand sie fuer einen Fehler haelt: Excel haelt 1900
     faelschlich fuer ein Schaltjahr. Wer den Nullpunkt so legt, dass
     alle Daten ab dem 01.03.1900 stimmen, liegt davor um einen Tag
     daneben. In einer Leistungstabelle kommt kein Datum von 1900 vor. */
  ok(alsDatum(1) === "1899-12-31",
    "vor dem 01.03.1900 liegt die Rechnung um einen Tag daneben (Excels Schaltjahr-Irrtum)");
}

console.log(`\n${geprueft} Pruefungen`);
console.log(fehler === 0 ? "ALLES IN ORDNUNG" : `${fehler} FEHLER`);
process.exit(fehler ? 1 : 0);