Backstage: eine Tabelle einfuegen, alle Creator auf einmal
Filipe: "mach diesen ganzen plan jetzt sofort auf einen schlag fertig."
Das ist Stufe 0 des Plans vom 10.09. -- der Teil, der ohne TikTok
auskommt und deshalb sofort baubar war.
WARUM EINFUEGEN UND NICHT ABRUFEN. Die Recherche vom 10.09. ergab:
TikTok LIVE Backstage hat keine Schnittstelle und keinen Export (zwei
unabhaengige Quellen), und in der offiziellen Scope-Liste von TikTok
gibt es nichts zu LIVE, Diamanten oder Netzwerkdaten. Was es gibt, ist
eine Tabelle im Browser. Also: markieren, kopieren, einfuegen. Kein
Token, kein Zugangsdatum, keine Erweiterung, die Backstages interne
Abfragen mitliest -- letzteres waere ein Verstoss gegen die
Nutzungsbedingungen und riskiert ausgerechnet das Netzwerkkonto.
DER UNTERSCHIED ZUM VORHANDENEN IMPORT ist genau eine Frage: Zu wem
gehoert diese Zeile? Der alte Weg nimmt eine Datei fuer EINEN Creator,
Backstage zeigt ALLE. Zugeordnet wird ueber `personen.tiktok` -- den
oeffentlichen Namen ohne @, den es im Steckbrief laengst gibt. Ohne @,
ohne Gross-/Kleinschreibung, ohne unsichtbare Zeichen aus der
Zwischenablage; faellt das aus, ueber den angezeigten Namen. Beides
ergebnislos -> die Zeile wird GEMELDET, nicht geraten. Eine falsch
zugeordnete Zahl ist schlimmer als eine fehlende, weil die fehlende
auffaellt.
DER TABULATOR WAR DER GANZE KNACKPUNKT. `csvZerlegen` kannte nur Komma
und Semikolon. Eine aus dem Browser kopierte Tabelle ist aber
TAB-getrennt -- ohne diese Zeile waere alles in Spalte 1 gelandet und
die Vorschau haette "keine Datumsspalte" gemeldet: eine richtige
Meldung auf eine falsche Faehrte. Gewaehlt wird jetzt das HAEUFIGSTE
der drei Zeichen, nicht das erste gefundene.
WAS NICHT PASSIERT, und genau das ist geprueft:
- unbekannte Person -> gemeldet mit Namen, nicht geraten
- Zeile ohne eine einzige Zahl -> uebersprungen (sie wuerde sonst
einen echten Tag mit Nullen ueberschreiben)
- Datum in der Zukunft -> abgelehnt
- dieselbe Tabelle zweimal -> ersetzt, verdoppelt nicht
- eine von Hand geschriebene Notiz -> ueberlebt den Import
- es wird niemand nebenbei angelegt
- kein Datum in der Tabelle und keines angegeben -> es wird GEFRAGT
NEUE PRUEFUNG (pruef-backstage-import, 29 Pruefungen) mit einer echten,
tab-getrennten Backstage-artigen Tabelle: drei Creator, einer davon
ohne Handle, einer mit abweichender Schreibweise, einer gar nicht im
Haus.
DREI EIGENE FEHLER, alle von der Pruefung gefunden:
* Die Spaltenerkennung nahm nur EINE Personenspalte. Ein Creator ohne
Handle fiel als "keine Person in der Zeile" durch, obwohl sein Name
danebenstand. Jetzt werden beide Spalten gemerkt und je Zeile
nacheinander versucht.
* Ein Scout bekam 400 statt 403 -- er kam durch `darfEintragen`
(das Scouts einschliesst) und scheiterte erst daran, dass er keinen
der Creator sieht. Richtige Antwort aus dem falschen Grund. Der
Netzwerk-Weg haengt jetzt an `istLeitung`, genau wie der Knopf.
* Die Vorschau meldete "2 von 3" statt "3 von 4" -- Folge des ersten
Fehlers.
Der Fusstext der Seite nannte zwei Wege, es sind jetzt drei. Ein Text,
der etwas anderes sagt als die Software tut, ist schlimmer als keiner.
Co-Authored-By: Claude Opus 5 <[email protected]>
This commit is contained in:
Claude Opus 5
@@ -45,7 +45,7 @@
|
||||
import express from "express";
|
||||
import {
|
||||
db, protokolliere, echteIp, sitzungLesen, istLeitung, istSpicy,
|
||||
sichtbareCreatorIds, ROLLEN_SORTIERUNG,
|
||||
sichtbareCreatorIds, ROLLEN_SORTIERUNG, heuteLokal,
|
||||
} from "./workspace.js";
|
||||
|
||||
export const leistungRouter = express.Router();
|
||||
@@ -473,9 +473,26 @@ export function csvZerlegen(text) {
|
||||
|
||||
/* Trennzeichen erkennen: Deutsche Exporte nutzen oft Semikolon,
|
||||
englische Komma. Geraten wird an der ERSTEN Zeile -- dort, wo die
|
||||
Überschriften stehen. */
|
||||
Ü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 trenner = (kopf.match(/;/g) || []).length > (kopf.match(/,/g) || []).length ? ";" : ",";
|
||||
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];
|
||||
@@ -589,6 +606,267 @@ export function spaltenRaten(kopf) {
|
||||
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" });
|
||||
}
|
||||
});
|
||||
|
||||
/** Vorschau: Was WÜRDE passieren? Schreibt nichts. */
|
||||
leistungRouter.post("/workspace/api/leistung/:creatorId/import/vorschau", gleicheHerkunft,
|
||||
express.json({ limit: "2mb" }), (req, res) => {
|
||||
|
||||
Reference in New Issue
Block a user