dogfather-universe/server/workspace-scouts.js

/* =====================================================================
   workspace-scouts.js — Scout-CRM (Konzept, Seite 15).

   Pipeline vom ersten Kontakt bis zur Uebergabe, Qualifizierung und
   Follow-ups. Der Merksatz der Seite ist hier die Sicherheitsregel:
   "Scouts sehen ihre Pipeline -- die Admin-Rolle die Gesamtuebersicht --
   Creator keine Scout-internen Daten."

   Creator bekommen deshalb 404, nicht 403: Sie sollen nicht einmal
   erfahren, dass es diesen Bereich gibt.

   Besonderheit am Ende der Pipeline: Aus einem uebergebenen Lead kann
   das Management mit einem Klick einen Creator anlegen -- "Creator-
   Onboarding starten" aus dem Deck. Der Zugangscode wird dabei einmal
   angezeigt, wie in der Personenverwaltung.
   ===================================================================== */

import express from "express";
import {
  db, protokolliere, echteIp, sitzungLesen, personAnlegen, betreuungSetzen, istLeitung, istDogFather, siehtAlles, pipelineIds,
  heuteLokal,
} from "./workspace.js";

export const scoutRouter = express.Router();

/* Reihenfolge ist die Pipeline aus dem Konzept. */
export const STUFEN = {
  neu: "Neu entdeckt",
  angesprochen: "Angesprochen",
  gespraech: "Gespräch geplant",
  interessiert: "Interessiert",
  uebergeben: "Übergeben",
  abgelehnt: "Abgelehnt",
};
const WEITER = { neu: "angesprochen", angesprochen: "gespraech", gespraech: "interessiert", interessiert: "uebergeben" };
const PRIORITAETEN = ["hoch", "mittel", "niedrig"];

/* DIE VIER LAENDER, IN DENEN BETREUT WIRD -- plus "andere".

   Filipe am 10.09.2026: "wir sind in deutschland, betreuen creator aus
   deutschland, luxemburg, schweiz und österreich." Die Liste steht
   hier und wird der Oberflaeche mitgeschickt (siehe /api/leads), damit
   es nicht zwei davon gibt. */
export const LAENDER = ["DE", "AT", "CH", "LU", "andere"];
export const LAND_NAME = {
  DE: "Deutschland", AT: "Österreich", CH: "Schweiz", LU: "Luxemburg", andere: "anderes Land",
};

/* SCHON BEI EINEM NETZWERK? Die teuerste Frage der ganzen Pipeline --
   wer unter Vertrag steht, kann nicht uebernommen werden. "unbekannt"
   ist ausdruecklich eine gueltige Antwort und nicht dasselbe wie
   "nein": Nicht gefragt zu haben ist etwas anderes, als gefragt und
   ein Nein bekommen zu haben. */
export const NETZWERK = ["nein", "ja", "unbekannt"];
export const NETZWERK_NAME = {
  nein: "frei", ja: "schon im Netzwerk", unbekannt: "noch nicht gefragt",
};

/* NORMAL ODER PREMIUM -- die beiden Arten, die TikTok kennt (06.10.2026).

   Filipe: "es gibt bei tiktok nämlich diese zwei optionen von streamer."

   GENAU ZWEI, und absichtlich kein "weiss nicht". Die Begruendung steht
   bei der Spalte in workspace.js; kurz: Hier wird nicht eine fremde
   Tatsache festgehalten, sondern eine eigene Absicht -- und deren
   Normalfall ist "normal".

   DIE REIHENFOLGE IST DIE DER SPALTEN auf der Seite: links normal,
   rechts premium. Die Oberflaeche liest sie von hier, sie fuehrt keine
   eigene Liste -- sonst stuende die Trennung an zwei Stellen und wuerde
   an einer davon geaendert. */
export const ARTEN = ["normal", "premium"];
export const ART_NAME = { normal: "Normal", premium: "Premium" };

