DogFatherGitandClaude Opus 5
8fc1ac7a7a
Filipe: "ich will dass alles von der excel datei genommen wird.
perfektionnier das, aber wenn ich dir runter lade soll alles notiert
und angezeigt werden." Dazu eine echte Ausgabe als Vorlage.
DER SCHWERSTE FUND STECKTE VOR DEN DATEN, NICHT IN IHNEN.
Seine Ausgabe "Creator_innendaten" hat DREI Spalten, die nach Person
aussehen: "Creator*in-ID", "Creator*innen-Anmeldename" und "Agent".
`personSpaltenRaten` nahm die erste mit dem Wort "creator" darin --
die ID. Danach wurde nach einem Creator namens "700001" gesucht.
Nachgemessen an seiner echten Kopfzeile: handle = KEINE, name =
"Creator*in-ID". Diese Datei haette KEINE EINZIGE Zeile zugeordnet,
mit einem Hinweis ("steht bei keinem Creator im Feld TikTok"), der in
die voellig falsche Richtung zeigt.
Jetzt ist "Anmeldename" der Handle, eine Kennnummer ist fuer beide
Spalten ausgeschlossen, und "creator" allein reicht nicht mehr als
Namensspalte -- sonst haette weiter hinten "Neue*r LIVE-Creator*innen"
(Wert: "Nein") die Stelle uebernommen. An fuenf Kopfzeilen gemessen.
UND DANN: NICHTS FAELLT MEHR WEG.
41 Spalten in der Datei, acht werden gedeutet. Die restlichen 33 --
letzter Monat, fuenf Prozentwerte, Matches, Multi-Gast-LIVEs, Fanclub,
Graduierungs- und Stufenstatus -- wurden lautlos weggeworfen.
KEINE 33 NEUEN SPALTEN, sondern eine Zeile je Spalte mit dem NAMEN als
Schluessel. Eine abgeschriebene Spaltenliste hat in diesem Haus schon
zweimal Daten gekostet und waere beim naechsten Backstage-Update
falsch. Gegenprobe in der Pruefung: eine erfundene Spalte
("Sternenstaub pro Woche") kommt genauso durch -- es wird also keine
Liste gepflegt, die Datei entscheidet.
An SEINER echten Datei gemessen, ohne sie irgendwo hineinzuschreiben:
40 von 41 Spalten gespeichert (die 41. ist leer), Zeitraum 01.09.-
13.09. erkannt, 32 als Zahl, 8 als Text.
UND EIN MESSFEHLER, DER LEHRREICH IST: Meine erste Pruefung meldete
"zugeklappt ist die Liste 141 px hoch", im Bildschirmfoto war dort
nichts. An einem Miniaturfall nachgemessen: getBoundingClientRect,
offsetHeight, offsetParent und getClientRects liefern bei einem
<details> in BEIDEN Zustaenden identische Werte -- Chromium verbirgt
den Inhalt mit content-visibility:hidden, und das behaelt die letzte
Ausmessung. Nur checkVisibility() kann es unterscheiden. Die Messung
log, nicht die Seite.
pruef-backstage-import 160 (war 133), pruef-xlsx 75,
pruef-leistung-optik 59, pruef-leistung, pruef-css-klassen und
pruef-auskunft (46, DSGVO -- die neue Tabelle ist automatisch dabei,
weil die Auskunft ihre Liste aus PRAGMA foreign_key_list ableitet):
alle gruen.
Co-Authored-By: Claude Opus 5 <[email protected]>
1602 lines
70 KiB
JavaScript
1602 lines
70 KiB
JavaScript
/* =====================================================================
|
||
workspace-leistung.js — die Zahlen über das Geschäft.
|
||
|
||
Der große Befund aus dem Plan vom 31.08.2026: Der Workspace
|
||
organisiert ARBEIT hervorragend -- Aufgaben, Termine, Protokolle,
|
||
Bereiche, Pipeline. Über das GESCHÄFT wusste er nichts. Keine
|
||
Diamanten, keine LIVE-Tage, keine Verweildauer.
|
||
|
||
Damit hing die ganze Betreuung in der Luft:
|
||
* Der Start-Check bewertet, aber misst nicht.
|
||
* Der Report fragt "was hat funktioniert?" -- ohne Beleg.
|
||
* Das 90-Tage-Ziel ist ein Satz, kein Fortschritt.
|
||
* "Creator im Fokus" zeigt überfällige Aufgaben, aber nicht,
|
||
WESSEN ZAHLEN einbrechen.
|
||
|
||
---------------------------------------------------------------------
|
||
DIE DREI REGELN GUTER KENNZAHLEN (Recherche 31.08./06.09.2026)
|
||
|
||
Jede Zahl, die dieses Modul ausliefert, bringt mit:
|
||
|
||
1. VERGLEICH gegen die Vorperiode oder gegen das Ziel
|
||
2. VERLAUF die letzten Wochen als Reihe, damit man Richtung sieht
|
||
3. EINORDNUNG "+23 % gegenüber der Vorwoche" statt nur "1.240"
|
||
|
||
Eine Zahl ohne diese drei ist eine Eitelkeitszahl. Sie sieht nach
|
||
Auskunft aus und ist keine -- man kann nichts entscheiden.
|
||
|
||
---------------------------------------------------------------------
|
||
DIE LEITZAHL IST DIE VERWEILDAUER
|
||
|
||
Neu aus der Recherche vom 06.09.2026: 2026 hängt der Algorithmus
|
||
alles an der Completion Rate. Und sie gehört als BETRIEBSkennzahl
|
||
behandelt, nicht als kreative -- sie soll die nächste Runde steuern,
|
||
nicht die letzte erklären. Deshalb steht sie überall vorn.
|
||
|
||
---------------------------------------------------------------------
|
||
WAS DIESES MODUL NICHT TUT
|
||
|
||
Es holt nichts von TikTok. Es gibt keine offene Agentur-Schnittstelle;
|
||
Fremd-APIs kosten Geld, verstoßen gegen die Nutzungsbedingungen und
|
||
brechen ohne Vorwarnung. Eingelesen wird der OFFIZIELLE Export --
|
||
und von Hand getippt, was fehlt.
|
||
===================================================================== */
|
||
|
||
import express from "express";
|
||
import { xlsxLesen, tabelleAbKopf, alsText } from "./workspace-xlsx.js";
|
||
import {
|
||
db, protokolliere, echteIp, sitzungLesen, istLeitung,
|
||
sichtbareCreatorIds, ROLLEN_SORTIERUNG, heuteLokal,
|
||
} from "./workspace.js";
|
||
|
||
export const leistungRouter = express.Router();
|
||
|
||
const jetzt = () => new Date().toISOString();
|
||
const NOTIZ_MAX = 500;
|
||
|
||
/* ---------- Schranke ---------------------------------------------------- */
|
||
|
||
function angemeldet(req, res, next) {
|
||
const person = sitzungLesen(req);
|
||
if (!person) return res.status(401).json({ fehler: "nicht_angemeldet" });
|
||
req.person = person;
|
||
next();
|
||
}
|
||
|
||
function gleicheHerkunft(req, res, next) {
|
||
const herkunft = req.get("origin");
|
||
if (!herkunft) return next();
|
||
let erlaubt;
|
||
try { erlaubt = new URL(herkunft).host === req.get("host"); } catch { erlaubt = false; }
|
||
if (!erlaubt) return res.status(403).json({ fehler: "fremde_herkunft" });
|
||
next();
|
||
}
|
||
|
||
leistungRouter.use("/workspace/api/leistung", angemeldet);
|
||
|
||
/* ---------- Die Spicy-Sperre von 07.09.2026 ist aufgehoben ----------
|
||
(11.09.2026) Filipe, mit der Zahlen-Kachel im Bild: "jetzt soll jede
|
||
rolle diese kachel sehen. spicy, dogfather, manager, scout und
|
||
creator ... der manager scout dogfather oder spicy koennen
|
||
eintragen."
|
||
|
||
Hier stand bis heute eine Sperre, die Spicy Media mit 404
|
||
abgewiesen hat -- der Rest des Wunsches vom 07.09. ("bei der spicy
|
||
rolle, die zahlen diese kategorie nicht sehen"). Sie sass
|
||
ausdruecklich am Server und nicht in der Oberflaeche, und genau
|
||
deshalb reichte es heute NICHT, Kachel und Tuer zu oeffnen: Die
|
||
Seite lud, das Auswahlfeld blieb leer, und es sah aus wie ein
|
||
Fehler.
|
||
|
||
GEFUNDEN HAT DAS EINE MESSUNG, NICHT DAS LESEN. Ich hatte Kachel
|
||
und Tuer geaendert und haette es dabei belassen; erst die Pruefung
|
||
mit Spicy-Zugang zeigte "0 Creator zur Auswahl" und dahinter das
|
||
404. Drei Schichten mussten zustimmen, und die dritte stand
|
||
woanders als die beiden ersten.
|
||
|
||
NEBENWIRKUNG, ausdruecklich: Damit stehen auch im Dashboard wieder
|
||
Diamanten, LIVE-Tage und Verweildauer je Creator-Karte. Das war der
|
||
zweite Teil der damaligen Entscheidung und faellt mit ihr weg.
|
||
|
||
Was die Zeile NICHT war: eine Rechteregel. Wessen Zahlen Spicy
|
||
Media sieht, entscheidet weiterhin siehtAlles() -- und das sagt
|
||
seit jeher "alle". */
|
||
|
||
/* ---------- Wer darf was ------------------------------------------------ */
|
||
|
||
/** Wessen Zahlen darf ich SEHEN? Dieselbe Regel wie überall sonst --
|
||
* eine eigene Sichtbarkeit für Zahlen wäre eine zweite Wahrheit, und
|
||
* zwei Wahrheiten laufen auseinander. */
|
||
function darfSehen(person, creatorId) {
|
||
const ids = sichtbareCreatorIds(person);
|
||
if (ids === null) return true; // DogFather
|
||
return ids.includes(Number(creatorId));
|
||
}
|
||
|
||
/** Wer darf Zahlen EINTRAGEN? Leitung und Scouts -- nicht der Creator
|
||
* selbst. Nicht aus Misstrauen: Die Zahlen kommen aus dem offiziellen
|
||
* Export, und wer sie selbst tippt, hat den Export nicht. Eine Zahl,
|
||
* die man sich selbst gibt, ist keine Messung. */
|
||
function darfEintragen(person) {
|
||
return istLeitung(person) || person.rolle === "scout";
|
||
}
|
||
|
||
/* ---------- Rechnen ----------------------------------------------------- */
|
||
|
||
const TAG_MS = 86400000;
|
||
|
||
/** Ortszeit-Datum als "JJJJ-MM-TT". Nie toISOString(): Das ist UTC und
|
||
* liegt zwischen Mitternacht und zwei Uhr einen Tag daneben. */
|
||
function tagText(d) {
|
||
const p = (n) => String(n).padStart(2, "0");
|
||
return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())}`;
|
||
}
|
||
const tagVor = (n) => tagText(new Date(Date.now() - n * TAG_MS));
|
||
|
||
/** Summe und Durchschnitt über einen Zeitraum.
|
||
*
|
||
* DURCHSCHNITTE ZÄHLEN NUR TAGE MIT WERT. Ein Tag ohne LIVE ist kein
|
||
* Tag mit 0 Zuschauern -- er ist ein Tag ohne Messung. Wer ihn
|
||
* mitmittelt, redet jede Zahl klein, sobald jemand Urlaub hat. */
|
||
function zeitraum(creatorId, von, bis) {
|
||
const z = db().prepare(`
|
||
SELECT
|
||
COUNT(*) AS tage_erfasst,
|
||
COALESCE(SUM(diamanten), 0) AS diamanten,
|
||
COALESCE(SUM(dauer_min), 0) AS dauer_min,
|
||
COALESCE(SUM(gueltiger_tag), 0) AS gueltige_tage,
|
||
COALESCE(SUM(follower_neu), 0) AS follower_neu,
|
||
COALESCE(SUM(schenker), 0) AS schenker,
|
||
AVG(CASE WHEN zuschauer_avg IS NOT NULL THEN zuschauer_avg END) AS zuschauer_avg,
|
||
MAX(zuschauer_max) AS zuschauer_max,
|
||
AVG(CASE WHEN verweildauer_s IS NOT NULL THEN verweildauer_s END) AS verweildauer_s
|
||
FROM leistung WHERE creator_id = ? AND tag >= ? AND tag <= ?`)
|
||
.get(creatorId, von, bis);
|
||
|
||
return {
|
||
tage_erfasst: z.tage_erfasst,
|
||
diamanten: z.diamanten,
|
||
dauer_min: z.dauer_min,
|
||
gueltige_tage: z.gueltige_tage,
|
||
follower_neu: z.follower_neu,
|
||
schenker: z.schenker,
|
||
zuschauer_avg: z.zuschauer_avg === null ? null : Math.round(z.zuschauer_avg),
|
||
zuschauer_max: z.zuschauer_max,
|
||
verweildauer_s: z.verweildauer_s === null ? null : Math.round(z.verweildauer_s),
|
||
};
|
||
}
|
||
|
||
/** Die Veränderung gegenüber der Vorperiode, in Prozent.
|
||
*
|
||
* VON NULL AUS GIBT ES KEINE PROZENT. 0 → 50 sind nicht "unendlich
|
||
* Prozent besser", sondern schlicht "vorher nichts". Wer hier eine
|
||
* Zahl erzwingt, bekommt Unsinn wie "+∞ %" auf den Bildschirm. */
|
||
function wandel(jetztWert, vorherWert) {
|
||
if (jetztWert === null || vorherWert === null) return null;
|
||
if (!vorherWert) return jetztWert ? { neu: true } : null;
|
||
return { prozent: Math.round(((jetztWert - vorherWert) / vorherWert) * 100) };
|
||
}
|
||
|
||
/** Der Verlauf: eine Zahl je Woche, die letzten N Wochen.
|
||
* Für die kleine Linie neben der Zahl -- ohne Richtung ist ein Wert
|
||
* nur ein Punkt. */
|
||
function verlauf(creatorId, wochen = 8) {
|
||
const reihen = [];
|
||
for (let i = wochen - 1; i >= 0; i--) {
|
||
const bis = tagVor(i * 7);
|
||
const von = tagVor(i * 7 + 6);
|
||
const z = zeitraum(creatorId, von, bis);
|
||
reihen.push({
|
||
von, bis,
|
||
diamanten: z.diamanten,
|
||
gueltige_tage: z.gueltige_tage,
|
||
verweildauer_s: z.verweildauer_s,
|
||
});
|
||
}
|
||
return reihen;
|
||
}
|
||
|
||
/* =====================================================================
|
||
Die Schnittstellen
|
||
===================================================================== */
|
||
|
||
/** Die Zahlen eines Creators: diese Woche, Vorwoche, Ziel, Verlauf. */
|
||
leistungRouter.get("/workspace/api/leistung/:creatorId", (req, res) => {
|
||
try {
|
||
const creatorId = Number(req.params.creatorId);
|
||
if (!Number.isInteger(creatorId)) return res.status(400).json({ fehler: "ungueltig" });
|
||
/* Was man nicht sehen darf, existiert nicht -- 404, nicht 403. */
|
||
if (!darfSehen(req.person, creatorId)) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
|
||
const dieseWoche = zeitraum(creatorId, tagVor(6), tagVor(0));
|
||
const vorwoche = zeitraum(creatorId, tagVor(13), tagVor(7));
|
||
const ziele = db().prepare("SELECT * FROM leistung_ziele WHERE creator_id = ?").get(creatorId);
|
||
|
||
/* JEDE ZAHL MIT VERGLEICH UND EINORDNUNG -- die drei Regeln aus
|
||
der Recherche. Eine nackte Zahl fliegt raus. */
|
||
const mitVergleich = {};
|
||
for (const feld of ["diamanten", "gueltige_tage", "dauer_min", "zuschauer_avg",
|
||
"verweildauer_s", "schenker", "follower_neu"]) {
|
||
mitVergleich[feld] = {
|
||
wert: dieseWoche[feld],
|
||
vorher: vorwoche[feld],
|
||
wandel: wandel(dieseWoche[feld], vorwoche[feld]),
|
||
};
|
||
}
|
||
|
||
/* Das Ziel als Fortschritt, nicht als Satz. */
|
||
const zielstand = ziele ? {
|
||
diamanten: ziele.diamanten_woche
|
||
? { ziel: ziele.diamanten_woche, ist: dieseWoche.diamanten,
|
||
anteil: Math.round((dieseWoche.diamanten / ziele.diamanten_woche) * 100) } : null,
|
||
tage: ziele.tage_woche
|
||
? { ziel: ziele.tage_woche, ist: dieseWoche.gueltige_tage,
|
||
anteil: Math.round((dieseWoche.gueltige_tage / ziele.tage_woche) * 100) } : null,
|
||
verweildauer: ziele.verweildauer_s && dieseWoche.verweildauer_s
|
||
? { ziel: ziele.verweildauer_s, ist: dieseWoche.verweildauer_s,
|
||
anteil: Math.round((dieseWoche.verweildauer_s / ziele.verweildauer_s) * 100) } : null,
|
||
} : null;
|
||
|
||
/* DIE ZEITRAEUME AUS BACKSTAGE (14.09.2026).
|
||
|
||
Sie gehen NICHT in die Wochenzahlen ein -- die bleiben aus Tagen
|
||
gerechnet. Ein Zeitraum ueber 13 Tage in eine Woche zu mischen
|
||
waere eine Summe aus zwei verschiedenen Dingen, und niemand
|
||
koennte hinterher sagen, was darin steckt.
|
||
|
||
Sie stehen deshalb daneben, mit ihrer Spanne davor. Die juengsten
|
||
zuerst; mehr als sechs braucht niemand auf einen Blick. */
|
||
const zeitraeume = db().prepare(`
|
||
SELECT von, bis, tage, diamanten, dauer_min, gueltige_tage,
|
||
zuschauer_avg, zuschauer_max, follower_neu, erfasst
|
||
FROM leistung_zeitraum WHERE creator_id = ?
|
||
ORDER BY bis DESC, von DESC LIMIT 6`).all(creatorId);
|
||
|
||
/* ALLES, WAS IN DER DATEI STAND -- IN EINER EINZIGEN ABFRAGE.
|
||
|
||
Filipe: "wenn ich dir runter lade soll alles notiert und
|
||
angezeigt werden." Notiert allein reicht nicht; was niemand
|
||
sieht, ist so gut wie nicht da.
|
||
|
||
EINE Abfrage fuer alle sechs Zeitraeume statt sechs einzelner --
|
||
dieselbe Regel wie bei den Chat-Reaktionen. Sortiert nach `nr`,
|
||
also in der Reihenfolge der Datei: Backstage gruppiert seine
|
||
Spalten bereits sinnvoll (dieser Zeitraum, letzter Monat,
|
||
Prozente, Matches, Fanclub). Eine eigene Gruppierung waere eine
|
||
erfundene Ordnung, die beim naechsten Backstage-Update falsch
|
||
ist. */
|
||
if (zeitraeume.length) {
|
||
const nach = new Map(zeitraeume.map((z) => [z.von + "|" + z.bis, z]));
|
||
for (const z of zeitraeume) z.felder = [];
|
||
for (const f of db().prepare(`
|
||
SELECT von, bis, nr, name, text, zahl
|
||
FROM leistung_zeitraum_feld WHERE creator_id = ?
|
||
ORDER BY nr`).all(creatorId)) {
|
||
nach.get(f.von + "|" + f.bis)?.felder.push(
|
||
{ nr: f.nr, name: f.name, text: f.text, zahl: f.zahl });
|
||
}
|
||
}
|
||
|
||
res.json({
|
||
zeitraeume,
|
||
creator_id: creatorId,
|
||
woche: mitVergleich,
|
||
roh: { woche: dieseWoche, vorwoche },
|
||
ziele: zielstand,
|
||
verlauf: verlauf(creatorId),
|
||
/* Wie vollständig ist die Woche überhaupt? Eine Zahl aus zwei von
|
||
sieben Tagen ist etwas anderes als eine aus sieben. Ohne das
|
||
hält man eine halbe Woche für einen Einbruch. */
|
||
erfassung: { tage: dieseWoche.tage_erfasst, von: 7 },
|
||
});
|
||
} catch (fehler) {
|
||
console.error("[leistung] Lesen:", fehler?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/** Die Tageszeilen eines Creators -- für die Schnelleingabe. */
|
||
leistungRouter.get("/workspace/api/leistung/:creatorId/tage", (req, res) => {
|
||
try {
|
||
const creatorId = Number(req.params.creatorId);
|
||
if (!Number.isInteger(creatorId)) return res.status(400).json({ fehler: "ungueltig" });
|
||
if (!darfSehen(req.person, creatorId)) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
|
||
const tage = Math.min(Math.max(Number(req.query.tage) || 14, 1), 120);
|
||
const reihen = db().prepare(`
|
||
SELECT * FROM leistung WHERE creator_id = ? AND tag >= ?
|
||
ORDER BY tag DESC`).all(creatorId, tagVor(tage - 1));
|
||
res.json({ tage: reihen });
|
||
} catch (fehler) {
|
||
console.error("[leistung] Tage:", fehler?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/* ZIELE STEHEN VOR DER TAGES-ROUTE -- und das ist kein Stilfrage.
|
||
|
||
Express nimmt die ERSTE Route, die passt. `:tag` passt auf jeden
|
||
Text, also auch auf "ziele": Ein PUT auf .../ziele landete in der
|
||
Tages-Route, scheiterte dort am Datumsmuster und gab 400 zurueck.
|
||
Die Ziele liessen sich nicht setzen, und die Meldung sagte
|
||
"ungueltig" -- was auf die Zahlen im Koerper hindeutet, nicht auf
|
||
den Weg.
|
||
|
||
Gefunden von pruef-leistung ("600 von 1200 Diamanten = undefined %").
|
||
Ohne die Pruefung waere es erst aufgefallen, wenn jemand ein Ziel
|
||
setzen wollte. */
|
||
/** Ziele setzen. */
|
||
leistungRouter.put("/workspace/api/leistung/:creatorId/ziele", gleicheHerkunft,
|
||
express.json({ limit: "4kb" }), (req, res) => {
|
||
try {
|
||
const creatorId = Number(req.params.creatorId);
|
||
if (!Number.isInteger(creatorId)) return res.status(400).json({ fehler: "ungueltig" });
|
||
if (!darfEintragen(req.person)) return res.status(403).json({ fehler: "nicht_erlaubt" });
|
||
if (!darfSehen(req.person, creatorId)) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
|
||
const z = (n) => {
|
||
const w = Number(req.body?.[n]);
|
||
return Number.isFinite(w) && w > 0 ? Math.round(w) : null;
|
||
};
|
||
db().prepare(`
|
||
INSERT INTO leistung_ziele (creator_id, diamanten_woche, tage_woche, verweildauer_s, gesetzt, gesetzt_von)
|
||
VALUES (?,?,?,?,?,?)
|
||
ON CONFLICT(creator_id) DO UPDATE SET
|
||
diamanten_woche = excluded.diamanten_woche,
|
||
tage_woche = excluded.tage_woche,
|
||
verweildauer_s = excluded.verweildauer_s,
|
||
gesetzt = excluded.gesetzt, gesetzt_von = excluded.gesetzt_von`)
|
||
.run(creatorId, z("diamanten_woche"), z("tage_woche"), z("verweildauer_s"),
|
||
jetzt(), req.person.id);
|
||
res.json({ ok: true });
|
||
} catch (fehler) {
|
||
console.error("[leistung] Ziele:", fehler?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
|
||
/** Einen Tag eintragen oder ändern.
|
||
*
|
||
* INSERT OR REPLACE auf (creator_id, tag): Derselbe Tag zweimal
|
||
* eingetragen überschreibt, statt zu verdoppeln. Verdoppelte Zahlen
|
||
* sind schlimmer als fehlende -- sie sehen richtig aus. */
|
||
leistungRouter.put("/workspace/api/leistung/:creatorId/:tag", gleicheHerkunft,
|
||
express.json({ limit: "8kb" }), (req, res) => {
|
||
try {
|
||
const creatorId = Number(req.params.creatorId);
|
||
const tag = String(req.params.tag);
|
||
if (!Number.isInteger(creatorId) || !/^\d{4}-\d{2}-\d{2}$/.test(tag)) {
|
||
return res.status(400).json({ fehler: "ungueltig" });
|
||
}
|
||
if (!darfEintragen(req.person)) {
|
||
return res.status(403).json({ fehler: "Zahlen tragen DogFather, Manager und Scouts ein." });
|
||
}
|
||
if (!darfSehen(req.person, creatorId)) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
|
||
/* KEINE ZAHLEN AUS DER ZUKUNFT. Ein Tippfehler im Jahr (2027
|
||
statt 2026) legt sonst eine Zeile an, die nie wieder auffällt
|
||
-- sie taucht in keiner Auswertung auf, weil alle nur
|
||
zurückschauen. */
|
||
if (tag > tagVor(0)) {
|
||
return res.status(400).json({ fehler: "Für einen Tag in der Zukunft gibt es noch keine Zahlen." });
|
||
}
|
||
|
||
const z = (name) => {
|
||
const w = req.body?.[name];
|
||
if (w === null || w === undefined || w === "") return null;
|
||
const n = Number(w);
|
||
/* Negative Werte gibt es hier nicht -- weder negative Diamanten
|
||
noch negative Minuten. Ein Minus ist immer ein Tippfehler. */
|
||
return Number.isFinite(n) && n >= 0 ? Math.round(n) : null;
|
||
};
|
||
|
||
const notiz = String(req.body?.notiz ?? "").trim().slice(0, NOTIZ_MAX) || null;
|
||
|
||
db().prepare(`
|
||
INSERT OR REPLACE INTO leistung
|
||
(creator_id, tag, diamanten, dauer_min, gueltiger_tag, zuschauer_avg,
|
||
zuschauer_max, verweildauer_s, schenker, follower_neu, notiz,
|
||
erfasst, erfasst_von, quelle)
|
||
VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(
|
||
creatorId, tag, z("diamanten"), z("dauer_min"),
|
||
req.body?.gueltiger_tag ? 1 : 0,
|
||
z("zuschauer_avg"), z("zuschauer_max"), z("verweildauer_s"),
|
||
z("schenker"), z("follower_neu"), notiz,
|
||
jetzt(), req.person.id, "hand");
|
||
|
||
protokolliere("leistung_erfasst", {
|
||
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
|
||
detail: `Creator #${creatorId} ${tag}`,
|
||
});
|
||
res.json({ ok: true });
|
||
} catch (fehler) {
|
||
console.error("[leistung] Eintragen:", fehler?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/** Einen Tag löschen -- für den Fall, dass eine Zeile falsch angelegt
|
||
* wurde. Kein "weg_am" wie beim Chat: Eine Messung, die es nicht gab,
|
||
* soll auch nicht als leere Zeile herumstehen und Durchschnitte
|
||
* verwässern. */
|
||
leistungRouter.delete("/workspace/api/leistung/:creatorId/:tag", gleicheHerkunft, (req, res) => {
|
||
try {
|
||
const creatorId = Number(req.params.creatorId);
|
||
const tag = String(req.params.tag);
|
||
if (!Number.isInteger(creatorId) || !/^\d{4}-\d{2}-\d{2}$/.test(tag)) {
|
||
return res.status(400).json({ fehler: "ungueltig" });
|
||
}
|
||
if (!darfEintragen(req.person)) return res.status(403).json({ fehler: "nicht_erlaubt" });
|
||
if (!darfSehen(req.person, creatorId)) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
|
||
const e = db().prepare("DELETE FROM leistung WHERE creator_id = ? AND tag = ?")
|
||
.run(creatorId, tag);
|
||
protokolliere("leistung_geloescht", {
|
||
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
|
||
detail: `Creator #${creatorId} ${tag}`,
|
||
});
|
||
res.json({ ok: true, entfernt: Number(e.changes) });
|
||
} catch (fehler) {
|
||
console.error("[leistung] Löschen:", fehler?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/** Überblick über ALLE sichtbaren Creator -- für das Dashboard.
|
||
* Eine Abfrage statt einer je Creator. */
|
||
leistungRouter.get("/workspace/api/leistung", (req, res) => {
|
||
try {
|
||
/* DURCH DIE AUGEN DER ANGESEHENEN PERSON (11.09.2026).
|
||
|
||
Filipe: "oben bei meine sicht soll ich auch die sicht von allen
|
||
jeden moment sehen koennen und das genau genau so wie sie es
|
||
sehen alles."
|
||
|
||
Nur LESEN wird umgestellt, nie ein Recht: `req.person` bleibt
|
||
ueberall dort stehen, wo geschrieben oder geprueft wird. Und
|
||
weil DogFather ohnehin alles sehen darf, kann diese Umstellung
|
||
nichts oeffnen -- sie kann nur WENIGER zeigen, naemlich genau
|
||
das, was die andere Person sieht.
|
||
Gemessen: In der Sicht auf einen Modi kamen hier DogFathers
|
||
eigene Creator zurueck -- 131 Zeichen statt 14. */
|
||
const zeigt = req.sicht || req.person;
|
||
const ids = sichtbareCreatorIds(zeigt);
|
||
const wo = ids === null ? "rolle = 'creator' AND aktiv = 1"
|
||
: ids.length ? `id IN (${ids.map(() => "?").join(",")}) AND aktiv = 1`
|
||
: "0=1";
|
||
const creator = db().prepare(
|
||
`SELECT id, name FROM personen WHERE ${wo} ORDER BY name`)
|
||
.all(...(ids === null ? [] : ids));
|
||
|
||
res.json({
|
||
creator: creator.map((c) => {
|
||
const w = zeitraum(c.id, tagVor(6), tagVor(0));
|
||
const v = zeitraum(c.id, tagVor(13), tagVor(7));
|
||
return {
|
||
id: c.id, name: c.name,
|
||
diamanten: w.diamanten,
|
||
gueltige_tage: w.gueltige_tage,
|
||
verweildauer_s: w.verweildauer_s,
|
||
wandel_diamanten: wandel(w.diamanten, v.diamanten),
|
||
tage_erfasst: w.tage_erfasst,
|
||
};
|
||
}),
|
||
});
|
||
} catch (fehler) {
|
||
console.error("[leistung] Überblick:", fehler?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/* =====================================================================
|
||
CSV-Import aus dem offiziellen Export
|
||
=====================================================================
|
||
|
||
ZWEIMAL EINLESEN DARF KEINEN SCHADEN ANRICHTEN. Das ist der
|
||
häufigste Fehler bei Importen und der Grund für den
|
||
Primärschlüssel (creator_id, tag): Dieselbe Datei ein zweites Mal
|
||
überschreibt, statt zu verdoppeln.
|
||
|
||
VORSCHAU VOR DEM ÜBERNEHMEN: Erst zeigen, was passieren wird, dann
|
||
machen. Ein Import, der sofort schreibt, ist bei einer falsch
|
||
zugeordneten Spalte nicht mehr zurückzuholen. */
|
||
|
||
/** Zerlegt CSV -- auch mit Anführungszeichen und Semikolon.
|
||
*
|
||
* Kein fremdes Paket: Die Formate, die hier vorkommen, sind
|
||
* überschaubar, und eine Abhängigkeit für dreißig Zeilen wäre in
|
||
* einem Haus mit drei Abhängigkeiten die vierte. */
|
||
export function csvZerlegen(text) {
|
||
const zeilen = [];
|
||
let feld = "";
|
||
let zeile = [];
|
||
let inAnfuehrung = false;
|
||
const roh = String(text).replace(/^/, ""); // BOM weg
|
||
|
||
/* Trennzeichen erkennen: Deutsche Exporte nutzen oft Semikolon,
|
||
englische Komma. Geraten wird an der ERSTEN Zeile -- dort, wo die
|
||
Überschriften stehen.
|
||
|
||
TABULATOR SEIT DEM 11.09.2026, und er ist hier der wichtigste Fall.
|
||
Wer eine Tabelle im Browser markiert und kopiert -- genau das ist
|
||
der Weg aus TikTok LIVE Backstage, das keinen Export hat --, hat
|
||
TAB-getrennte Spalten in der Zwischenablage, nicht Komma oder
|
||
Semikolon. Ohne diese Zeile landete die ganze Zeile in der ersten
|
||
Spalte, und die Vorschau haette gemeldet "keine Datumsspalte" --
|
||
eine richtige Meldung auf eine falsche Fährte.
|
||
|
||
Gewählt wird das HÄUFIGSTE der drei, nicht das erste gefundene:
|
||
In "Nickname,ID\tDiamanten" kommen zwei davon vor, und nur die
|
||
Anzahl sagt, welches die Spalten trennt. */
|
||
const kopf = roh.split(/\r?\n/)[0] || "";
|
||
const zaehl = (z) => (kopf.split(z).length - 1);
|
||
const trenner = [["\t", zaehl("\t")], [";", zaehl(";")], [",", zaehl(",")]]
|
||
.sort((a, b) => b[1] - a[1])[0][1] > 0
|
||
? [["\t", zaehl("\t")], [";", zaehl(";")], [",", zaehl(",")]]
|
||
.sort((a, b) => b[1] - a[1])[0][0]
|
||
: ",";
|
||
|
||
for (let i = 0; i < roh.length; i++) {
|
||
const z = roh[i];
|
||
if (inAnfuehrung) {
|
||
if (z === '"' && roh[i + 1] === '"') { feld += '"'; i++; }
|
||
else if (z === '"') inAnfuehrung = false;
|
||
else feld += z;
|
||
} else if (z === '"') inAnfuehrung = true;
|
||
else if (z === trenner) { zeile.push(feld); feld = ""; }
|
||
else if (z === "\n") { zeile.push(feld); zeilen.push(zeile); zeile = []; feld = ""; }
|
||
else if (z !== "\r") feld += z;
|
||
}
|
||
if (feld !== "" || zeile.length) { zeile.push(feld); zeilen.push(zeile); }
|
||
return zeilen.filter((z) => z.some((f) => String(f).trim() !== ""));
|
||
}
|
||
|
||
/** Macht aus einem Textwert eine Zahl.
|
||
*
|
||
* Deutsche Exporte schreiben "1.234,5", englische "1,234.5". Beide
|
||
* müssen gehen -- und "1.234" darf nicht als 1,234 gelesen werden.
|
||
* Regel: Das LETZTE Trennzeichen entscheidet, ob es ein Komma-
|
||
* oder Punktformat ist. */
|
||
export function zahlLesen(roh) {
|
||
const t = String(roh ?? "").trim();
|
||
if (!t) return null;
|
||
const nurZiffern = t.replace(/[^\d.,-]/g, "");
|
||
if (!nurZiffern) return null;
|
||
|
||
const letztesKomma = nurZiffern.lastIndexOf(",");
|
||
const letzterPunkt = nurZiffern.lastIndexOf(".");
|
||
let sauber;
|
||
|
||
if (letztesKomma >= 0 && letzterPunkt >= 0) {
|
||
/* BEIDE kommen vor -- dann ist das LETZTE das Dezimalzeichen und
|
||
das andere der Tausendertrenner. "1.234,5" und "1,234.5" sind
|
||
damit eindeutig. */
|
||
sauber = letztesKomma > letzterPunkt
|
||
? nurZiffern.replace(/\./g, "").replace(",", ".")
|
||
: nurZiffern.replace(/,/g, "");
|
||
} else if (letztesKomma >= 0 || letzterPunkt >= 0) {
|
||
/* NUR EINES kommt vor -- und das ist die Falle.
|
||
"1.250" ist deutsch Tausend-zweihundertfünfzig, englisch aber
|
||
eins-komma-zwofünfnull. "1,234" genauso, nur andersherum. Die
|
||
Regel "das letzte Trennzeichen ist das Dezimalzeichen" liefert
|
||
hier für BEIDE Fälle das Falsche: Sie las "1.250" als 1,25 und
|
||
"1,234" als 1,234 -- Faktor tausend daneben, und die Zahl sieht
|
||
trotzdem plausibel aus.
|
||
|
||
Entscheidend ist stattdessen, WIE VIELE Ziffern dahinter
|
||
stehen: Genau drei heißt Tausendertrenner (so gruppiert man
|
||
überall), alles andere heißt Dezimalstelle.
|
||
|
||
"1.250" -> 3 Ziffern -> 1250
|
||
"1,234" -> 3 Ziffern -> 1234
|
||
"210,5" -> 1 Ziffer -> 210.5
|
||
"12.75" -> 2 Ziffern -> 12.75
|
||
|
||
Bleibt EIN unauflösbarer Fall: "1.500" könnte auch eins Komma
|
||
fünf sein. Bei Diamanten, Minuten und Zuschauern ist die
|
||
Tausenderdeutung die richtige -- Nachkommastellen kommen dort
|
||
nicht vor. Deshalb wird hier so entschieden und nicht anders. */
|
||
const trenner = letztesKomma >= 0 ? "," : ".";
|
||
const stelle = letztesKomma >= 0 ? letztesKomma : letzterPunkt;
|
||
const dahinter = nurZiffern.length - stelle - 1;
|
||
sauber = dahinter === 3
|
||
? nurZiffern.split(trenner).join("")
|
||
: nurZiffern.replace(trenner, ".");
|
||
} else {
|
||
sauber = nurZiffern;
|
||
}
|
||
|
||
const n = Number(sauber);
|
||
return Number.isFinite(n) ? n : null;
|
||
}
|
||
|
||
/* =====================================================================
|
||
ALLES, WAS IN DER ZEILE STAND (16.09.2026)
|
||
|
||
Filipe: "ich will dass alles von der excel datei genommen wird ...
|
||
wenn ich dir runter lade soll alles notiert und angezeigt werden."
|
||
|
||
Seine echte Ausgabe hat 41 Spalten; `spaltenRaten` kennt acht davon.
|
||
Die restlichen 33 fielen beim Einlesen weg -- lautlos, ohne dass
|
||
irgendwo stand, dass es sie gab: Zahlen vom letzten Monat, fuenf
|
||
Prozentwerte, Matches, Multi-Gast-LIVEs, Fanclub, Graduierungs- und
|
||
Stufenstatus.
|
||
|
||
DIESE FUNKTION DEUTET NICHTS. Sie nimmt Ueberschrift und Zelle,
|
||
so wie sie dastehen. Das ist Absicht: Was "Diamanten - Prozent
|
||
erreicht" genau bedeutet, weiss TikTok, nicht ich -- und eine
|
||
erfundene Bedeutung waere schlimmer als gar keine. Nachgerechnet
|
||
habe ich es trotzdem einmal (13.210 / 29.488 = 44,79 %, und dasselbe
|
||
Verhaeltnis stimmt bei allen fuenf Groessen), aber eine Herleitung
|
||
aus EINER Zeile ist kein Beweis, und sie steht deshalb nicht im Code.
|
||
|
||
WAS UEBERSPRUNGEN WIRD, und warum genau das:
|
||
* Spalten OHNE Ueberschrift -- ohne Namen gibt es keinen
|
||
Schluessel, und "Spalte 37" ist keine Auskunft.
|
||
* DOPPELTE Ueberschriften -- die erste gilt. Der Schluessel in der
|
||
Datenbank ist der Name; zwei gleiche wuerden einander
|
||
ueberschreiben, und dann haenge es von der Reihenfolge ab, welche
|
||
gewinnt.
|
||
* LEERE Zellen -- eine leere Zelle ist kein Wert. In Filipes Datei
|
||
ist "Status" leer; eine Zeile "Status: (nichts)" waere eine
|
||
Auskunft, die die Datei gar nicht gibt.
|
||
|
||
BEIDES WIRD BEHALTEN: der Text woertlich und, falls lesbar, die
|
||
Zahl. Nur die Zahl hiesse "Nicht graduiert" wegzuwerfen; nur den
|
||
Text hiesse, nicht rechnen zu koennen. */
|
||
export function felderAus(kopf, zeile) {
|
||
const felder = [];
|
||
const gesehen = new Set();
|
||
for (let i = 0; i < kopf.length; i++) {
|
||
const name = String(kopf[i] ?? "").trim();
|
||
if (!name || gesehen.has(name)) continue;
|
||
gesehen.add(name);
|
||
const text = String(zeile[i] ?? "").trim();
|
||
if (!text) continue;
|
||
felder.push({
|
||
nr: i,
|
||
name: name.slice(0, 120),
|
||
text: text.slice(0, 300),
|
||
zahl: zahlLesen(text),
|
||
});
|
||
}
|
||
return felder;
|
||
}
|
||
|
||
/** 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 };
|
||
}
|
||
|
||
/** Der Tag aus einer Zelle -- MIT dem Zeitraum-Schutz.
|
||
*
|
||
* (14.09.2026, nachgetragen.) Den Schutz gab es seit heute frueh nur
|
||
* im Backstage-Weg. Filipe hat daraufhin seine echte Datei durch den
|
||
* EINZEL-Import geschickt, und genau das ist passiert, wovor der
|
||
* Schutz bewahren sollte: eine Zeile auf den 1. September, aus einem
|
||
* Zeitraum vom 1. bis 11.
|
||
*
|
||
* Dass es an zwei Stellen stand und an einer fehlte, ist derselbe
|
||
* Fehler wie an diesem Tag schon zweimal: eine Regel, zweimal
|
||
* aufgeschrieben, und die zweite Abschrift ist die unvollstaendige.
|
||
* Deshalb steht sie jetzt EINMAL hier und wird dreimal benutzt.
|
||
*
|
||
* Rueckgabe: { tag } oder { fehler } -- nie beides, nie keines.
|
||
*/
|
||
export function tagAusZelle(roh) {
|
||
const zeitraum = zeitraumLesen(roh);
|
||
if (zeitraum && zeitraum.von !== zeitraum.bis) {
|
||
/* MEHRERE TAGE SIND KEIN FEHLER MEHR (14.09.2026, zweite Fassung).
|
||
|
||
Am Vormittag wurde so eine Zeile abgewiesen -- richtig, denn auf
|
||
einen Tag geschrieben waeren es 13 Tage auf einmal gewesen.
|
||
Filipe: "ich will dass das auch so geht ... sieh zu dass die
|
||
excel auch so durch geht."
|
||
|
||
Also geht sie durch -- aber als das, was sie ist. Der Aufrufer
|
||
bekommt `zeitraum` statt `tag` und legt sie in
|
||
leistung_zeitraum ab. Wer nur `tag` liest, bekommt weiterhin
|
||
nichts und schreibt damit auch nichts Falsches. */
|
||
return { zeitraum };
|
||
}
|
||
const tag = zeitraum ? zeitraum.von : datumLesen(roh);
|
||
if (!tag) return { fehler: `Datum unlesbar: "${String(roh ?? "").slice(0, 40)}"` };
|
||
return { tag };
|
||
}
|
||
|
||
/** Wie viele Tage liegen in einem Zeitraum? Beide Enden zaehlen mit --
|
||
* vom 1. bis zum 1. ist EIN Tag, nicht null. */
|
||
export function tageImZeitraum(von, bis) {
|
||
const a = Date.parse(`${von}T00:00:00Z`);
|
||
const b = Date.parse(`${bis}T00:00:00Z`);
|
||
if (!Number.isFinite(a) || !Number.isFinite(b) || b < a) return 0;
|
||
return Math.round((b - a) / 86400000) + 1;
|
||
}
|
||
|
||
/** Macht aus einem Textwert ein Datum "JJJJ-MM-TT".
|
||
* Erkennt 2026-09-06, 06.09.2026 und 09/06/2026. */
|
||
export function datumLesen(roh) {
|
||
const t = String(roh ?? "").trim();
|
||
let m;
|
||
if ((m = /^(\d{4})-(\d{2})-(\d{2})/.exec(t))) return `${m[1]}-${m[2]}-${m[3]}`;
|
||
if ((m = /^(\d{1,2})\.(\d{1,2})\.(\d{4})/.exec(t))) {
|
||
return `${m[3]}-${String(m[2]).padStart(2, "0")}-${String(m[1]).padStart(2, "0")}`;
|
||
}
|
||
if ((m = /^(\d{1,2})\/(\d{1,2})\/(\d{4})/.exec(t))) {
|
||
/* Amerikanisch: Monat zuerst. */
|
||
return `${m[3]}-${String(m[1]).padStart(2, "0")}-${String(m[2]).padStart(2, "0")}`;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
/** Rät die Spaltenzuordnung aus den Überschriften.
|
||
* Nur ein Vorschlag -- bestätigt wird er in der Vorschau. */
|
||
export function spaltenRaten(kopf) {
|
||
const muster = {
|
||
/* "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,
|
||
/* "Gültige LIVE-Gehen-Tage" (16.09.2026).
|
||
|
||
DIESE SPALTE STEHT IN JEDER BACKSTAGE-AUSGABE UND WURDE BIS
|
||
HEUTE WEGGEWORFEN. Die Datenbank hat die Spalte, die Anzeige hat
|
||
das Feld, der Import hat die Zeile -- nur hier fehlte das
|
||
Muster, und damit blieb `gueltige_tage` auf dem ganzen Weg leer.
|
||
Aufgefallen ist es nicht beim Lesen des Codes, sondern beim
|
||
Nachsehen, warum "Gültige Tage" auf der Karte nie erschien.
|
||
|
||
WARUM ES VORHER NICHT AUFFIEL: Bis zum 14.09. hat das Muster
|
||
`tag: /.../` mit einem blossen `/tag/` genau diese Spalte
|
||
gefressen und als DATUMSSPALTE verbucht (Wert: "11"). Als das
|
||
repariert wurde, fiel die Spalte durchs Raster -- die Reparatur
|
||
hat den falschen Empfänger entfernt, aber keinen richtigen
|
||
bestellt.
|
||
|
||
Es trifft die deutsche und die englische Schreibweise. Kein
|
||
anderes Muster oben oder unten greift daneben: "dauer_min"
|
||
verlangt `live` ZUSAMMEN mit `zeit`, und `tag` nur ganze
|
||
Wörter. */
|
||
gueltige_tage: /g(?:ü|ue)ltig.*tag|valid.*day|live.*geh|go.*live.*day/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,
|
||
zuschauer_max: /(spitze|peak|max).*(zuschauer|viewer)|(zuschauer|viewer).*(spitze|peak|max)/i,
|
||
verweildauer_s: /verweil|watch.*time|retention|zuschauzeit/i,
|
||
schenker: /schenker|gifter|sender/i,
|
||
follower_neu: /follower|abonnent/i,
|
||
};
|
||
const zu = {};
|
||
kopf.forEach((name, i) => {
|
||
for (const [feld, m] of Object.entries(muster)) {
|
||
if (zu[feld] === undefined && m.test(String(name))) zu[feld] = i;
|
||
}
|
||
});
|
||
return zu;
|
||
}
|
||
|
||
/* =====================================================================
|
||
DER NETZWERK-IMPORT — eine Tabelle, alle Creator auf einmal
|
||
(11.09.2026)
|
||
|
||
Filipe: "wie sehr wir diese seite hier mit dem backstage verbinden
|
||
könnten von tiktok. ohne probleme und ganz schnell."
|
||
|
||
Die Recherche vom 10.09. hat ergeben: TikTok LIVE Backstage hat
|
||
KEINE Schnittstelle und KEINEN Export -- weder die offizielle Seite
|
||
noch ein Agenturleitfaden nennen einen, und in den offiziellen
|
||
TikTok-Scopes gibt es nichts zu LIVE, Diamanten oder Netzwerkdaten.
|
||
Was es gibt, ist eine Tabelle im Browser, die man markieren kann.
|
||
|
||
ALSO IST DER SCHNELLSTE EHRLICHE WEG: markieren, kopieren, einfügen.
|
||
Kein Zugangsdatum, kein Token, keine Erweiterung, die Backstages
|
||
interne Abfragen mitliest -- letzteres wäre ein Verstoß gegen die
|
||
Nutzungsbedingungen und riskiert ausgerechnet das Netzwerkkonto, an
|
||
dem die Einnahmen hängen.
|
||
|
||
WAS ES VOM VORHANDENEN IMPORT UNTERSCHEIDET: Der bestehende Weg
|
||
(/leistung/:creatorId/import) nimmt eine Datei FÜR EINEN Creator.
|
||
Backstage zeigt aber ALLE auf einmal. Der Unterschied ist genau eine
|
||
Frage: Zu wem gehört diese Zeile?
|
||
|
||
DIE ANTWORT KOMMT AUS `personen.tiktok` -- dem öffentlichen Namen
|
||
ohne @, den es im Steckbrief längst gibt. Gesucht wird ohne @, ohne
|
||
Groß-/Kleinschreibung und ohne Leerzeichen; fällt das aus, wird der
|
||
ANGEZEIGTE Name verglichen. Beides ergebnislos -> die Zeile wird
|
||
gemeldet, nicht geraten. Eine falsch zugeordnete Zahl ist schlimmer
|
||
als eine fehlende: Die fehlende sieht man.
|
||
===================================================================== */
|
||
|
||
/** Wer darf eine GANZE Tabelle einspielen?
|
||
*
|
||
* Nur die Leitung -- enger als `darfEintragen`, das auch Scouts
|
||
* einschliesst. Ein Scout traegt Zahlen fuer die Creator ein, die ihm
|
||
* zugeteilt sind; dieser Weg schreibt dagegen fuer ALLE auf einmal,
|
||
* und das ist eine Handlung der Leitung.
|
||
*
|
||
* GEMESSEN, NICHT AUSGEDACHT: Der erste Entwurf nahm `darfEintragen`,
|
||
* und die Pruefung meldete fuer einen Scout HTTP 400 statt 403 -- er
|
||
* kam durch die Rechtepruefung und scheiterte erst daran, dass er
|
||
* keinen der Creator sehen darf. Das ist die richtige Antwort aus dem
|
||
* falschen Grund, und der Knopf auf der Seite war ohnehin schon der
|
||
* Leitung vorbehalten. Jetzt sagen beide dasselbe. */
|
||
function netzDarf(person) {
|
||
return istLeitung(person);
|
||
}
|
||
|
||
/** Aus "@Nova_Live " wird "nova_live" -- damit sich zwei Schreibweisen
|
||
* derselben Person auch dann treffen, wenn eine davon kopiert wurde. */
|
||
function handleSchluessel(roh) {
|
||
return String(roh ?? "").trim().toLowerCase()
|
||
.replace(/^@+/, "")
|
||
/* Unsichtbare Zeichen aus der Zwischenablage: geschütztes
|
||
Leerzeichen und die Richtungsmarken, die TikTok um Namen setzt.
|
||
Sie sind nicht zu sehen und verhindern jeden Treffer. */
|
||
.replace(/[- ]/g, "")
|
||
.replace(/\s+/g, "");
|
||
}
|
||
|
||
/** Welche Spalten nennen die Person -- Handle UND Name.
|
||
*
|
||
* BEIDE, nicht eine (11.09.2026). Der erste Entwurf nahm die erste
|
||
* passende Spalte: das Handle, wenn es eines gab. Eine Backstage-
|
||
* Tabelle hat aber beides nebeneinander, und nicht jeder Creator hat
|
||
* sein Handle im Steckbrief stehen. Ergebnis in der Messung: Die Zeile
|
||
* mit leerer Handle-Zelle fiel als "keine Person in der Zeile" durch,
|
||
* obwohl der Name danebenstand.
|
||
*
|
||
* Jetzt werden beide gemerkt und je Zeile nacheinander versucht:
|
||
* erst das Handle (eindeutig), dann der Name (mehrdeutig, aber
|
||
* besser als nichts). */
|
||
function personSpaltenRaten(kopf) {
|
||
/* AN SEINER ECHTEN AUSGABE GEMESSEN (16.09.2026) -- und sie ist hier
|
||
durchgefallen, bevor eine einzige Zahl ankam.
|
||
|
||
"Creator_innendaten" hat DREI Spalten, die nach Person aussehen:
|
||
|
||
Creator*in-ID 700001
|
||
Creator*innen-Anmeldename nova_live
|
||
Agent <Scout>
|
||
|
||
Die alte Regel nahm die ERSTE, die das Wort "creator" enthaelt --
|
||
also die ID. Danach wurde nach einem Creator namens "700001"
|
||
gesucht, und den gibt es nicht. Ergebnis: die ganze Datei
|
||
unzugeordnet, mit der Meldung "steht bei keinem Creator im Feld
|
||
TikTok". Der Hinweis war richtig formuliert und zeigte in die
|
||
voellig falsche Richtung.
|
||
|
||
ZWEI AENDERUNGEN, und beide sind Ausschluesse, keine Zusaetze:
|
||
|
||
1. EINE ID IST KEIN NAME. Was wie eine Kennnummer heisst, kommt
|
||
fuer beide Spalten nicht in Frage. Eine Nummer trifft nie einen
|
||
Namen -- sie kann also nur schaden.
|
||
2. "ANMELDENAME" IST DER HANDLE. So heisst bei TikTok der Name
|
||
mit dem @. Damit wird die richtige Spalte zum Handle, statt gar
|
||
keine zu finden.
|
||
|
||
UND "creator" ALLEIN REICHT NICHT MEHR als Namensspalte. In
|
||
derselben Datei steht weiter hinten "Neue*r LIVE-Creator*innen"
|
||
mit dem Wert "Nein" -- die alte Regel haette nach dem Ausschluss
|
||
der ID genau dort weitergesucht und einen Creator namens "Nein"
|
||
gesucht. Ein Spaltenname zaehlt nur noch, wenn er WIRKLICH nach
|
||
Name klingt (nick, anzeige, display, name) oder fuer sich allein
|
||
"Creator" heisst -- so wie in den aelteren Ausgaben.
|
||
|
||
KEINE BACKSLASHES IM MUSTER, mit Absicht: Diese Datei wird oefter
|
||
ueber Textwerkzeuge bearbeitet, und ein verschlucktes Zeichen in
|
||
einer Regex faellt erst auf, wenn Daten fehlen. */
|
||
const istKennung = /(^|[^a-z])id([^a-z]|$)|nummer/i;
|
||
const handle = kopf.findIndex((n) => !istKennung.test(String(n))
|
||
&& /handle|username|user.?name|anmeldename|anmelde.?name|login|@/i.test(String(n)));
|
||
const name = kopf.findIndex((n, i) => i !== handle && !istKennung.test(String(n))
|
||
&& (/nick|anzeige|display|name/i.test(String(n))
|
||
|| /^[\s]*creator[\s*:in]*[\s]*$/i.test(String(n))));
|
||
return { handle, name };
|
||
}
|
||
|
||
/** Die Creator, auf die diese Person Zahlen schreiben darf --
|
||
* als zwei Nachschlagewerke: nach Handle und nach Name. */
|
||
function creatorNachschlagen(person) {
|
||
const ids = sichtbareCreatorIds(person);
|
||
const wo = ids === null ? "" : ` AND p.id IN (${ids.map(() => "?").join(",")})`;
|
||
if (ids !== null && !ids.length) return { handle: new Map(), name: new Map(), anzahl: 0 };
|
||
const zeilen = db().prepare(
|
||
`SELECT p.id, p.name, p.tiktok FROM personen p
|
||
WHERE p.rolle = 'creator' AND p.aktiv = 1${wo}`).all(...(ids || []));
|
||
const handle = new Map(), name = new Map();
|
||
for (const z of zeilen) {
|
||
if (z.tiktok) handle.set(handleSchluessel(z.tiktok), z);
|
||
name.set(handleSchluessel(z.name), z);
|
||
}
|
||
return { handle, name, anzahl: zeilen.length };
|
||
}
|
||
|
||
/** Die gemeinsame Auswertung -- von Vorschau UND Übernahme benutzt.
|
||
*
|
||
* EINE Funktion für beide, weil sonst die Vorschau etwas anderes
|
||
* berechnen könnte als die Übernahme danach schreibt. Genau das ist
|
||
* die Sorte Unterschied, die niemand bemerkt, bis die Zahlen falsch
|
||
* sind. */
|
||
function netzwerkLesen(text, person, tagVorgabe) {
|
||
const zeilen = csvZerlegen(String(text || ""));
|
||
if (zeilen.length < 2) return { fehler: "Die Tabelle hat keine Datenzeilen." };
|
||
|
||
const kopf = zeilen[0];
|
||
const zu = spaltenRaten(kopf);
|
||
const wer = personSpaltenRaten(kopf);
|
||
if (wer.handle < 0 && wer.name < 0) {
|
||
return { fehler: "Keine Spalte mit Name oder Handle gefunden. "
|
||
+ "Die erste Zeile muss die Überschriften enthalten." };
|
||
}
|
||
/* Ohne Datum in der Tabelle muss eines mitgegeben werden -- sonst
|
||
wüsste niemand, auf welchen Tag die Zahlen gehören. Raten wäre
|
||
hier besonders teuer: Ein falscher Tag überschreibt einen echten. */
|
||
const ausTabelle = zu.tag !== undefined;
|
||
if (!ausTabelle && !tagVorgabe) {
|
||
return { fehler: "Die Tabelle hat keine Datumsspalte. Bitte den Tag angeben, "
|
||
+ "für den diese Zahlen gelten.", braucht_tag: true };
|
||
}
|
||
const messwerte = Object.keys(zu).filter((f) => f !== "tag");
|
||
if (!messwerte.length) {
|
||
return { fehler: "Keine Zahlenspalte erkannt (Diamanten, Dauer, Zuschauer …)." };
|
||
}
|
||
|
||
const nach = creatorNachschlagen(person);
|
||
const treffer = [];
|
||
const unbekannt = [];
|
||
const schlecht = [];
|
||
|
||
for (let i = 1; i < zeilen.length; i++) {
|
||
const z = zeilen[i];
|
||
/* Erst das Handle, dann der Name -- je Zeile, nicht je Tabelle.
|
||
Eine leere Handle-Zelle darf die Zeile nicht kosten, solange der
|
||
Name danebensteht. */
|
||
const rohHandle = wer.handle >= 0 ? z[wer.handle] : "";
|
||
const rohName = wer.name >= 0 ? z[wer.name] : "";
|
||
const rohWer = String(rohHandle).trim() || String(rohName).trim();
|
||
if (!rohWer) { schlecht.push({ zeile: i + 1, grund: "Keine Person in der Zeile." }); continue; }
|
||
|
||
/* EIN ZEITRAUM IST KEIN TAG -- die Regel steht in tagAusZelle().
|
||
Sie stand am 14.09. frueh nur hier; Filipe schickte seine Datei
|
||
daraufhin durch den Einzel-Import, und dort fehlte sie. Jetzt
|
||
benutzen alle drei Stellen dieselbe. */
|
||
let tag = tagVorgabe;
|
||
let spanne = null;
|
||
if (ausTabelle) {
|
||
const gelesen = tagAusZelle(z[zu.tag]);
|
||
if (gelesen.fehler) { schlecht.push({ zeile: i + 1, grund: gelesen.fehler }); continue; }
|
||
if (gelesen.zeitraum) spanne = gelesen.zeitraum;
|
||
else tag = gelesen.tag;
|
||
}
|
||
if (!tag && !spanne) { schlecht.push({ zeile: i + 1, grund: "Kein Tag angegeben." }); continue; }
|
||
const letzterTag = spanne ? spanne.bis : tag;
|
||
if (letzterTag > heuteLokal()) {
|
||
schlecht.push({ zeile: i + 1, grund: `${letzterTag} liegt in der Zukunft` });
|
||
continue;
|
||
}
|
||
|
||
/* Vier Versuche, in dieser Reihenfolge: Handle gegen Handle, Handle
|
||
gegen Name, Name gegen Handle, Name gegen Name. Das Eindeutige
|
||
zuerst. */
|
||
const sHandle = handleSchluessel(rohHandle);
|
||
const sName = handleSchluessel(rohName);
|
||
const p = (sHandle && nach.handle.get(sHandle))
|
||
|| (sHandle && nach.name.get(sHandle))
|
||
|| (sName && nach.handle.get(sName))
|
||
|| (sName && nach.name.get(sName));
|
||
if (!p) { unbekannt.push(rohWer.slice(0, 60)); continue; }
|
||
|
||
const werte = spanne
|
||
? { creator_id: p.id, name: p.name, von: spanne.von, bis: spanne.bis,
|
||
tage: tageImZeitraum(spanne.von, spanne.bis),
|
||
/* ALLE Spalten der Zeile, nicht nur die acht erkannten.
|
||
Nur beim Zeitraum: Die Tageszeilen haben ihre eigene
|
||
Tabelle, und ein halb gebautes Feld dort waere Datenhaltung
|
||
ohne Anzeige -- also nichts, was jemand je saehe. */
|
||
felder: felderAus(kopf, z) }
|
||
: { creator_id: p.id, name: p.name, tag };
|
||
let hatZahl = false;
|
||
for (const feld of messwerte) {
|
||
/* 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;
|
||
}
|
||
/* Eine Zeile ohne eine einzige Zahl ist keine Messung, sondern eine
|
||
Leerzeile mit Namen. Sie zu schreiben würde einen vorhandenen Tag
|
||
mit Nullen überschreiben. */
|
||
if (!hatZahl) { schlecht.push({ zeile: i + 1, grund: `${p.name}: keine einzige Zahl in der Zeile` }); continue; }
|
||
treffer.push(werte);
|
||
}
|
||
return {
|
||
kopf, spalten: zu, person_spalten: wer, aus_tabelle: ausTabelle,
|
||
treffer, unbekannt: [...new Set(unbekannt)], schlecht,
|
||
creator_gesamt: nach.anzahl,
|
||
};
|
||
}
|
||
|
||
/** Vorschau des Netzwerk-Imports. Schreibt nichts. */
|
||
leistungRouter.post("/workspace/api/leistung/netzwerk-import/vorschau", gleicheHerkunft,
|
||
express.json({ limit: "4mb" }), (req, res) => {
|
||
try {
|
||
if (!netzDarf(req.person)) return res.status(403).json({ fehler: "nicht_erlaubt" });
|
||
const tag = req.body?.tag ? datumLesen(req.body.tag) : null;
|
||
const e = netzwerkLesen(req.body?.text, req.person, tag);
|
||
if (e.fehler) return res.status(400).json(e);
|
||
|
||
/* Was ist neu, was wird ersetzt? Wer eine Tabelle zweimal
|
||
einfügt, soll sehen, dass es dieselbe ist -- und nicht
|
||
hinterher raten, ob er etwas überschrieben hat. */
|
||
const vorhanden = db().prepare(
|
||
"SELECT 1 FROM leistung WHERE creator_id = ? AND tag = ?");
|
||
const vorhandenSpanne = db().prepare(
|
||
"SELECT 1 FROM leistung_zeitraum WHERE creator_id = ? AND von = ? AND bis = ?");
|
||
let neu = 0, ersetzt = 0, zeitraeume = 0;
|
||
for (const t of e.treffer) {
|
||
if (t.von) {
|
||
zeitraeume++;
|
||
if (vorhandenSpanne.get(t.creator_id, t.von, t.bis)) ersetzt++; else neu++;
|
||
} else {
|
||
(vorhanden.get(t.creator_id, t.tag) ? ersetzt++ : neu++);
|
||
}
|
||
}
|
||
|
||
res.json({
|
||
spalten: e.spalten, person_spalten: e.person_spalten, aus_tabelle: e.aus_tabelle,
|
||
kopf: e.kopf,
|
||
/* WIE VIELE DAVON SIND ZEITRAEUME? Steht eigens da, weil es
|
||
etwas anderes ist als ein Tag -- wer eine Backstage-Ausgabe
|
||
ueber zwei Wochen einliest, soll das VOR dem Bestaetigen
|
||
sehen und nicht hinterher raten, warum die Woche leer ist. */
|
||
zeitraeume,
|
||
spanne: e.treffer.find((t) => t.von)
|
||
? { von: e.treffer.find((t) => t.von).von,
|
||
bis: e.treffer.find((t) => t.von).bis,
|
||
tage: e.treffer.find((t) => t.von).tage }
|
||
: null,
|
||
zugeordnet: e.treffer.length, neu, ersetzt,
|
||
/* WIE VIELE SPALTEN LANDEN WIRKLICH IN DER ABLAGE?
|
||
|
||
Filipes Sorge war genau die: "ich will dass alles von der
|
||
excel datei genommen wird." Das gehoert VOR das Bestaetigen,
|
||
nicht hinterher -- sonst muesste er der Zusage glauben,
|
||
statt die Zahl zu sehen.
|
||
|
||
Gemessen am ERSTEN Zeitraum der Datei, nicht ueber alle
|
||
summiert: Alle Zeilen haben dieselben Spalten, eine Summe
|
||
ueber 40 Creator waere eine grosse Zahl ohne Aussage. */
|
||
spalten_gesamt: (e.kopf || []).length,
|
||
felder: (e.treffer.find((t) => t.felder) || {}).felder?.length ?? 0,
|
||
unbekannt: e.unbekannt, probleme: e.schlecht.slice(0, 12),
|
||
probleme_gesamt: e.schlecht.length,
|
||
creator_gesamt: e.creator_gesamt,
|
||
beispiele: e.treffer.slice(0, 6),
|
||
});
|
||
} catch (fehler) {
|
||
console.error("[leistung] Netzwerk-Vorschau:", fehler?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/** Übernehmen. Erst jetzt wird geschrieben. */
|
||
leistungRouter.post("/workspace/api/leistung/netzwerk-import", gleicheHerkunft,
|
||
express.json({ limit: "4mb" }), (req, res) => {
|
||
try {
|
||
if (!netzDarf(req.person)) return res.status(403).json({ fehler: "nicht_erlaubt" });
|
||
const tag = req.body?.tag ? datumLesen(req.body.tag) : null;
|
||
const e = netzwerkLesen(req.body?.text, req.person, tag);
|
||
if (e.fehler) return res.status(400).json(e);
|
||
if (!e.treffer.length) return res.status(400).json({ fehler: "keine_zuordnung" });
|
||
|
||
const d = db();
|
||
const schreiben = d.prepare(`
|
||
INSERT OR REPLACE INTO leistung
|
||
(creator_id, tag, diamanten, dauer_min, gueltiger_tag, zuschauer_avg,
|
||
zuschauer_max, verweildauer_s, schenker, follower_neu, notiz,
|
||
erfasst, erfasst_von, quelle)
|
||
VALUES (?,?,?,?,?,?,?,?,?,?,
|
||
/* Eine von Hand geschriebene Notiz überlebt den Import --
|
||
sie steht in keiner Backstage-Tabelle. */
|
||
(SELECT notiz FROM leistung WHERE creator_id = ? AND tag = ?),
|
||
?,?, 'import')`);
|
||
|
||
/* DER ZWEITE WEG: ein Zeitraum geht in seine eigene Tabelle.
|
||
INSERT OR REPLACE, damit dieselbe Datei zweimal denselben
|
||
Zeitraum ersetzt statt ihn zu verdoppeln. */
|
||
const spanneSchreiben = d.prepare(`
|
||
INSERT OR REPLACE INTO leistung_zeitraum
|
||
(creator_id, von, bis, tage, diamanten, dauer_min, gueltige_tage,
|
||
zuschauer_avg, zuschauer_max, verweildauer_s, schenker, follower_neu,
|
||
erfasst, erfasst_von)
|
||
VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)`);
|
||
|
||
/* ERST WEGRAEUMEN, DANN SCHREIBEN. Ohne das Loeschen bliebe eine
|
||
Spalte, die beim ersten Mal gefuellt war und beim zweiten leer
|
||
ist, mit ihrem ALTEN Wert stehen -- ein Wert aus einer Datei,
|
||
die es nicht mehr gibt, und niemand koennte ihn von einem
|
||
frischen unterscheiden. */
|
||
const felderWeg = d.prepare(`DELETE FROM leistung_zeitraum_feld
|
||
WHERE creator_id = ? AND von = ? AND bis = ?`);
|
||
const feldSchreiben = d.prepare(`INSERT OR REPLACE INTO leistung_zeitraum_feld
|
||
(creator_id, von, bis, nr, name, text, zahl) VALUES (?,?,?,?,?,?,?)`);
|
||
|
||
let geschrieben = 0;
|
||
let spannen = 0;
|
||
let felder = 0;
|
||
d.exec("BEGIN");
|
||
try {
|
||
for (const t of e.treffer) {
|
||
if (t.von) {
|
||
felderWeg.run(t.creator_id, t.von, t.bis);
|
||
for (const f of (t.felder || [])) {
|
||
feldSchreiben.run(t.creator_id, t.von, t.bis, f.nr, f.name, f.text, f.zahl);
|
||
felder++;
|
||
}
|
||
spanneSchreiben.run(t.creator_id, t.von, t.bis, t.tage,
|
||
t.diamanten ?? null, t.dauer_min ?? null, t.gueltige_tage ?? null,
|
||
t.zuschauer_avg ?? null, t.zuschauer_max ?? null,
|
||
t.verweildauer_s ?? null, t.schenker ?? null, t.follower_neu ?? null,
|
||
new Date().toISOString(), req.person.id);
|
||
spannen++;
|
||
continue;
|
||
}
|
||
schreiben.run(t.creator_id, t.tag,
|
||
t.diamanten ?? null, t.dauer_min ?? null,
|
||
/* Ein gültiger Tag im Sinne von TikTok ist einer mit
|
||
LIVE-Zeit. Steht keine Dauer in der Tabelle, bleibt es
|
||
bei 0 -- geraten wird nichts. */
|
||
(t.dauer_min ?? 0) > 0 ? 1 : 0,
|
||
t.zuschauer_avg ?? null, t.zuschauer_max ?? null,
|
||
t.verweildauer_s ?? null, t.schenker ?? null, t.follower_neu ?? null,
|
||
t.creator_id, t.tag,
|
||
new Date().toISOString(), req.person.id);
|
||
geschrieben++;
|
||
}
|
||
d.exec("COMMIT");
|
||
} catch (f) { d.exec("ROLLBACK"); throw f; }
|
||
|
||
protokolliere("leistung_netzwerk_import", {
|
||
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
|
||
detail: `${geschrieben} Tage, ${spannen} Zeitraeume, ${felder} Felder, `
|
||
+ `${e.unbekannt.length} unbekannt`.slice(0, 120),
|
||
});
|
||
res.json({ geschrieben, zeitraeume: spannen, felder,
|
||
unbekannt: e.unbekannt, probleme: e.schlecht.length });
|
||
} catch (fehler) {
|
||
console.error("[leistung] Netzwerk-Import:", fehler?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/* =====================================================================
|
||
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)
|
||
|
||
Gebaut am 11.09. vormittags, am selben Tag wieder ausgebaut. Filipe,
|
||
mit den drei Knoepfen im Bild: *"ich will nur dass wir manager
|
||
scouts, dogfather oder spicy sachen eintragen koennen und nicht die
|
||
creator. ich will keine daten von denen kriegen, nur wir."*
|
||
|
||
Der Weg war technisch einwandfrei -- und er war der einzige, bei dem
|
||
ein CREATOR uns etwas gibt: seine eigene Datenkopie aus der
|
||
TikTok-App. Genau das soll nicht sein. Es bleiben die beiden
|
||
Wir-Wege: die eigene Datei und die Backstage-Tabelle der Agentur.
|
||
|
||
VOLLSTAENDIG ENTFERNT, nicht nur versteckt: Schnittstellen, Leser
|
||
(workspace-tiktok-datei.js), Knopf, Fenster und der fertige Text an
|
||
den Creator. Ein Weg, der nur unsichtbar ist, ist weiterhin da --
|
||
wer die Adresse kennt, benutzt ihn. Und ein Text, der einen Creator
|
||
um seine Daten bittet, soll in diesem Haus nirgends mehr stehen.
|
||
|
||
WAS WIR DAMIT NICHT MEHR WISSEN: nichts, was Backstage nicht auch
|
||
sagt. Die Datei war die zweite Quelle (COALESCE), nie die erste.
|
||
===================================================================== */
|
||
|
||
|
||
/** Vorschau: Was WÜRDE passieren? Schreibt nichts. */
|
||
leistungRouter.post("/workspace/api/leistung/:creatorId/import/vorschau", gleicheHerkunft,
|
||
express.json({ limit: "2mb" }), (req, res) => {
|
||
try {
|
||
const creatorId = Number(req.params.creatorId);
|
||
if (!Number.isInteger(creatorId)) return res.status(400).json({ fehler: "ungueltig" });
|
||
if (!darfEintragen(req.person)) return res.status(403).json({ fehler: "nicht_erlaubt" });
|
||
if (!darfSehen(req.person, creatorId)) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
|
||
const zeilen = csvZerlegen(String(req.body?.text || ""));
|
||
if (zeilen.length < 2) {
|
||
return res.status(400).json({ fehler: "Die Datei hat keine Datenzeilen." });
|
||
}
|
||
const kopf = zeilen[0];
|
||
const zu = req.body?.spalten && typeof req.body.spalten === "object"
|
||
? req.body.spalten : spaltenRaten(kopf);
|
||
|
||
if (zu.tag === undefined) {
|
||
return res.status(400).json({
|
||
fehler: "Ich finde keine Datumsspalte. Bitte die Spalte zuordnen.",
|
||
kopf, spalten: zu,
|
||
});
|
||
}
|
||
|
||
/* DIESE DATEI GEHOERT WOANDERS HIN (14.09.2026).
|
||
|
||
Filipe hat seine Backstage-Ausgabe hier hochgeladen -- eine
|
||
Tabelle mit ALLEN Creator:innen. Dieser Weg schreibt aber auf
|
||
EINEN Creator; herausgekommen ist eine Zeile mit lauter Nullen
|
||
auf einem Tag, den er nicht mehr sah.
|
||
|
||
"Es passiert nichts Sichtbares" ist die schlechteste aller
|
||
Antworten. Erkannt wird es an einer Namensspalte mit MEHREREN
|
||
verschiedenen Eintraegen -- das ist keine Tagesliste, das ist
|
||
eine Personenliste. */
|
||
const werSpalte = kopf.findIndex((n) =>
|
||
/creator|nickname|anmeldename|benutzer|username|handle|tiktok/i.test(String(n)));
|
||
if (werSpalte >= 0) {
|
||
const leute = new Set();
|
||
for (let i = 1; i < zeilen.length; i++) {
|
||
const w = String(zeilen[i][werSpalte] ?? "").trim().toLowerCase();
|
||
if (w) leute.add(w);
|
||
}
|
||
if (leute.size > 1) {
|
||
return res.status(409).json({
|
||
fehler: `In dieser Datei stehen ${leute.size} verschiedene Creator `
|
||
+ `(Spalte „${kopf[werSpalte]}“). Dieser Weg schreibt auf EINE Person. `
|
||
+ "Nimm „Backstage-Tabelle einfügen“ – der ordnet jede Zeile selbst zu.",
|
||
kopf, spalten: zu, mehrere: leute.size,
|
||
});
|
||
}
|
||
}
|
||
|
||
const neu = [];
|
||
const ersetzt = [];
|
||
const fehlerhaft = [];
|
||
for (let i = 1; i < zeilen.length; i++) {
|
||
const z = zeilen[i];
|
||
/* DER DRITTE AUSGANG MUSS HIER GENAUSO ANKOMMEN wie im
|
||
Backstage-Weg (14.09.2026).
|
||
|
||
Als tagAusZelle() den Zeitraum bekam, stand hier weiterhin
|
||
nur `gelesen.tag`. Bei einem Zeitraum war der `undefined`,
|
||
der Vergleich mit heute wurde still falsch, und die Zeile
|
||
landete mit `tag: undefined` in der Vorschau -- waehrend der
|
||
Schreibweg daneben sie kommentarlos uebersprang. Vorschau
|
||
und Ergebnis haetten sich widersprochen, und das ist der
|
||
Unterschied, den niemand bemerkt.
|
||
|
||
Ein dritter Ausgang taugt nur, wenn ihn ALLE Aufrufer
|
||
kennen. Das ist an diesem Tag die fuenfte Wiederholung
|
||
derselben Sache -- gefunden, bevor sie jemanden getroffen
|
||
hat, weil ich nach dem Umbau nachgesehen habe, wer die
|
||
Funktion sonst noch ruft. */
|
||
const gelesen = tagAusZelle(z[zu.tag]);
|
||
if (gelesen.fehler) { fehlerhaft.push({ zeile: i + 1, grund: gelesen.fehler }); continue; }
|
||
|
||
if (gelesen.zeitraum) {
|
||
const { von, bis } = gelesen.zeitraum;
|
||
if (bis > tagVor(0)) {
|
||
fehlerhaft.push({ zeile: i + 1, grund: `${bis} liegt in der Zukunft` });
|
||
continue;
|
||
}
|
||
const wertez = { von, bis, tage: tageImZeitraum(von, bis) };
|
||
for (const [feld, spalte] of Object.entries(zu)) {
|
||
if (feld === "tag" || spalte === undefined) continue;
|
||
wertez[feld] = feld === "dauer_min" ? dauerLesen(z[spalte]) : zahlLesen(z[spalte]);
|
||
}
|
||
const daz = db().prepare(
|
||
"SELECT 1 FROM leistung_zeitraum WHERE creator_id = ? AND von = ? AND bis = ?")
|
||
.get(creatorId, von, bis);
|
||
(daz ? ersetzt : neu).push(wertez);
|
||
continue;
|
||
}
|
||
|
||
const tag = gelesen.tag;
|
||
if (tag > tagVor(0)) { fehlerhaft.push({ zeile: i + 1, grund: `${tag} liegt in der Zukunft` }); continue; }
|
||
|
||
const werte = { tag };
|
||
for (const [feld, spalte] of Object.entries(zu)) {
|
||
if (feld === "tag" || spalte === undefined) continue;
|
||
/* Die Dauer hat eine Einheit, die uebrigen Felder nicht --
|
||
dieselbe Unterscheidung wie im Backstage-Weg. */
|
||
werte[feld] = feld === "dauer_min" ? dauerLesen(z[spalte]) : zahlLesen(z[spalte]);
|
||
}
|
||
const vorhanden = db().prepare(
|
||
"SELECT 1 FROM leistung WHERE creator_id = ? AND tag = ?").get(creatorId, tag);
|
||
(vorhanden ? ersetzt : neu).push(werte);
|
||
}
|
||
|
||
res.json({
|
||
kopf, spalten: zu,
|
||
/* Die ZAHLEN stehen vorn, die Beispiele dahinter: Wer
|
||
übernimmt, will wissen "wie viele", nicht "welche". */
|
||
neu: neu.length, ersetzt: ersetzt.length, fehlerhaft: fehlerhaft.length,
|
||
beispiele: neu.slice(0, 5),
|
||
ersetzt_beispiele: ersetzt.slice(0, 5),
|
||
probleme: fehlerhaft.slice(0, 10),
|
||
});
|
||
} catch (fehler) {
|
||
console.error("[leistung] Vorschau:", fehler?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/** Übernehmen. Erst jetzt wird geschrieben. */
|
||
leistungRouter.post("/workspace/api/leistung/:creatorId/import", gleicheHerkunft,
|
||
express.json({ limit: "2mb" }), (req, res) => {
|
||
try {
|
||
const creatorId = Number(req.params.creatorId);
|
||
if (!Number.isInteger(creatorId)) return res.status(400).json({ fehler: "ungueltig" });
|
||
if (!darfEintragen(req.person)) return res.status(403).json({ fehler: "nicht_erlaubt" });
|
||
if (!darfSehen(req.person, creatorId)) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
|
||
const zeilen = csvZerlegen(String(req.body?.text || ""));
|
||
if (zeilen.length < 2) return res.status(400).json({ fehler: "keine_daten" });
|
||
const zu = req.body?.spalten && typeof req.body.spalten === "object"
|
||
? req.body.spalten : spaltenRaten(zeilen[0]);
|
||
if (zu.tag === undefined) return res.status(400).json({ fehler: "keine_datumsspalte" });
|
||
|
||
const d = db();
|
||
const schreiben = d.prepare(`
|
||
INSERT OR REPLACE INTO leistung
|
||
(creator_id, tag, diamanten, dauer_min, gueltiger_tag, zuschauer_avg,
|
||
zuschauer_max, verweildauer_s, schenker, follower_neu, notiz,
|
||
erfasst, erfasst_von, quelle)
|
||
VALUES (?,?,?,?,?,?,?,?,?,?,
|
||
/* Eine vorhandene Notiz NICHT wegwerfen: Sie ist von Hand
|
||
geschrieben und steht in keinem Export. */
|
||
(SELECT notiz FROM leistung WHERE creator_id = ? AND tag = ?),
|
||
?,?, 'import')`);
|
||
|
||
/* Der zweite Weg, wie im Backstage-Import: Ein Zeitraum geht in
|
||
seine eigene Tabelle. */
|
||
const spanneSchreiben = d.prepare(`
|
||
INSERT OR REPLACE INTO leistung_zeitraum
|
||
(creator_id, von, bis, tage, diamanten, dauer_min, gueltige_tage,
|
||
zuschauer_avg, zuschauer_max, verweildauer_s, schenker, follower_neu,
|
||
erfasst, erfasst_von)
|
||
VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)`);
|
||
|
||
/* UND ALLE UEBRIGEN SPALTEN -- WORTGLEICH WIE IM ANDEREN WEG.
|
||
|
||
Es gibt zwei Wege in dieses System (eine Datei je Creator und
|
||
eine Tabelle fuer alle), und sie sind in diesem Modul schon
|
||
dreimal auseinandergelaufen: beim Zeitraumschutz, bei der
|
||
Dauer-Einheit und beim dritten Ausgang. Jedes Mal, weil eine
|
||
Sache an zwei Stellen geschrieben stand.
|
||
|
||
Deshalb kommt die Liste der Felder hier NICHT aus einer zweiten
|
||
Rechnung, sondern aus derselben Funktion `felderAus`. */
|
||
const felderWeg = d.prepare(`DELETE FROM leistung_zeitraum_feld
|
||
WHERE creator_id = ? AND von = ? AND bis = ?`);
|
||
const feldSchreiben = d.prepare(`INSERT OR REPLACE INTO leistung_zeitraum_feld
|
||
(creator_id, von, bis, nr, name, text, zahl) VALUES (?,?,?,?,?,?,?)`);
|
||
let felder = 0;
|
||
|
||
let geschrieben = 0, uebersprungen = 0, spannen = 0;
|
||
d.exec("BEGIN");
|
||
try {
|
||
for (let i = 1; i < zeilen.length; i++) {
|
||
const z = zeilen[i];
|
||
/* Dieselbe Regel wie in der Vorschau -- sonst zeigt die
|
||
Vorschau etwas anderes an, als geschrieben wird. Genau das
|
||
ist der Unterschied, den niemand bemerkt.
|
||
|
||
UND DERSELBE DRITTE AUSGANG: Ohne diesen Zweig wuerde ein
|
||
Zeitraum hier still uebersprungen, waehrend die Vorschau
|
||
ihn zaehlt. */
|
||
const gelesen = tagAusZelle(z[zu.tag]);
|
||
const wz = (feld) => (zu[feld] === undefined ? null
|
||
: (feld === "dauer_min" ? dauerLesen(z[zu[feld]]) : zahlLesen(z[zu[feld]])));
|
||
if (gelesen.zeitraum) {
|
||
const { von, bis } = gelesen.zeitraum;
|
||
if (bis > tagVor(0)) { uebersprungen++; continue; }
|
||
spanneSchreiben.run(creatorId, von, bis, tageImZeitraum(von, bis),
|
||
wz("diamanten"), wz("dauer_min"), wz("gueltige_tage"),
|
||
wz("zuschauer_avg"), wz("zuschauer_max"), wz("verweildauer_s"),
|
||
wz("schenker"), wz("follower_neu"),
|
||
jetzt(), req.person.id);
|
||
felderWeg.run(creatorId, von, bis);
|
||
for (const f of felderAus(zeilen[0], z)) {
|
||
feldSchreiben.run(creatorId, von, bis, f.nr, f.name, f.text, f.zahl);
|
||
felder++;
|
||
}
|
||
spannen++;
|
||
continue;
|
||
}
|
||
const tag = gelesen.tag;
|
||
if (!tag || tag > tagVor(0)) { uebersprungen++; continue; }
|
||
const w = (feld) => (zu[feld] === undefined ? null : zahlLesen(z[zu[feld]]));
|
||
/* Die Dauer hat eine EINHEIT ("86Std. 10Min. 52Sek."), die
|
||
uebrigen Felder nicht. */
|
||
const dauer = zu.dauer_min === undefined ? null : dauerLesen(z[zu.dauer_min]);
|
||
schreiben.run(
|
||
creatorId, tag, w("diamanten"), dauer,
|
||
/* Ein gültiger Tag ist ein Tag mit LIVE-Zeit. Steht im
|
||
Export nichts, wird aus der Dauer geschlossen -- eine
|
||
eigene Spalte dafür gibt es meist nicht. */
|
||
dauer && dauer > 0 ? 1 : 0,
|
||
w("zuschauer_avg"), w("zuschauer_max"), w("verweildauer_s"),
|
||
w("schenker"), w("follower_neu"),
|
||
creatorId, tag,
|
||
jetzt(), req.person.id);
|
||
geschrieben++;
|
||
}
|
||
d.exec("COMMIT");
|
||
} catch (f) {
|
||
try { d.exec("ROLLBACK"); } catch { /* schon zurück */ }
|
||
throw f;
|
||
}
|
||
|
||
protokolliere("leistung_import", {
|
||
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
|
||
detail: `Creator #${creatorId}: ${geschrieben} Tage, ${spannen} Zeitraeume, ${felder} Felder`,
|
||
});
|
||
res.json({ ok: true, geschrieben, zeitraeume: spannen, felder, uebersprungen });
|
||
} catch (fehler) {
|
||
console.error("[leistung] Import:", fehler?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|