DogFatherGitandClaude Opus 5
984f0dd7a9
Filipe: "das muss viel geiler aussehen bitte. ich will dass es auch seeeehr gut erkennbar ist, genau wie der text drueber. mach das bitte alles so dass es mega speziell, hochwertig und lesbar ist." DAS EIGENTLICHE PROBLEM WAR LESBARKEIT, nicht Geschmack. Im Bildschirmfoto gemessen: Ueberschrift und Erklaersatz standen direkt auf der Buehne -- einem Foto mit hellrotem Berg. Und die Karte griff nach `--flaeche-tief`, einer Variablen, die es im ganzen Haus nicht gibt; gegriffen hat der Ersatzwert mit 72 % Deckung, also kam der Berg mit. Eine Variable, die nirgends steht, faellt nicht auf. Jetzt sitzt alles in EINEM Koerper: vierfarbige Fassung, deckendes Innenglas mit Messraster, die Zeitraeume als eingelassene Felder mit dunklen Fugen. Das ist nicht neu erfunden, sondern die Rollenkachel der Anmeldeseite -- ein Haus, eine Handschrift. Typenschild und Hauptzahl in gebuerstetem Metall, mit vollwertigem Rueckfall. "GUELTIGE LIVE-GEHEN-TAGE" WURDE BIS HEUTE WEGGEWORFEN. Datenbank, Anzeigefeld und Importzeile waren da -- nur `spaltenRaten` hatte kein Muster dafuer. Am 14.09. wurde das alte `/tag/` reparirt, das die Spalte faelschlich zur Datumsspalte machte; die Reparatur hat den falschen Empfaenger entfernt und keinen richtigen bestellt. Die Pruefdatei SCHICKTE den Wert seit dem 14.09. und hat nie nachgesehen, ob er ankommt. Jetzt steht er als Streifen da, in genau so viele Kaestchen geteilt, wie der Zeitraum Tage hat. ZWEI KLASSEN IM WAEHLER, mit Grund: `.spannen__schild` allein (0,1,0) kam gegen `.inhalt .feldschild` aus start.css (0,2,0) nicht an -- im Browser gemessen war weder `display: flex` noch die Farbe da. UND EINE ZEITBOMBE ENTSCHAERFT: pruef-backstage-import rechnete "morgen" mit `toISOString()` (UTC), der Server mit Ortszeit. Um 00:40 Berlin war das hier berechnete "morgen" in Wahrheit HEUTE -- die Gegenprobe "ein Datum in der Zukunft wird abgelehnt" fiel taeglich zwischen Mitternacht und zwei Uhr um. Alle drei Tage werden jetzt aus einer Stelle abgeleitet. Gemessen statt behauptet: 43 258 Bildpunkte hinter Ueberschrift und Satz abgetastet, kein einziger rot. Gegenprobe mit weggenommenem Innenglas: 2 857 rote -- die Messung kann Rot also sehen. pruef-backstage-import 133 (war 127), pruef-xlsx 75 (war 67), pruef-css-klassen, pruef-leistung-optik 59, pruef-leistung: alle gruen. Co-Authored-By: Claude Opus 5 <[email protected]>
419 lines
21 KiB
JavaScript
419 lines
21 KiB
JavaScript
/* 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 WO LANDET SIE DANN? (16.09.2026) ----------------------
|
||
Die Gegenprobe oben sagte nur, dass "Gültige LIVE-Gehen-Tage"
|
||
KEINE Datumsspalte ist. Das war richtig -- und unvollständig: Die
|
||
Spalte hatte danach ueberhaupt keinen Empfaenger mehr und lief ins
|
||
Leere. Datenbankspalte, Anzeigefeld und Importzeile waren da, nur
|
||
das Muster fehlte.
|
||
|
||
DAS IST DIE GENAUE SORTE FEHLER, DIE EINE GEGENPROBE ALLEIN NICHT
|
||
FINDET: "trifft das Falsche nicht" ist kein Beweis dafuer, dass es
|
||
das Richtige trifft. Deshalb steht beides jetzt nebeneinander. */
|
||
ok(tabelle[0][zu.gueltige_tage] === "Gültige LIVE-Gehen-Tage",
|
||
`"Gültige LIVE-Gehen-Tage" landet als gueltige_tage (Spalte ${zu.gueltige_tage})`);
|
||
ok(zahlLesen(tabelle[1][zu.gueltige_tage]) === 11,
|
||
`und traegt die Zahl ${zahlLesen(tabelle[1][zu.gueltige_tage])}`);
|
||
for (const [name, soll] of [
|
||
["Gültige LIVE-Gehen-Tage", true], ["Valid go LIVE days", true],
|
||
["Tage seit dem Beitritt", false], ["Livestreams", false],
|
||
["Diamanten", false], ["LIVE-Dauer", false],
|
||
]) {
|
||
const trifft = spaltenRaten([name]).gueltige_tage === 0;
|
||
ok(trifft === soll,
|
||
`"${name}" ${soll ? "ist" : "ist NICHT"} die Spalte der gueltigen Tage (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);
|