/* NULL ist "normal". Diese Umrechnung steht an EINER Stelle, weil sonst
   jede Abfrage, jede Spaltenzuteilung und jede Zaehlung ihre eigene
   Meinung dazu haette, wo ein Lead ohne Eintrag hingehoert. */
export const artVon = (wert) => (wert === "premium" ? "premium" : "normal");
const NAME_MAX = 120;
const TEXT_MAX = 3000;

const jetzt = () => new Date().toISOString();

function angemeldet(req, res, next) {
  const person = sitzungLesen(req);
  if (!person) return res.status(401).json({ fehler: "nicht_angemeldet" });
  if (person.rolle === "creator") return res.status(404).json({ fehler: "nicht_gefunden" });
  /* DIE PIPELINE GEHOERT DEM WORKSPACE, NICHT TEAM DOGI (11.09.2026).

     Filipe: "das soll getrennt von der team dogi seite sein. die laufen
     was daten angeht getrennt."

     Ohne diese Zeile war es genau umgekehrt: `sichtbar()` gibt fuer
     jeden mit `siehtAlles` schlicht `1=1` zurueck -- und DogFather hat
     `siehtAlles` auch dann, wenn er auf der crew-Adresse arbeitet. Die
     komplette Scout-Pipeline des Workspace waere dort mitgekommen.

     Die Absperrung steht HIER und nicht in `sichtbar()`: Es geht nicht
     darum, WELCHE Leads man sieht, sondern darum, dass es auf dieser
     Adresse ueberhaupt keine gibt. Eine gefilterte Liste waere eine
     Liste; 404 ist die Aussage, dass es den Bereich nicht gibt -- und
     sie gilt fuer alle acht Wege dieses Routers auf einmal, auch fuer
     die, die erst noch dazukommen. */
  if (person.haus === "crew") return res.status(404).json({ fehler: "nicht_gefunden" });
  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();
}

scoutRouter.use("/workspace/api/leads", angemeldet);

  /* Wessen Pipeline sieht diese Person?

     NUR DogFather sieht alle (01.09.2026). Ein Scout sieht seine
     eigenen Leads, ein Manager seine eigenen UND die der Scouts, die
     ihm zugeteilt sind: "er soll nur die Scouts sehen, die ihm
     zugeteilt sind."

     Vorher stand hier istLeitung() -- damit sah jeder Manager jeden
     Lead jedes Scouts. pipelineIds() steht in workspace.js und wird von
     drei Stellen benutzt (Liste, Suche, Hinweise); dieselbe Regel
     dreimal abgeschrieben waere dreimal Gelegenheit, sie einmal falsch
     zu aendern. */
function sichtbar(person) {
  if (siehtAlles(person)) return { wo: "1=1", werte: [] };
  const ids = pipelineIds(person);
  if (!ids.length) return { wo: "0=1", werte: [] };
  return { wo: `l.scout_id IN (${ids.map(() => "?").join(",")})`, werte: ids };
}

const SPALTEN = `
  l.id, l.name, l.plattform, l.handle, l.status, l.prioritaet,
  l.aktivitaet, l.potenzial, l.notizen, l.letzte_nachricht, l.naechster_followup,
  l.scout_id, l.erstellt, l.geaendert, l.uebergeben_am, l.creator_id,
  l.follower, l.land, l.woher, l.kontaktweg, l.live_zeiten, l.netzwerk, l.absage_grund,
  l.creator_art,
  ps.name AS scout_name, pc.name AS creator_name`;

const VERBUND = `
  FROM leads l
  LEFT JOIN personen ps ON ps.id = l.scout_id
  LEFT JOIN personen pc ON pc.id = l.creator_id`;

/* ---------- Liste ------------------------------------------------------- */

