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",
};
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,
  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,
      heute,
      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),
    });
  } 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;
  }
  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)
      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);

    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 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" });
  }
});