DogFatherGitandClaude Opus 5
027c372afd
Filipe: "tiktok entwicklerkonto hab ich nicht und werd ich nicht
bekommen."
Damit sind zwei der drei Wege aus dem Plan vom 10.09. erledigt: Login
Kit und die Datenportabilitaets-API haengen beide an einer App auf
developers.tiktok.com. Sie sind nicht verschoben, sie sind weg.
DER DRITTE BRAUCHT KEINES. Jeder TikTok-Nutzer kann seine eigenen Daten
selbst herunterladen (Profil -> Einstellungen -> Konto -> Deine Daten
herunterladen, Format JSON). Die Datei enthaelt laut TikToks eigener
Datentypen-Liste einen Abschnitt "TikTok LIVE" mit dem Go-LIVE-Verlauf.
Der Creator gibt sie her, mit eigenen Haenden -- legitimer wird es
nicht, und es ist jetzt der einzige verbliebene Weg an TikTok-Daten.
ICH KENNE DAS FORMAT NICHT -- UND BAUE TROTZDEM.
TikTok dokumentiert, DASS es den Verlauf gibt, nicht wie die Schluessel
heissen. Der naheliegende Weg waere, Namen zu raten. Das waere die
schlechteste Loesung: Er fiele bei der ersten echten Datei auseinander,
und zwar STILL -- "0 Eintraege gefunden" sieht aus wie "war nicht live".
Deshalb wird gesucht statt geraten. Der Leser geht die Datei durch,
sammelt ALLE Listen, deren Eintraege ein Datum tragen (gemessen am
INHALT, nicht am Feldnamen), schlaegt eine Zuordnung vor und legt sie
zur Auswahl vor -- mit Anzahl, Zeitraum, Beispielzeile und dem, was
dabei herauskaeme. Bestaetigt wird von Hand. Damit ist der Leser
unabhaengig davon, wie die Felder heissen.
DIE EINHEIT IST DIE FALLE. "83" kann Sekunden, Minuten oder Stunden
sein. Geraten wird NICHT aus der Zahl, sondern aus dem Schluesselnamen
-- und wo der schweigt, aus der Form ("01:23:45" ist eindeutig).
Schweigen beide, kommt null zurueck. Eine Dauer, die um Faktor 60
danebenliegt, sieht richtig aus und ist es nicht.
MEHRERE LIVES AN EINEM TAG SIND EIN TAG: Dauer und Diamanten addiert,
bei den Zuschauern gewinnt die hoehere Spitze -- ein Durchschnitt aus
zwei Streams waere eine Zahl, die es nie gegeben hat.
DIE DATEI UEBERSCHREIBT NICHTS. Anders als der Backstage-Import, der
die Wahrheit der Agentur bringt, ist diese Datei die ZWEITE Quelle. Wo
schon eine Zahl steht -- von Hand oder aus Backstage --, bleibt sie
stehen (COALESCE statt REPLACE). Sonst wuerde ein Dateiupload
stillschweigend die offiziellen Zahlen ersetzen, und niemand wuesste
hinterher, welche gilt.
UND SIE WIRD NICHT GESPEICHERT. Gelesen, ausgewertet, verworfen. In
derselben Datei stehen Direktnachrichten, Such- und Ansehverlauf; die
haben auf diesem Server nichts zu suchen. "Income and Wallet" bleibt
ebenfalls liegen: Diamanten sind Leistung, Auszahlungen sind Gehalt.
GEPRUEFT OHNE ECHTE DATEI -- MIT DREI ERFUNDENEN (47 Pruefungen):
A englisch, flach, Dauer in Sekunden
B deutsch, verschachtelt, Dauer als "01:23:45"
C Sekundenstempel, Dauer in Minuten, andere Namen
+ eine Datei ganz ohne Verlauf -> muss abgelehnt werden
Eine Pruefung gegen EINE ausgedachte Form wuerde nur beweisen, dass
mein Leser meine eigene Erfindung liest. Drei verschiedene zeigen, dass
er das Prinzip kann und nicht eine Form.
EIN EIGENER FEHLER, von der Pruefung gefunden: Der Nachrichtenverlauf
in Form A hatte nur EINEN Eintrag und fiel damit unter die
Mindestgroesse von zwei. Die Pruefung "der LIVE-Verlauf steht oben"
hatte danach nur einen Kandidaten und bewies gar nichts -- eine
Rangfolge laesst sich nur an mindestens zwei Dingen zeigen. Jetzt sind
es drei Nachrichten, und die Rangfolge ist wirklich gemessen.
Co-Authored-By: Claude Opus 5 <[email protected]>
1126 lines
49 KiB
JavaScript
1126 lines
49 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 {
|
||
db, protokolliere, echteIp, sitzungLesen, istLeitung, istSpicy,
|
||
sichtbareCreatorIds, ROLLEN_SORTIERUNG, heuteLokal,
|
||
} from "./workspace.js";
|
||
import { kandidatenFinden, listeAmPfad, zuTagen } from "./workspace-tiktok-datei.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);
|
||
|
||
/* SPICY MEDIA SIEHT DIE ZAHLEN NIRGENDS (07.09.2026).
|
||
|
||
Filipe: "bei der spicy rolle, die zahlen diese kategorie nicht
|
||
sehen." Zuerst habe ich woertlich nur die KATEGORIE geschlossen --
|
||
Kachel und Seite. Auf Nachfrage, was noch offen sei, habe ich selbst
|
||
darauf hingewiesen, dass die Creator-Zahlen damit weiterhin im
|
||
Dashboard stehen (Diamanten, LIVE-Tage, Verweildauer je Karte);
|
||
Filipe hat entschieden, dass auch das weg soll.
|
||
|
||
DIE SPERRE SITZT AM SERVER UND NICHT IN DER OBERFLAECHE. Eine
|
||
ausgeblendete Zeile ist keine Sperre: Wer die Adresse kennt, ruft
|
||
die Schnittstelle direkt auf. Hier kommt sie gar nicht mehr an
|
||
Daten.
|
||
|
||
404 statt 403, wie ueberall in diesem Haus: Wer nicht hierher
|
||
gehoert, muss nicht erfahren, dass es diesen Bereich gibt.
|
||
|
||
DAS DASHBOARD BRICHT DADURCH NICHT. Es holt die Zahlen in EINER
|
||
zusaetzlichen Abfrage und faengt ihren Fehlschlag ausdruecklich ab
|
||
("die Karten stehen auch ohne", uebersicht.js) -- bei ihr fehlen
|
||
also die drei Zeilen, alles andere bleibt. Genau deshalb ist diese
|
||
eine Zeile hier der ganze Eingriff. */
|
||
leistungRouter.use("/workspace/api/leistung", (req, res, next) => {
|
||
if (istSpicy(req.person)) return res.status(404).json({ fehler: "nicht_gefunden" });
|
||
next();
|
||
});
|
||
|
||
/* ---------- 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;
|
||
|
||
res.json({
|
||
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;
|
||
}
|
||
|
||
/** 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: /datum|date|tag|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) {
|
||
const handle = kopf.findIndex((n) => /handle|username|user.?name|tiktok.?id|@/i.test(String(n)));
|
||
const name = kopf.findIndex((n, i) => i !== handle
|
||
&& /nick|anzeige|display|name|creator/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; }
|
||
|
||
const tag = ausTabelle ? 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; }
|
||
|
||
/* 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 = { creator_id: p.id, name: p.name, tag };
|
||
let hatZahl = false;
|
||
for (const feld of messwerte) {
|
||
const w = 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 = ?");
|
||
let neu = 0, ersetzt = 0;
|
||
for (const t of e.treffer) (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,
|
||
zugeordnet: e.treffer.length, neu, ersetzt,
|
||
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')`);
|
||
|
||
let geschrieben = 0;
|
||
d.exec("BEGIN");
|
||
try {
|
||
for (const t of e.treffer) {
|
||
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} Zeilen, ${e.unbekannt.length} unbekannt`.slice(0, 120),
|
||
});
|
||
res.json({ geschrieben, unbekannt: e.unbekannt, probleme: e.schlecht.length });
|
||
} catch (fehler) {
|
||
console.error("[leistung] Netzwerk-Import:", fehler?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/* =====================================================================
|
||
DIE EIGENE TIKTOK-DATEI EINES CREATORS (11.09.2026)
|
||
|
||
Der letzte verbliebene Weg aus dem Plan vom 10.09.: Login Kit und
|
||
Datenportabilitäts-API hängen beide an einem TikTok-Entwicklerkonto,
|
||
und das wird es nicht geben ("hab ich nicht und werd ich nicht
|
||
bekommen"). Dieser hier braucht keines -- der Creator lädt seine
|
||
eigenen Daten bei TikTok herunter und gibt die Datei her.
|
||
|
||
Das Suchen und Umrechnen steht in workspace-tiktok-datei.js; hier
|
||
stehen nur die beiden Wege und die Rechte.
|
||
|
||
DIE DATEI WIRD NICHT GESPEICHERT. Sie wird gelesen, ausgewertet und
|
||
fällt danach weg. In ihr stehen auch Direktnachrichten und der
|
||
Ansehverlauf -- das ist nichts, was auf einem Server liegen soll,
|
||
der es nicht braucht.
|
||
===================================================================== */
|
||
leistungRouter.post("/workspace/api/leistung/:creatorId/tiktok-datei/vorschau",
|
||
gleicheHerkunft, express.json({ limit: "60mb" }), (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 inhalt = req.body?.inhalt;
|
||
if (!inhalt || typeof inhalt !== "object") {
|
||
return res.status(400).json({ fehler: "Das ist keine gelesene JSON-Datei." });
|
||
}
|
||
const kandidaten = kandidatenFinden(inhalt);
|
||
if (!kandidaten.length) {
|
||
return res.status(400).json({
|
||
fehler: "In dieser Datei steht keine Liste mit Datumsangaben. "
|
||
+ "Wurde beim Herunterladen wirklich JSON gewählt (nicht TXT) und "
|
||
+ "„Alles auswählen“ angehakt?",
|
||
});
|
||
}
|
||
/* Zu jedem Vorschlag gleich zeigen, was dabei herauskäme -- sonst
|
||
muss der Mensch aus Schlüsselnamen raten, welcher der richtige
|
||
ist. */
|
||
const mitVorschau = kandidaten.map((k) => {
|
||
const { tage } = zuTagen(k.beispiele.length ? listeAmPfad(inhalt, k.pfad) || [] : [], k.vorschlag);
|
||
return {
|
||
...k,
|
||
tage_gesamt: tage.length,
|
||
tage_beispiel: tage.slice(-3),
|
||
/* Die Beispielzeilen gekürzt: In einem Vollarchiv hängt an
|
||
einem Eintrag manchmal ein ganzer Kommentartext. */
|
||
beispiele: k.beispiele.map((b) => {
|
||
const klein = {};
|
||
for (const [s, w] of Object.entries(b)) klein[s] = String(w ?? "").slice(0, 80);
|
||
return klein;
|
||
}),
|
||
};
|
||
});
|
||
res.json({ kandidaten: mitVorschau });
|
||
} catch (fehler) {
|
||
console.error("[leistung] TikTok-Datei Vorschau:", fehler?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
leistungRouter.post("/workspace/api/leistung/:creatorId/tiktok-datei",
|
||
gleicheHerkunft, express.json({ limit: "60mb" }), (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 inhalt = req.body?.inhalt;
|
||
const pfad = String(req.body?.pfad || "");
|
||
const zuordnung = req.body?.zuordnung;
|
||
if (!inhalt || !pfad || !zuordnung?.tag) {
|
||
return res.status(400).json({ fehler: "Es fehlt die Auswahl, was gelesen werden soll." });
|
||
}
|
||
const liste = listeAmPfad(inhalt, pfad);
|
||
if (!liste) return res.status(400).json({ fehler: "Diese Liste gibt es in der Datei nicht." });
|
||
|
||
const { tage, uebersprungen } = zuTagen(liste, zuordnung);
|
||
const heute = heuteLokal();
|
||
const brauchbar = tage.filter((t) => t.tag <= heute
|
||
/* Ein Tag ohne eine einzige Zahl ist keine Messung. Dieselbe
|
||
Regel wie beim Backstage-Import. */
|
||
&& (t.dauer_min !== null || t.diamanten !== null || t.zuschauer_max !== null));
|
||
if (!brauchbar.length) return res.status(400).json({ fehler: "keine_brauchbaren_tage" });
|
||
|
||
const d = db();
|
||
const schreiben = d.prepare(`
|
||
INSERT INTO leistung
|
||
(creator_id, tag, diamanten, dauer_min, gueltiger_tag, zuschauer_max,
|
||
erfasst, erfasst_von, quelle)
|
||
VALUES (?,?,?,?,?,?,?,?,'import')
|
||
ON CONFLICT(creator_id, tag) DO UPDATE SET
|
||
/* NUR FÜLLEN, NICHT ÜBERSCHREIBEN.
|
||
|
||
Anders als beim Backstage-Import, der die Wahrheit der
|
||
Agentur bringt: Diese Datei kommt vom Creator und ist eine
|
||
ZWEITE Quelle. Wo schon eine Zahl steht -- von Hand
|
||
eingetragen oder aus Backstage --, bleibt sie stehen.
|
||
Andersherum würde ein Dateiupload stillschweigend die
|
||
offiziellen Zahlen ersetzen, und niemand wüsste hinterher,
|
||
welche gilt. */
|
||
diamanten = COALESCE(leistung.diamanten, excluded.diamanten),
|
||
dauer_min = COALESCE(leistung.dauer_min, excluded.dauer_min),
|
||
zuschauer_max = COALESCE(leistung.zuschauer_max, excluded.zuschauer_max),
|
||
gueltiger_tag = MAX(leistung.gueltiger_tag, excluded.gueltiger_tag)`);
|
||
|
||
let geschrieben = 0, ergaenzt = 0;
|
||
const vorhanden = d.prepare("SELECT 1 FROM leistung WHERE creator_id = ? AND tag = ?");
|
||
d.exec("BEGIN");
|
||
try {
|
||
for (const t of brauchbar) {
|
||
const gabEs = !!vorhanden.get(creatorId, t.tag);
|
||
schreiben.run(creatorId, t.tag, t.diamanten, t.dauer_min,
|
||
(t.dauer_min ?? 0) > 0 ? 1 : 0, t.zuschauer_max,
|
||
new Date().toISOString(), req.person.id);
|
||
if (gabEs) ergaenzt++; else geschrieben++;
|
||
}
|
||
d.exec("COMMIT");
|
||
} catch (f) { d.exec("ROLLBACK"); throw f; }
|
||
|
||
protokolliere("leistung_tiktok_datei", {
|
||
personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
|
||
detail: `Creator #${creatorId}: ${geschrieben} neu, ${ergaenzt} ergaenzt`.slice(0, 120),
|
||
});
|
||
res.json({ geschrieben, ergaenzt, uebersprungen: uebersprungen.length });
|
||
} catch (fehler) {
|
||
console.error("[leistung] TikTok-Datei:", fehler?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|
||
|
||
/** 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,
|
||
});
|
||
}
|
||
|
||
const neu = [];
|
||
const ersetzt = [];
|
||
const fehlerhaft = [];
|
||
for (let i = 1; i < zeilen.length; i++) {
|
||
const z = zeilen[i];
|
||
const tag = datumLesen(z[zu.tag]);
|
||
if (!tag) { fehlerhaft.push({ zeile: i + 1, grund: `Datum unlesbar: "${z[zu.tag]}"` }); continue; }
|
||
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;
|
||
werte[feld] = 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')`);
|
||
|
||
let geschrieben = 0, uebersprungen = 0;
|
||
d.exec("BEGIN");
|
||
try {
|
||
for (let i = 1; i < zeilen.length; i++) {
|
||
const z = zeilen[i];
|
||
const tag = datumLesen(z[zu.tag]);
|
||
if (!tag || tag > tagVor(0)) { uebersprungen++; continue; }
|
||
const w = (feld) => (zu[feld] === undefined ? null : zahlLesen(z[zu[feld]]));
|
||
const dauer = w("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`,
|
||
});
|
||
res.json({ ok: true, geschrieben, uebersprungen });
|
||
} catch (fehler) {
|
||
console.error("[leistung] Import:", fehler?.message);
|
||
res.status(503).json({ fehler: "nicht_verfuegbar" });
|
||
}
|
||
});
|