scoutRouter.get("/workspace/api/leads", (req, res) => {
  try {
    const { wo, werte } = sichtbar(req.sicht || req.person);
    /* ORTSZEIT (01.10.2026), nicht der UTC-Tag: Sonst gilt ein Lead
       nachts zwischen 00:00 und 02:00 als einen Tag juenger. */
    const heute = heuteLokal();
    res.json({
      stufen: STUFEN,
      /* Die Auswahllisten kommen MIT, damit die Oberflaeche keine
         eigenen fuehrt. Zwei Listen fuer dieselbe Auswahl waren im Haus
         schon mehrfach die Stelle, an der eine gepflegt wurde und die
         andere nicht -- zuletzt bei der Rollenwahl am 10.09. */
      laender: LAENDER, land_name: LAND_NAME,
      netzwerk: NETZWERK, netzwerk_name: NETZWERK_NAME,
      arten: ARTEN, art_name: ART_NAME,
      heute,
      /* `creator_art` wird hier schon aufgeloest (NULL -> "normal"),
         damit die Oberflaeche nicht ihre eigene Regel dafuer braucht --
         sie waere die zweite und wuerde irgendwann die andere sagen. */
      leads: db().prepare(`
        SELECT ${SPALTEN} ${VERBUND}
        WHERE ${wo}
        ORDER BY
          CASE l.status WHEN 'neu' THEN 0 WHEN 'angesprochen' THEN 1
                        WHEN 'gespraech' THEN 2 WHEN 'interessiert' THEN 3
                        WHEN 'uebergeben' THEN 4 ELSE 5 END,
          CASE l.prioritaet WHEN 'hoch' THEN 0 WHEN 'mittel' THEN 1 ELSE 2 END,
          CASE WHEN l.naechster_followup IS NULL THEN 1 ELSE 0 END,
          l.naechster_followup, l.id DESC`).all(...werte)
        .map((l) => ({ ...l, creator_art: artVon(l.creator_art) })),
    });
  } catch (fehler) {
    console.error("[workspace] Leads lesen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------- Prüfen ------------------------------------------------------- */

function pruefe(körper, { neu }) {
  const fehler = [];
  const aus = {};
  const text = (feld, max, pflicht = false) => {
    if (!neu && körper[feld] === undefined) return;
    const t = String(körper[feld] ?? "").trim();
    if (pflicht && t.length < 2) { fehler.push("Name fehlt."); return; }
    if (t.length > max) { fehler.push(`Feld ${feld} ist zu lang.`); return; }
    aus[feld] = t || null;
  };
  text("name", NAME_MAX, neu);
  text("plattform", 60);
  text("handle", 120);
  text("aktivitaet", TEXT_MAX);
  text("potenzial", TEXT_MAX);
  text("notizen", TEXT_MAX);

  if (körper.status !== undefined) {
    if (!Object.hasOwn(STUFEN, körper.status)) fehler.push("Unbekannte Stufe.");
    else aus.status = körper.status;
  }
  if (körper.prioritaet !== undefined) {
    if (!PRIORITAETEN.includes(körper.prioritaet)) fehler.push("Unbekannte Priorität.");
    else aus.prioritaet = körper.prioritaet;
  }
  /* ---- DIE SIEBEN NEUEN FELDER (11.09.2026) ----------------------------

     Jedes wird geprueft, keines wird geglaubt. Die drei mit fester
     Auswahl (Land, Netzwerk) gegen ihre Liste, die Zahl gegen ihre
     Grenzen, die Texte gegen ihre Laenge.

     WARUM `land` UND `netzwerk` EIGENE LISTEN HABEN UND KEINE FREITEXTE:
     Danach wird spaeter gefiltert und gezaehlt ("wie viele in der
     Schweiz", "wie viele sind noch frei"). Ein Freitext ergibt
     "Schweiz", "CH", "ch" und "Suisse" -- und damit vier Gruppen fuer
     ein Land. */
  text("woher", 80);
  text("kontaktweg", 80);
  text("live_zeiten", 200);
  text("absage_grund", TEXT_MAX);

  if (körper.land !== undefined) {
    const w = String(körper.land ?? "").trim();
    if (!w) aus.land = null;
    else if (!LAENDER.includes(w)) fehler.push("Unbekanntes Land.");
    else aus.land = w;
  }
  if (körper.netzwerk !== undefined) {
    const w = String(körper.netzwerk ?? "").trim();
    if (!w) aus.netzwerk = null;
    else if (!NETZWERK.includes(w)) fehler.push("Unbekannte Angabe zum Netzwerk.");
    else aus.netzwerk = w;
  }
  /* Normal oder Premium. Ein leerer Wert ist hier NICHT dasselbe wie bei
     Land und Netzwerk: Dort heisst leer "nicht angegeben" und wird als
     NULL gespeichert, hier gibt es keinen dritten Zustand -- leer faellt
     auf "normal" zurueck, so wie es die Spalte ohnehin liest. Ein
     erfundener Wert wird trotzdem abgelehnt und nicht stillschweigend
     zu "normal" gemacht: Wer "premiumm" schickt, hat sich vertippt und
     soll es erfahren, statt die Karte auf der falschen Seite zu finden. */
  if (körper.creator_art !== undefined) {
    const w = String(körper.creator_art ?? "").trim();
    if (!w) aus.creator_art = "normal";
    else if (!ARTEN.includes(w)) fehler.push("Unbekannte Creator-Art.");
    else aus.creator_art = w;
  }
  if (körper.follower !== undefined) {
    const roh = String(körper.follower ?? "").trim();
    if (!roh) aus.follower = null;
    else {
      /* Punkte und Leerzeichen fallen weg: Wer aus TikTok kopiert, hat
         "12.400" oder "12 400" in der Zwischenablage. Ein "k" oder "M"
         wird ausgerechnet -- sonst steht am Ende eine 12 statt 12000,
         und das faellt niemandem auf. */
      const m = /^([\d.,\s]+)\s*([kKmM]?)$/.exec(roh);
      const zahl = m ? Number(m[1].replace(/[.\s]/g, "").replace(",", ".")) : NaN;
      const faktor = m && /[kK]/.test(m[2]) ? 1000 : m && /[mM]/.test(m[2]) ? 1000000 : 1;
      const wert = Math.round(zahl * faktor);
      if (!Number.isFinite(wert) || wert < 0 || wert > 1000000000) {
        fehler.push("Follower-Zahl ist ungültig.");
      } else aus.follower = wert;
    }
  }

  for (const feld of ["letzte_nachricht", "naechster_followup"]) {
    if (körper[feld] === undefined) continue;
    const d = String(körper[feld] ?? "").trim();
    if (!d) { aus[feld] = null; continue; }
    if (!/^\d{4}-\d{2}-\d{2}$/.test(d) || Number.isNaN(Date.parse(d))) fehler.push("Datum ist ungültig.");
    else aus[feld] = d;
  }
  return { aus, fehler };
}

/* ---------- Anlegen und Ändern ------------------------------------------- */

scoutRouter.post("/workspace/api/leads", gleicheHerkunft, (req, res) => {
  try {
    const { aus, fehler } = pruefe(req.body || {}, { neu: true });
    if (fehler.length) return res.status(400).json({ fehler: fehler.join(" ") });

    /* Ein Scout legt immer in die eigene Pipeline. Das Management darf
       einen Lead einem Scout zuordnen. */
    let scoutId = req.person.id;
    if (istLeitung(req.person)) {
      const w = req.body?.scout_id;
      if (w) {
        const z = Number(w);
        if (!Number.isInteger(z) || z < 1) return res.status(400).json({ fehler: "Ungültige Zuordnung." });
        if (!db().prepare("SELECT 1 FROM personen WHERE id = ? AND rolle = 'scout'").get(z)) {
          return res.status(400).json({ fehler: "Scout existiert nicht." });
        }
        scoutId = z;
      } else scoutId = null;
    }

    const { lastInsertRowid } = db().prepare(`
      INSERT INTO leads
        (name, plattform, handle, status, prioritaet, aktivitaet, potenzial,
         notizen, letzte_nachricht, naechster_followup, scout_id, erstellt, erstellt_von,
         follower, land, woher, kontaktweg, live_zeiten, netzwerk, absage_grund,
         creator_art)
      VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)`).run(
      aus.name, aus.plattform ?? null, aus.handle ?? null,
      aus.status ?? "neu", aus.prioritaet ?? "mittel",
      aus.aktivitaet ?? null, aus.potenzial ?? null, aus.notizen ?? null,
      aus.letzte_nachricht ?? null, aus.naechster_followup ?? null,
      scoutId, jetzt(), req.person.id,
      aus.follower ?? null, aus.land ?? null, aus.woher ?? null,
      aus.kontaktweg ?? null, aus.live_zeiten ?? null, aus.netzwerk ?? null,
      aus.absage_grund ?? null, aus.creator_art ?? "normal");

    protokolliere("lead_angelegt", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `#${lastInsertRowid} ${aus.name}`.slice(0, 120),
    });
    res.status(201).json({ id: Number(lastInsertRowid) });
  } catch (fehler) {
    console.error("[workspace] Lead anlegen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

function holen(req, id) {
  const { wo, werte } = sichtbar(req.person);
  return db().prepare(`SELECT l.* ${VERBUND} WHERE ${wo} AND l.id = ?`).get(...werte, id);
}

scoutRouter.patch("/workspace/api/leads/:id", gleicheHerkunft, (req, res) => {
  try {
    const id = Number(req.params.id);
    if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });
    const lead = holen(req, id);
    if (!lead) return res.status(404).json({ fehler: "nicht_gefunden" });

    const { aus, fehler } = pruefe(req.body || {}, { neu: false });
    if (fehler.length) return res.status(400).json({ fehler: fehler.join(" ") });
    const felder = Object.keys(aus);
    if (!felder.length) return res.status(400).json({ fehler: "nichts_zu_aendern" });

    const setz = felder.map((f) => `${f} = ?`);
    const daten = felder.map((f) => aus[f]);
    /* Der Zeitpunkt der Uebergabe wird festgehalten -- er ist der
       Uebergang aus der Scout-Arbeit in die Betreuung. */
    if (aus.status === "uebergeben" && lead.status !== "uebergeben") {
      setz.push("uebergeben_am = ?"); daten.push(jetzt());
    }
    setz.push("geaendert = ?"); daten.push(jetzt());

    db().prepare(`UPDATE leads SET ${setz.join(", ")} WHERE id = ?`).run(...daten, id);
    protokolliere("lead_geaendert", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `#${id} ${felder.join(",")}`.slice(0, 120),
    });
    res.json({ ok: true });
  } catch (fehler) {
    console.error("[workspace] Lead ändern:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

scoutRouter.delete("/workspace/api/leads/:id", gleicheHerkunft, (req, res) => {
  try {
    const id = Number(req.params.id);
    if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });
    const lead = holen(req, id);
    if (!lead) return res.status(404).json({ fehler: "nicht_gefunden" });
    /* Ein übergebener Lead ist Teil der Betreuungsgeschichte -- den
       räumt nur das Management weg. */
    if (!istLeitung(req.person) && lead.status === "uebergeben") {
      return res.status(403).json({ fehler: "Übergebene Leads löscht nur DogFather." });
    }
    db().prepare("DELETE FROM leads WHERE id = ?").run(id);
    protokolliere("lead_geloescht", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `#${id} ${lead.name}`.slice(0, 120),
    });
    res.json({ ok: true });
  } catch (fehler) {
    console.error("[workspace] Lead löschen:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* ---------- Creator-Onboarding starten ------------------------------------
   "Übergabe: Infos vollständig, Gespräch dokumentiert, Termin setzen,
   Creator-Onboarding starten" (Deck, Seite 15). Aus einem übergebenen
   Lead entsteht hier eine echte Person mit Zugangscode -- der Code wird
   genau einmal zurückgegeben und danach nie wieder.                     */

scoutRouter.post("/workspace/api/leads/:id/onboarding", gleicheHerkunft, (req, res) => {
  try {
    if (!istLeitung(req.person)) return res.status(403).json({ fehler: "nicht_erlaubt" });
    const id = Number(req.params.id);
    if (!Number.isInteger(id)) return res.status(400).json({ fehler: "ungueltig" });

    const lead = holen(req, id);
    if (!lead) return res.status(404).json({ fehler: "nicht_gefunden" });
    if (lead.creator_id) return res.status(409).json({ fehler: "Für diesen Lead gibt es schon einen Creator." });
    if (lead.status !== "uebergeben") {
      return res.status(400).json({ fehler: "Erst übergeben, dann das Onboarding starten." });
    }

    const name = String(req.body?.name ?? lead.name).trim().slice(0, 60);
    if (name.length < 2) return res.status(400).json({ fehler: "Name fehlt." });
    if (db().prepare("SELECT 1 FROM personen WHERE lower(name) = lower(?) AND aktiv = 1").get(name)) {
      return res.status(409).json({ fehler: "Diesen Namen gibt es schon." });
    }

    const neu = personAnlegen(name, "creator", { ...req.person, ip: echteIp(req) });
    db().prepare("UPDATE leads SET creator_id = ?, geaendert = ? WHERE id = ?")
      .run(neu.id, jetzt(), id);

    /* DIE ART GEHT MIT (06.10.2026).

       Sonst endet die Angabe genau in dem Moment, in dem sie zum ersten
       Mal vertraglich zaehlt: Der Scout haelt fest, dass jemand als
       Premium geholt werden soll, das Onboarding legt die Person an --
       und am Creator steht es nirgends mehr. Ab hier ist es eine Angabe
       an der Person und laeuft dem Lead nicht mehr hinterher; geaendert
       wird sie danach in der Personenverwaltung. */
    db().prepare("UPDATE personen SET creator_art = ? WHERE id = ?")
      .run(artVon(lead.creator_art), neu.id);

    /* Die Angaben des Scouts wandern ins Creator-Profil -- sonst müsste
       das Management sie abtippen, obwohl sie längst da sind. */
    const handles = [lead.plattform, lead.handle].filter(Boolean).join(" · ") || null;
    if (handles || lead.potenzial || lead.aktivitaet) {
      db().prepare(`
        INSERT INTO profile (person_id, handles, nische, live_zeiten, geaendert, geaendert_von)
        VALUES (?,?,?,?,?,?)`).run(
        neu.id, handles, lead.potenzial ?? null, lead.aktivitaet ?? null,
        jetzt(), req.person.id);
    }

    /* Wer jemanden gefunden hat, betreut ihn weiter -- das ist der
       ganze Sinn der Uebergabe. Das Management kann die Zustaendigkeit
       jederzeit umhaengen. */
    if (lead.scout_id) {
      betreuungSetzen(neu.id, lead.scout_id, { ...req.person, ip: echteIp(req) });
    }

    protokolliere("onboarding_gestartet", {
      personId: req.person.id, rolle: req.person.rolle, ip: echteIp(req),
      detail: `Lead #${id} -> Creator ${name}`.slice(0, 120),
    });
    res.status(201).json({ id: neu.id, name: neu.name, rolle: neu.rolle, code: neu.code });
  } catch (fehler) {
    console.error("[workspace] Onboarding:", fehler?.message);
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});

/* Scout-Liste für die Zuordnung durch das Management. */
scoutRouter.get("/workspace/api/leads-scouts", angemeldet, (req, res) => {
  try {
    if (!istLeitung(req.person)) {
      return res.json({ scouts: [{ id: req.person.id, name: req.person.name }] });
    }
    res.json({
      scouts: db().prepare(
        "SELECT id, name FROM personen WHERE rolle = 'scout' AND aktiv = 1 ORDER BY name").all(),
    });
  } catch {
    res.status(503).json({ fehler: "nicht_verfuegbar" });
  }
});