Excel-Dateien werden gelesen -- und drei Fallen dahinter entschaerft
Filipe: "mach doch bitte so dass man alle dateien hoch laden könne auch
excel dateien. gib gas und krieg das hin."
server/workspace-xlsx.js liest .xlsx mit Bordmitteln: Eine .xlsx ist ein
ZIP mit XML darin, und Node kann beides (`zlib.inflateRawSync`). Kein
zusaetzliches Paket fuer eine Datei mit neun Zeilen.
GEMESSEN AN ZWEI ECHTEN BACKSTAGE-AUSGABEN vom 11. und 12.09.2026, die
auf dem Rechner lagen -- nicht an der Dokumentation. Sie haben mir an
drei Stellen widersprochen, und JEDE davon waere sonst ein stiller
Fehler geworden:
1. DER ZEITRAUM. In "Datenzeitraum" steht `2026-09-01 ~ 2026-09-11`.
`datumLesen` griff sich davon den ersten Tag -- elf Tage Diamanten
waeren auf den 1. September gebucht worden. Die Zahl steht da, sie
ist gross, sie sieht richtig aus, und niemand kann spaeter sagen,
dass elf Tage darin stecken. Neu: `zeitraumLesen`; eine Zeile mit
einem Zeitraum ueber mehrere Tage wird abgelehnt UND begruendet
("Stell in Backstage den Zeitraum auf EINEN Tag"). Ein Zeitraum von
einem Tag geht durch.
2. DIE EINHEIT. "LIVE-Dauer" enthaelt `86Std. 10Min. 52Sek.`.
`zahlLesen` ergab daraus `null` -- die Dauer fiel weg. Bei einem
anderen Trennzeichen waere es schlimmer gewesen: 86 statt 5171,
Faktor 60 daneben und plausibel. Neu: `dauerLesen`, versteht die
deutsche und englische Schreibweise, die Uhrzeitform und weiterhin
die blosse Zahl.
3. DIE DATUMSSPALTE. `/datum|date|tag|day/i` erklaerte "Tage seit dem
Beitritt" zur Datumsspalte (Wert "65") und traf in der
Leistungstabelle "Gueltige LIVE-Gehen-Tage" genauso. Jetzt nur noch
als ganzes Wort, dafuer mit "zeitraum" -- Backstages Spalte wurde
bisher nur zufaellig gefunden, weil in "Daten" die Silbe "date"
steckt.
Gefunden hat das keine Ueberlegung, sondern der ganze Weg einmal mit
der echten Datei durchlaufen.
WEITER GEBAUT:
- Titelzeilen werden uebersprungen: "Creator:innen verwalten" hat in
Zeile 1 nur "Exportiert am :…", die Ueberschriften stehen darunter.
Die Regel misst (drei gefuellte Felder UND halb so breit wie die
breiteste Zeile), statt eine feste Zahl zu nehmen.
- Fehlende Zellen verschieben nichts: Eine leere Zelle steht in der
Datei gar nicht; wer der Reihe nach liest, verrutscht ab dort jede
Spalte, und die Zeile sieht voll aus.
- Datums-Seriennummern werden nur umgerechnet, wenn das FORMAT es sagt
(sonst stuende 46271 in der Vorschau). Der Nullpunkt ist an zwei
nachschlagbaren Werten festgenagelt.
- Der Backstage-Dialog nimmt die Datei jetzt AUCH -- dort gehoert sie
hin, denn Filipes Ausgabe enthaelt alle Creator auf einmal. Sie fuellt
das Einfuegefeld; ab da laeuft derselbe Weg wie beim Einfuegen. Keine
zweite Fassung derselben Regeln.
- Die alte .xls (BIFF, kein ZIP) wird erkannt und bekommt einen Weg
gezeigt, statt "ging nicht" zu sagen.
NEU: pruef-xlsx.mjs (60) -- baut seine Dateien selbst (ZIP-Schreiber in
helfer-xlsx-bauen.mjs), damit keine Creator-Daten ins Repo wandern und
auch Faelle pruefbar sind, die es als Datei nicht gibt: kaputtes
Verzeichnis, fehlendes Blatt, abgeschnittene Datei. Jeder davon mit
Gegenprobe, dass die heile Datei durchgeht.
pruef-backstage-import 77 -> 82, dabei zwei Pruefungen GEDREHT: Die
.xlsx bekommt keine Absage mehr, sondern eine Vorschau.
DREI EIGENE FEHLER DABEI, alle von einer Messung gefunden:
- Ich hielt Seriennummer 46264 fuer den 06.09.; es ist der 30.08. Der
Code hatte recht. Deshalb stehen jetzt zwei nachschlagbare Anker drin.
- Eine Zeile war gruen, weil mein Muster den SPALTENNAMEN
"Datenzeitraum" traf statt der Begruendung. Jetzt wird auf den Text
der Ablehnung geprueft.
- Beim Umbau habe ich pruef-backstage-import beschaedigt (ein
Suchtreffer weiter oben als gemeint) und aus Git zurueckgeholt.
Co-Authored-By: Claude Opus 5 <[email protected]>
This commit is contained in:
Claude Opus 5
@@ -43,6 +43,7 @@
|
||||
===================================================================== */
|
||||
|
||||
import express from "express";
|
||||
import { xlsxLesen, tabelleAbKopf, alsText } from "./workspace-xlsx.js";
|
||||
import {
|
||||
db, protokolliere, echteIp, sitzungLesen, istLeitung,
|
||||
sichtbareCreatorIds, ROLLEN_SORTIERUNG, heuteLokal,
|
||||
@@ -569,6 +570,102 @@ export function zahlLesen(roh) {
|
||||
return Number.isFinite(n) ? n : null;
|
||||
}
|
||||
|
||||
/** Macht aus "86Std. 10Min. 52Sek." Minuten.
|
||||
*
|
||||
* GEMESSEN AN DER ECHTEN BACKSTAGE-AUSGABE (14.09.2026): Die Spalte
|
||||
* "LIVE-Dauer" enthaelt dort woertlich `86Std. 10Min. 52Sek.` -- ohne
|
||||
* Leerzeichen vor der Einheit. `zahlLesen` machte daraus `null`, weil
|
||||
* "86.10.52." keine Zahl ist. Die Dauer fiel also stillschweigend weg;
|
||||
* der Tag wurde mit Diamanten, aber ohne Minuten geschrieben.
|
||||
*
|
||||
* DIE EINHEIT IST DIE FALLE, nicht die Zahl. Haette `zahlLesen` hier
|
||||
* "86" zurueckgegeben -- was bei einem anderen Trennzeichen leicht
|
||||
* passiert waere --, stuenden 86 Minuten statt 5171 in der Datenbank.
|
||||
* Das sieht richtig aus und ist um Faktor 60 daneben.
|
||||
*
|
||||
* Verstanden werden:
|
||||
* "86Std. 10Min. 52Sek." deutsche Backstage-Ausgabe
|
||||
* "86 Std 10 Min" mit Leerzeichen
|
||||
* "3h 20m", "3 hrs 20 min" englische Fassungen
|
||||
* "86:10:52" / "3:20" Doppelpunktform
|
||||
* "184" blosse Zahl -> Minuten, wie bisher
|
||||
*
|
||||
* OHNE EINHEIT BLEIBT ES EINE ZAHL. Eine blosse "184" als Stunden zu
|
||||
* deuten waere geraten; die bestehenden Exporte liefern dort Minuten,
|
||||
* und dabei bleibt es.
|
||||
*/
|
||||
export function dauerLesen(roh) {
|
||||
const t = String(roh ?? "").trim();
|
||||
if (!t) return null;
|
||||
|
||||
/* Doppelpunktform zuerst: "86:10:52" ist eindeutig und wuerde von der
|
||||
Einheitensuche unten nicht erkannt. Zwei Teile heissen Stunden und
|
||||
Minuten -- so schreibt es jede Uhr. */
|
||||
const uhr = /^(\d+):([0-5]?\d)(?::([0-5]?\d))?$/.exec(t);
|
||||
if (uhr) {
|
||||
const std = Number(uhr[1]);
|
||||
const min = Number(uhr[2]);
|
||||
const sek = uhr[3] === undefined ? 0 : Number(uhr[3]);
|
||||
return Math.round(std * 60 + min + sek / 60);
|
||||
}
|
||||
|
||||
/* Einheiten einsammeln. Der Punkt hinter "Std." gehoert nicht dazu,
|
||||
die Reihenfolge im Text ist egal, und jede Einheit zaehlt nur
|
||||
einmal -- "1 Std 2 Std" ist kein gueltiger Wert und soll nicht
|
||||
stillschweigend zu drei Stunden werden. */
|
||||
const einheiten = [
|
||||
["std", /(\d+(?:[.,]\d+)?)\s*(?:std|stunden|stunde|hrs|hours|hour|h)(?![a-z])/i],
|
||||
["min", /(\d+(?:[.,]\d+)?)\s*(?:min|minuten|minute|mins|m)(?![a-z])/i],
|
||||
["sek", /(\d+(?:[.,]\d+)?)\s*(?:sek|sekunden|sekunde|secs|sec|s)(?![a-z])/i],
|
||||
];
|
||||
let minuten = 0;
|
||||
let gefunden = false;
|
||||
for (const [art, muster] of einheiten) {
|
||||
const m = muster.exec(t);
|
||||
if (!m) continue;
|
||||
const n = Number(String(m[1]).replace(",", "."));
|
||||
if (!Number.isFinite(n)) continue;
|
||||
gefunden = true;
|
||||
if (art === "std") minuten += n * 60;
|
||||
else if (art === "min") minuten += n;
|
||||
else minuten += n / 60;
|
||||
}
|
||||
if (gefunden) return Math.round(minuten);
|
||||
|
||||
/* Keine Einheit erkannt -> wie bisher eine blosse Zahl. */
|
||||
return zahlLesen(t);
|
||||
}
|
||||
|
||||
/** Ist das ein ZEITRAUM statt eines Tages?
|
||||
*
|
||||
* Backstage schreibt in "Datenzeitraum" woertlich
|
||||
* `2026-09-01 ~ 2026-09-11`. `datumLesen` griff sich davon die erste
|
||||
* Haelfte und gab "2026-09-01" zurueck -- elf Tage Diamanten waeren
|
||||
* damit auf den 1. September geschrieben worden. Gemessen am echten
|
||||
* Export vom 12.09.2026, nicht vermutet.
|
||||
*
|
||||
* DAS IST DER TEUERSTE FEHLER, den dieser Weg machen kann: Die Zahl
|
||||
* steht da, sie ist gross, sie sieht richtig aus, und niemand kann
|
||||
* spaeter sagen, dass sie elf Tage enthaelt.
|
||||
*
|
||||
* Rueckgabe: {von, bis} bei einem erkannten Zeitraum, sonst null.
|
||||
* Ein Zeitraum von EINEM Tag (von === bis) ist kein Zeitraum -- dann
|
||||
* ist die Datei genau das, was hier gebraucht wird.
|
||||
*/
|
||||
export function zeitraumLesen(roh) {
|
||||
const t = String(roh ?? "").trim();
|
||||
/* Zwei Datumsangaben, getrennt durch ~, -, bis oder to. Das Muster
|
||||
verlangt ZWEI vollstaendige Daten; ein einzelnes "2026-09-06"
|
||||
faellt nicht darauf herein. */
|
||||
const m = /^(\d{4}-\d{2}-\d{2})[^\d]{1,6}(\d{4}-\d{2}-\d{2})$/.exec(t)
|
||||
|| /^(\d{1,2}\.\d{1,2}\.\d{4})[^\d]{1,6}(\d{1,2}\.\d{1,2}\.\d{4})$/.exec(t);
|
||||
if (!m) return null;
|
||||
const von = datumLesen(m[1]);
|
||||
const bis = datumLesen(m[2]);
|
||||
if (!von || !bis) return null;
|
||||
return { von, bis };
|
||||
}
|
||||
|
||||
/** Macht aus einem Textwert ein Datum "JJJJ-MM-TT".
|
||||
* Erkennt 2026-09-06, 06.09.2026 und 09/06/2026. */
|
||||
export function datumLesen(roh) {
|
||||
@@ -589,7 +686,21 @@ export function datumLesen(roh) {
|
||||
* Nur ein Vorschlag -- bestätigt wird er in der Vorschau. */
|
||||
export function spaltenRaten(kopf) {
|
||||
const muster = {
|
||||
tag: /datum|date|tag|day/i,
|
||||
/* "tag" UND "day" NUR ALS GANZES WORT (14.09.2026).
|
||||
|
||||
Gemessen an der echten Backstage-Mitgliederliste: Dort steht
|
||||
"Tage seit dem Beitritt", und das alte Muster erklaerte diese
|
||||
Spalte zur Datumsspalte -- Wert "65". In der Leistungstabelle
|
||||
daneben trifft es "Gueltige LIVE-Gehen-Tage" genauso.
|
||||
|
||||
Aufgefallen ist es nicht beim Lesen, sondern als ich den ganzen
|
||||
Weg mit der echten Datei durchlaufen liess.
|
||||
|
||||
"zeitraum" kam dazu, weil Backstages Spalte "Datenzeitraum"
|
||||
heisst -- sie wurde bisher nur zufaellig gefunden, weil in
|
||||
"Daten" die englische Silbe "date" steckt. Auf Zufall soll das
|
||||
nicht beruhen. */
|
||||
tag: /datum|date|zeitraum|^\s*tage?\s*$|^\s*day\s*$/i,
|
||||
diamanten: /diamant|diamond/i,
|
||||
dauer_min: /dauer|duration|minut|zeit.*live|live.*zeit/i,
|
||||
zuschauer_avg: /(durchschnitt|avg|average|⌀|ø).*(zuschauer|viewer)|(zuschauer|viewer).*(durchschnitt|avg)/i,
|
||||
@@ -749,7 +860,28 @@ function netzwerkLesen(text, person, tagVorgabe) {
|
||||
const rohWer = String(rohHandle).trim() || String(rohName).trim();
|
||||
if (!rohWer) { schlecht.push({ zeile: i + 1, grund: "Keine Person in der Zeile." }); continue; }
|
||||
|
||||
const tag = ausTabelle ? datumLesen(z[zu.tag]) : tagVorgabe;
|
||||
/* EIN ZEITRAUM IST KEIN TAG (14.09.2026).
|
||||
|
||||
Backstage schreibt in "Datenzeitraum" `2026-09-01 ~ 2026-09-11`.
|
||||
`datumLesen` griff sich davon den ersten Tag -- elf Tage
|
||||
Diamanten waeren auf den 1. September geschrieben worden. Die
|
||||
Zahl steht da, sie ist gross, sie sieht richtig aus, und niemand
|
||||
kann spaeter sagen, dass elf Tage darin stecken.
|
||||
|
||||
Gemessen am echten Export vom 12.09.2026, nicht vermutet.
|
||||
|
||||
Ein Zeitraum von EINEM Tag geht durch -- dann ist die Datei
|
||||
genau das, was hier gebraucht wird. */
|
||||
const zeitraum = ausTabelle ? zeitraumLesen(z[zu.tag]) : null;
|
||||
if (zeitraum && zeitraum.von !== zeitraum.bis) {
|
||||
schlecht.push({ zeile: i + 1,
|
||||
grund: `Zeitraum ${zeitraum.von} bis ${zeitraum.bis} – das sind mehrere Tage `
|
||||
+ "auf einmal. Stell in Backstage den Zeitraum auf EINEN Tag." });
|
||||
continue;
|
||||
}
|
||||
const tag = ausTabelle
|
||||
? (zeitraum ? zeitraum.von : datumLesen(z[zu.tag]))
|
||||
: tagVorgabe;
|
||||
if (!tag) { schlecht.push({ zeile: i + 1, grund: `Datum unlesbar: "${z[zu.tag]}"` }); continue; }
|
||||
if (tag > heuteLokal()) { schlecht.push({ zeile: i + 1, grund: `${tag} liegt in der Zukunft` }); continue; }
|
||||
|
||||
@@ -767,7 +899,11 @@ function netzwerkLesen(text, person, tagVorgabe) {
|
||||
const werte = { creator_id: p.id, name: p.name, tag };
|
||||
let hatZahl = false;
|
||||
for (const feld of messwerte) {
|
||||
const w = zahlLesen(z[zu[feld]]);
|
||||
/* Die Dauer hat eine EINHEIT, die anderen Felder nicht.
|
||||
"86Std. 10Min. 52Sek." ergibt sonst nichts (zahlLesen scheitert
|
||||
an "86.10.52.") -- und bei einem anderen Trennzeichen waere es
|
||||
schlimmer: 86 statt 5171, Faktor 60 daneben und plausibel. */
|
||||
const w = feld === "dauer_min" ? dauerLesen(z[zu[feld]]) : zahlLesen(z[zu[feld]]);
|
||||
werte[feld] = w;
|
||||
if (w !== null && w !== undefined) hatZahl = true;
|
||||
}
|
||||
@@ -868,6 +1004,65 @@ leistungRouter.post("/workspace/api/leistung/netzwerk-import", gleicheHerkunft,
|
||||
}
|
||||
});
|
||||
|
||||
/* =====================================================================
|
||||
EXCEL-DATEIEN (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."
|
||||
|
||||
Die Datei kommt roh herein und geht als TEXT wieder hinaus -- genau
|
||||
in der Form, die auch beim Einfuegen aus dem Browser entsteht
|
||||
(TAB-getrennt). Danach laeuft alles durch dieselbe Zerlegung,
|
||||
dieselbe Vorschau und dieselbe Bestaetigung wie bisher.
|
||||
|
||||
WARUM NICHT GLEICH IMPORTIEREN: Eine Datei, die direkt schreibt,
|
||||
nimmt dem Menschen den Blick auf das, was passieren wird. Die
|
||||
Vorschau ist der ganze Schutz dieses Wegs; sie zu umgehen waere
|
||||
bequem und falsch.
|
||||
|
||||
WER DARF: wer auch eintragen darf. Gelesen wird nichts Fremdes --
|
||||
die Antwort enthaelt nur, was in der hochgeladenen Datei stand.
|
||||
===================================================================== */
|
||||
leistungRouter.post("/workspace/api/leistung/tabelle-lesen",
|
||||
gleicheHerkunft, express.raw({ type: "*/*", limit: "12mb" }), (req, res) => {
|
||||
try {
|
||||
if (!darfEintragen(req.person)) return res.status(403).json({ fehler: "nicht_erlaubt" });
|
||||
if (!Buffer.isBuffer(req.body) || !req.body.length) {
|
||||
return res.status(400).json({ fehler: "Keine Datei empfangen." });
|
||||
}
|
||||
let gelesen;
|
||||
try {
|
||||
gelesen = xlsxLesen(req.body);
|
||||
} catch (fehler) {
|
||||
/* DER DRITTE AUSGANG: nicht "ging nicht", sondern WAS nicht
|
||||
ging. Sonst sucht der Mensch den Fehler bei sich. */
|
||||
if (fehler?.name === "XlsxFehler") {
|
||||
return res.status(415).json({ fehler: fehler.message });
|
||||
}
|
||||
throw fehler;
|
||||
}
|
||||
const t = tabelleAbKopf(gelesen.zeilen);
|
||||
if (!t.zeilen.length) {
|
||||
return res.status(422).json({ fehler: "In der Tabelle steht nichts." });
|
||||
}
|
||||
const text = alsText(t.zeilen);
|
||||
res.json({
|
||||
text,
|
||||
blatt: gelesen.blatt,
|
||||
zeilen: t.zeilen.length,
|
||||
spalten: t.zeilen[0]?.length || 0,
|
||||
/* Wie viele Zeilen oben weggefallen sind. Steht in der Antwort,
|
||||
damit die Oberflaeche es SAGEN kann -- eine Tabelle, die
|
||||
stillschweigend anders anfaengt als die Datei, ist genau die
|
||||
Sorte Hilfsbereitschaft, die spaeter niemand nachvollzieht. */
|
||||
uebersprungen: t.uebersprungen,
|
||||
});
|
||||
} catch (fehler) {
|
||||
console.error("[leistung] Tabelle lesen:", fehler?.message);
|
||||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||||
}
|
||||
});
|
||||
|
||||
/* =====================================================================
|
||||
DER WEG UEBER DIE TIKTOK-DATEI IST ENTFERNT (11.09.2026)
|
||||
|
||||
|
||||
Reference in New Issue
Block a user