HiveGrid Marketing: Hub mit Strategie, Redaktionsplan, Dashboard, Produktionsvorgaben und Webinar

Stand 16.10.2026. Enthält das Marketing-Dashboard, die Daten in daten/,
die Produktionsvorgaben, Reels und das Webinar mit Skript, Sprechzettel
und Präsentation (HTML, PowerPoint, PDF).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
dejanandClaude Opus 5.5 committed 2026-10-16 18:09:07 +02:00
commit 686ee36b4f
490 files changed
+53846

No files matched your search

+183
View File
@@ -0,0 +1,183 @@
// Dokumente: alle Markdown-Dateien im Hub lesen und durchsuchen.
import { S } from "../app.js";
import { esc, md, slug, dokLink, zeitstempel } from "../hilfen.js";
const STANDARD = "Brainstorming Kickoff/Strategie/Content-Strategie.md";
// Reihenfolge der Ordner in der Liste: das, was man täglich braucht, zuerst.
const ORDNER = [
["Brainstorming Kickoff/Strategie", "Strategie"],
["webinar", "Webinar"],
["webinar/01-crm-marketing-vertrieb", "Webinar: CRM"],
["webinar/02-automation", "Webinar: Automation"],
["webinar/03-drumherum", "Webinar: Drumherum"],
["webinar/04-ueberraschung", "Webinar: Überraschung"],
["webinar/slides", "Webinar: Slides"],
["Ressourcen", "Ressourcen"],
["Ressourcen/Reel-Analyse", "Reel-Analyse"],
["Ressourcen/Reel-Analyse/analysen", "Reel-Analysen"],
["Brainstorming Kickoff/Kontext", "Kontext"],
["Brainstorming Kickoff/Research", "Recherche"],
["Brainstorming Kickoff", "Brainstorming Kickoff"],
["", "Hub"],
];
let suche = { begriff: "", treffer: [], laeuft: null };
const textCache = new Map();
async function dokText(pfad) {
const eintrag = S.dokumente.find((d) => d.pfad === pfad);
const zeit = eintrag?.zeit;
const alt = textCache.get(pfad);
if (alt && alt.zeit === zeit) return alt.text;
const r = await fetch("/" + pfad.split("/").map(encodeURIComponent).join("/"), { cache: "no-store" });
if (!r.ok) throw new Error(`${pfad} nicht gefunden`);
const text = await r.text();
textCache.set(pfad, { zeit, text });
return text;
}
// Kurze Titel für die Liste. "HiveGrid: " fällt weg, und bei Recherche und
// Auswertungen sagt der Ordner schon, worum es geht.
// Aus "Recherche zum Marketing-Brainstorming: Übersicht" wird "Übersicht".
const kurzTitel = (titel) => titel.replace(/^HiveGrid:\s*/, "").replace(/^(Recherche[^:]*|Auswertung):\s*/, "");
function liste(aktiv) {
if (suche.begriff.length >= 2) {
const n = suche.treffer.length;
const muster = new RegExp(suche.begriff.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "gi");
return `<div class="klein" style="margin-bottom:6px">${n >= 300 ? "Über 300" : n} Treffer</div>
${suche.treffer.map((t) => `<a class="treffer" href="${dokLink(t.pfad, `?q=${encodeURIComponent(suche.begriff)}`)}">
<b>${esc(kurzTitel(t.titel))}</b>${t.ueberschrift ? `<span class="klein" style="display:block">${esc(t.ueberschrift)}</span>` : ""}${esc(t.text).replace(muster, (m) => `<mark>${m}</mark>`)}</a>`).join("")}`;
}
const gruppen = new Map(ORDNER.map(([o]) => [o, []]));
for (const d of S.dokumente) {
if (!gruppen.has(d.ordner)) gruppen.set(d.ordner, []);
gruppen.get(d.ordner).push(d);
}
return [...gruppen.entries()].filter(([, l]) => l.length).map(([ordner, l]) => {
const name = (ORDNER.find(([o]) => o === ordner) || [, ordner.split("/").at(-1)])[1];
return `<div class="dok-ordner">${esc(name)}</div>${l.map((d) =>
`<a class="dok-link ${d.pfad === aktiv ? "aktiv" : ""}" href="${dokLink(d.pfad)}">${esc(kurzTitel(d.titel))}</a>`).join("")}`;
}).join("");
}
// Relative Links zwischen Markdown-Dateien bleiben im Dashboard.
function linksUmbiegen(wurzel, pfad) {
const basis = pfad.split("/").slice(0, -1);
wurzel.querySelectorAll("a[href]").forEach((a) => {
const href = a.getAttribute("href");
if (/^(https?:|mailto:|#)/.test(href)) {
if (/^https?:/.test(href)) { a.target = "_blank"; a.rel = "noopener"; }
return;
}
const [ziel, anker] = href.split("#");
const teile = [...basis];
for (const t of decodeURIComponent(ziel).split("/")) {
if (t === "..") teile.pop();
else if (t && t !== ".") teile.push(t);
}
const voll = teile.join("/");
if (voll.endsWith(".md")) a.setAttribute("href", dokLink(voll, anker ? `?abschnitt=${encodeURIComponent(anker)}` : ""));
else a.setAttribute("href", "/" + teile.map(encodeURIComponent).join("/"));
});
}
function markieren(wurzel, begriff) {
if (!begriff) return null;
const quelle = esc(begriff).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
// Ohne "g" zum Prüfen: ein globaler Ausdruck merkt sich die letzte Stelle
// und würde jeden zweiten Treffer überspringen.
const pruefen = new RegExp(begriff.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), "i");
const gaenger = document.createTreeWalker(wurzel, NodeFilter.SHOW_TEXT);
const knoten = [];
while (gaenger.nextNode()) if (pruefen.test(gaenger.currentNode.nodeValue)) knoten.push(gaenger.currentNode);
let erster = null;
for (const k of knoten) {
const span = document.createElement("span");
span.innerHTML = esc(k.nodeValue).replace(new RegExp(quelle, "gi"), (m) => `<mark class="fund">${m}</mark>`);
k.replaceWith(span);
erster = erster || span.querySelector("mark");
}
return erster;
}
export async function zeichnen(main, r) {
const pfad = r.rest.join("/") || STANDARD;
const abschnitt = r.query.get("abschnitt");
const q = r.query.get("q");
const eintrag = S.dokumente.find((d) => d.pfad === pfad);
main.innerHTML = `
<div class="dok-rahmen">
<div class="block dok-liste">
<input type="search" id="dok-suche" placeholder="In allen Dokumenten suchen" value="${esc(suche.begriff)}" autocomplete="off">
<div id="dok-liste">${liste(pfad)}</div>
</div>
<article class="block dok-inhalt">
<div class="springe"><span class="pfad">${esc(pfad)}${eintrag ? `, geändert am ${zeitstempel(eintrag.zeit)}` : ""}</span><span id="springe"></span></div>
<div class="md" id="dok-text"><p class="muted">Lade</p></div>
</article>
</div>`;
const eingabe = main.querySelector("#dok-suche");
eingabe.oninput = () => {
clearTimeout(suche.laeuft);
suche.laeuft = setTimeout(async () => {
suche.begriff = eingabe.value.trim();
suche.treffer = suche.begriff.length >= 2
? await fetch(`/api/suche?q=${encodeURIComponent(suche.begriff)}`).then((x) => x.json()).catch(() => [])
: [];
main.querySelector("#dok-liste").innerHTML = liste(pfad);
}, 220);
};
eingabe.onkeydown = (e) => {
if (e.key === "Escape") { eingabe.value = ""; eingabe.oninput(); e.stopPropagation(); }
};
const ziel = main.querySelector("#dok-text");
let text;
try {
text = await dokText(pfad);
} catch (e) {
ziel.innerHTML = `<p>${esc(e.message)}</p>`;
return;
}
ziel.innerHTML = md(text);
ziel.querySelectorAll("table").forEach((t) => {
const rahmen = document.createElement("div");
rahmen.className = "tabelle-rahmen";
t.replaceWith(rahmen);
rahmen.appendChild(t);
});
linksUmbiegen(ziel, pfad);
const vergeben = new Set();
const ueberschriften = [...ziel.querySelectorAll("h2, h3")];
for (const h of ziel.querySelectorAll("h1, h2, h3, h4")) {
let id = slug(h.textContent);
while (vergeben.has(id)) id += "-1";
vergeben.add(id);
h.id = id;
}
const kapitel = ueberschriften.filter((h) => h.tagName === "H2");
if (kapitel.length > 2) {
const springe = main.querySelector("#springe");
springe.innerHTML = `<select aria-label="Springe zu"><option value="">Springe zu Abschnitt</option>${kapitel.map((h) =>
`<option value="${h.id}">${esc(h.textContent)}</option>`).join("")}</select>`;
const sel = springe.querySelector("select");
sel.onchange = () => {
document.getElementById(sel.value)?.scrollIntoView({ behavior: "smooth", block: "start" });
sel.value = "";
};
}
let sprung = null;
if (abschnitt) {
const a = abschnitt.toLowerCase();
sprung = [...ziel.querySelectorAll("h1, h2, h3, h4")].find((h) => h.id === slug(abschnitt) || h.textContent.trim().toLowerCase().startsWith(a));
}
if (q) sprung = markieren(ziel, q) || sprung;
if (sprung) requestAnimationFrame(() => sprung.scrollIntoView({ block: q ? "center" : "start" }));
}
+139
View File
@@ -0,0 +1,139 @@
// Formate: Übersicht aus der Formatbibliothek, mit Nutzung im Redaktionsplan.
import { S, schublade } from "../app.js";
import { heute, kurzDatum, esc, md, mdInline, ohneMd, codes, dokLink, pille, FUNNEL_NAME } from "../hilfen.js";
const QUELLE = "Ressourcen/Formatbibliothek.md";
let cache = { zeit: null, daten: null };
// Liest die Formatbibliothek: die Übersichtstabelle und die Abschnitte je Format.
export async function formatbibliothek() {
const zeit = S.stand?.dokumente;
if (cache.daten && cache.zeit === zeit) return cache.daten;
const text = await fetch("/" + QUELLE.split("/").map(encodeURIComponent).join("/"), { cache: "no-store" }).then((r) => r.text());
const abschnitte = {};
const teile = text.split(/^## /m);
const vorspann = teile.shift();
for (const t of teile) {
const kopf = t.slice(0, t.indexOf("\n"));
const rumpf = t.slice(t.indexOf("\n") + 1);
const m = kopf.match(/^(F\d{1,2}b?)\s/);
abschnitte[m ? m[1] : kopf.trim()] = { titel: kopf.trim(), rumpf };
}
const uebersicht = [];
const tabelle = (abschnitte["Übersicht"]?.rumpf || "").split("\n").filter((z) => /^\|\s*F\d/.test(z));
for (const z of tabelle) {
const [code, name, herkunft, aufwand, konto, laenge, start] = z.split("|").slice(1, -1).map((x) => x.trim());
uebersicht.push({ code, name, herkunft, aufwand, konto, laenge, start });
}
cache = { zeit, daten: { vorspann, abschnitte, uebersicht } };
return cache.daten;
}
function nutzung(code) {
return S.slots.filter((s) => codes(s.format).includes(code) && s.status !== "ausgefallen");
}
// Wie das Format für Noah heißt, welche Funnel-Stufe es hat und wie das Thema darin vorkommt.
const planFormat = (code) => S.plan.formate.find((f) => f.kuerzel === code) || S.plan.linkedin.find((l) => l.kuerzel === code);
const noahName = (code) => planFormat(code)?.noah_name || "";
const funnelZelle = (code) => (planFormat(code)?.funnel ? `<span class="fu fu-${planFormat(code).funnel}">${FUNNEL_NAME[planFormat(code).funnel]}</span>` : "");
function imPlan(code, h) {
const im = nutzung(code);
const naechst = im.find((s) => s.datum >= h);
if (!im.length) return `<span class="muted">nicht im Plan</span>`;
return `${im.length} Mal${naechst ? `<span class="klein" style="display:block;white-space:nowrap">ab ${kurzDatum(naechst.datum)}</span>` : ""}`;
}
export async function zeichnen(main, r) {
const h = heute();
const fb = await formatbibliothek();
const liste = [...fb.uebersicht];
// CH steht nur im Redaktionsplan, nicht in der Formatbibliothek.
for (const f of S.plan.formate) {
if (!liste.some((x) => x.code === f.kuerzel)) {
liste.push({ code: f.kuerzel, name: f.name, aufwand: f.aufwand === "mittel" ? "2" : f.aufwand === "leicht" ? "1" : "3", konto: "HiveGrid", start: "laut Redaktionsplan" });
}
}
const allgemein = fb.abschnitte["Was für alle Reel-Formate gilt"];
const imPlanListe = liste.filter((f) => nutzung(f.code).length);
const rest = liste.filter((f) => !nutzung(f.code).length);
const aufwandText = (a) => ({ "1": "leicht", "2": "mittel", "3": "hoch", "1 bis 2": "leicht bis mittel" }[String(a)] || String(a));
const zeile = (f, mitPlan) => `<tr class="klickbar" data-format="${esc(f.code)}">
<td style="width:56px" class="code">${esc(f.code)}</td>
<td><b>${esc(f.name)}</b>${noahName(f.code) ? `<span class="klein" style="display:block">Für Noah: ${esc(noahName(f.code))}</span>` : ""}</td>
<td>${funnelZelle(f.code)}</td><td>${esc(aufwandText(f.aufwand))}</td><td>${esc(f.konto || "")}</td>
${mitPlan ? `<td style="white-space:nowrap">${imPlan(f.code, h)}</td>` : `<td>${esc(f.start || "")}</td>`}
</tr>`;
main.innerHTML = `
<header class="seitenkopf">
<div><h1>Formate</h1><div class="unter">Ein Format ist eine wiederholbare Bauform. Alle Formate tragen dasselbe Thema.</div>
<div class="thema">Thema: <b>${esc(S.plan.thema.name)}</b></div></div>
<a class="knopf" href="${dokLink(QUELLE)}">Formatbibliothek lesen</a>
</header>
<section class="block"><h2>Im Plan <span class="neben">${imPlanListe.length} Formate, zum Öffnen anklicken</span></h2>
<div class="tab"><table class="daten">
<thead><tr><th></th><th>Format</th><th>Funnel</th><th>Aufwand</th><th>Konto</th><th>Im Plan</th></tr></thead>
<tbody>${imPlanListe.map((f) => zeile(f, true)).join("")}</tbody></table></div>
</section>
<section class="block">
<details><summary>${rest.length} weitere Formate, noch nicht im Plan</summary>
<div class="tab" style="margin-top:10px"><table class="daten">
<thead><tr><th></th><th>Format</th><th>Funnel</th><th>Aufwand</th><th>Konto</th><th>Start</th></tr></thead>
<tbody>${rest.map((f) => zeile(f, false)).join("")}</tbody></table></div>
</details>
</section>
${S.plan.ideen?.length ? `<section class="block"><h2>Ideen-Pool zum Thema <span class="neben">nicht fest im Plan, für Ausfälle und nach T5</span></h2>
<div class="tab"><table class="daten">
<thead><tr><th>Idee</th><th>Funnel</th><th>Aufwand</th><th>Baut auf</th></tr></thead>
<tbody>${S.plan.ideen.map((i) => `<tr>
<td><b>${esc(i.name)}</b><span class="klein" style="display:block">${esc(i.text)}</span></td>
<td><span class="fu fu-${esc(i.funnel)}">${FUNNEL_NAME[i.funnel] || ""}</span></td>
<td>${esc(i.aufwand)}</td>
<td class="klein">${esc([i.aus === "neu" ? "neu" : i.aus, i.vorbild].filter(Boolean).join(", "))}</td></tr>`).join("")}</tbody></table></div>
</section>` : ""}
<div class="raster r-2">
<section class="block"><h2>LinkedIn-Postarten <span class="neben">Text und Bild</span></h2>
${S.plan.linkedin.map((l) => `<div class="zeile" style="grid-template-columns:40px 1fr auto">
<span class="code">${esc(l.kuerzel)}</span><span><b>${esc(l.name)}</b>
<details><summary>Was dahinter steckt</summary><span class="klein" style="display:block;margin-top:6px">${mdInline(l.text)}</span></details></span>
<span class="klein" style="white-space:nowrap">${nutzung(l.kuerzel).length} Mal</span></div>`).join("")}
</section>
<section class="block"><h2>Blickwinkel <span class="neben">auf das eine Thema</span></h2>
${S.plan.saeulen.map((s) => `<div class="zeile" style="grid-template-columns:40px 1fr auto">
<span class="code">${esc(s.kuerzel)}</span><span><b>${esc(s.name)}</b><span class="klein" style="display:block">${esc(s.text || "")}</span></span>
<span class="klein">${S.slots.filter((x) => x.saeule === s.kuerzel).length} Slots</span></div>`).join("")}
</section>
</div>
${allgemein ? `<section class="block"><details><summary>${esc(allgemein.titel)}</summary><div class="md" style="margin-top:10px">${md(allgemein.rumpf)}</div></details></section>` : ""}
<p class="klein">Woher die Formate kommen: <a href="${dokLink("Ressourcen/Reel-Analyse/analysen/2026-10-05-inspo-liste-dejan.md")}">Analyse der Inspo-Reels</a>.</p>
`;
main.querySelectorAll("[data-format]").forEach((tr) => {
tr.onclick = () => { location.hash = `#/formate/${encodeURIComponent(tr.dataset.format)}`; };
});
const code = r.rest[0];
if (!code) return;
const abschnitt = fb.abschnitte[code];
const eintrag = liste.find((f) => f.code === code);
const im = nutzung(code);
schublade(`
<div class="ueber">Format</div>
<h2>${esc(abschnitt ? abschnitt.titel : `${code} ${eintrag?.name || ""}`)}</h2>
<div class="unter">${eintrag ? [`Aufwand ${esc(eintrag.aufwand)}`, eintrag.konto && esc(eintrag.konto), eintrag.laenge && esc(eintrag.laenge)].filter(Boolean).join(", ") + "." : ""}</div>
<dl class="felder">
<dt>Im Plan</dt><dd>${im.length ? im.map((s) =>
`<a href="#/plan/${esc(s.id)}">${kurzDatum(s.datum)}, ${esc(ohneMd(s.format))}</a>${s.status !== "geplant" ? ` ${pille(s.status)}` : ""}`).join("<br>") : `<span class="muted">nicht im festen Plan</span>`}</dd>
${planFormat(code)?.funnel ? `<dt>Funnel</dt><dd>${funnelZelle(code)}</dd>` : ""}
${planFormat(code)?.thema ? `<dt>Im Thema</dt><dd>${esc(planFormat(code).thema)}</dd>` : ""}
${noahName(code) ? `<dt>Für Noah</dt><dd>${esc(noahName(code))}</dd>` : ""}
</dl>
<div class="md" style="margin-top:18px">${abschnitt ? md(abschnitt.rumpf) : `<p class="muted">In der Formatbibliothek gibt es dazu keinen eigenen Abschnitt.</p>`}</div>
`, { zurueck: "#/formate", breit: true });
}
+413
View File
@@ -0,0 +1,413 @@
// Redaktionsplan als Kalender oder Liste, mit Filtern und einer Schublade je Slot.
import { S, schublade, statusSetzen, meldung } from "../app.js";
import {
heute, plus, montag, kw, ttmm, wt, kurzDatum, langDatum, spanne, abstand,
esc, mdInline, ohneMd, codes, kanalBadges, art, ART_NAME, KANAL_FILTER, SLOT_STATUS, pille,
funnel, funnelMix, funnelBalken, FUNNEL_NAME,
} from "../hilfen.js";
const SPEICHER = "hg-plan-2";
const zustand = { ansicht: "kalender", kanal: "alle", saeule: "alle", funnel: "alle", roadmap: false };
try { Object.assign(zustand, JSON.parse(localStorage.getItem(SPEICHER) || "{}")); } catch { /* egal */ }
const merken = () => { try { localStorage.setItem(SPEICHER, JSON.stringify(zustand)); } catch { /* egal */ } };
function sichtbar(s) {
if (zustand.kanal !== "alle" && !s.kanaele.includes(zustand.kanal)) return false;
if (zustand.saeule !== "alle" && s.saeule !== zustand.saeule) return false;
if (zustand.funnel !== "alle" && funnel(s, S.plan) !== zustand.funnel) return false;
return true;
}
const amTag = (s, d) => s.datum === d || (s.bis && s.datum <= d && s.bis >= d);
function eintrag(s) {
return `<button class="e ${art(s)} ${s.wichtig ? "wichtig" : ""} st-${esc(s.status)}" data-slot="${esc(s.id)}"
title="${esc(ohneMd(s.format))}${s.notiz ? ": " + esc(ohneMd(s.notiz)) : ""}">
<span class="f">${esc(ohneMd(s.format))}</span>
<span class="u">${funnel(s, S.plan) ? `<span class="fu fu-${funnel(s, S.plan)}">${FUNNEL_NAME[funnel(s, S.plan)]}</span>` : "<span></span>"}${s.status !== "geplant" ? `<span class="s">${esc(s.status)}</span>` : ""}</span>
</button>`;
}
function roadmapEintraege(d) {
if (!zustand.roadmap) return "";
const faellig = S.schritte.filter((s) => s.faellig === d && s.status !== "später" && s.status !== "entfällt");
if (!faellig.length) return "";
if (faellig.length > 2) {
const fertig = faellig.filter((s) => s.status === "erledigt").length;
return `<a class="e roadmap" href="#/roadmap" title="${esc(faellig.map((s) => s.id + " " + s.kurz).join("\n"))}">
${faellig.length} Roadmap-Schritte fällig, ${fertig} erledigt</a>`;
}
return faellig.map((s) => `<a class="e roadmap" href="#/roadmap" title="${esc(ohneMd(s.text))}">
${esc(s.id)} ${esc(s.kurz)}${s.status === "erledigt" ? ", erledigt" : ""}</a>`).join("");
}
// ---------------------------------------------------------------- Kalender
function kalender(h) {
const phasen = S.plan.phasen;
const erster = phasen[0].von;
const startM = montag(plus(erster, -7));
const letzte = S.plan.pausen.length ? S.plan.pausen.at(-1).bis : phasen.at(-1).bis;
const spaetester = S.slots.length ? S.slots.at(-1).datum : letzte;
const endeM = montag(spaetester > letzte ? spaetester : letzte);
const vorbereitung = S.roadmap.zeitstrahl.find((z) => z.von <= startM && z.bis >= startM);
let html = `<div class="kal-kopf"><div></div>${["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"].map((t) => `<div>${t}</div>`).join("")}</div>`;
let block = null;
for (let m = startM; m <= endeM; m = plus(m, 7)) {
const so = plus(m, 6);
const phase = phasen.find((p) => m >= p.von && m <= p.bis);
const pause = S.plan.pausen.find((p) => m >= montag(p.von) && m <= p.bis);
const neu = phase ? `p${phase.nr}` : pause ? "pause" : m < erster ? "vor" : "nach";
if (neu !== block) {
block = neu;
if (phase) html += `<div class="kal-phase"><b>Phase ${phase.nr}, ${esc(phase.name)}</b><span class="klein">${spanne(phase.von, phase.bis)}</span><span class="klein phase-zusatz">${esc(phase.text)}</span></div>`;
else if (pause) html += `<div class="kal-phase"><b>${esc(pause.titel)}</b><span class="klein">${spanne(pause.von, pause.bis)}</span><span class="klein phase-zusatz">${esc(pause.text)}</span></div>`;
else if (neu === "vor") html += `<div class="kal-phase"><b>Vorbereitung</b><span class="klein">${vorbereitung ? esc(ohneMd(vorbereitung.text).replace(/^Vorbereitung:\s*/, "")) : "Kanäle anlegen"}</span></div>`;
else html += `<div class="kal-phase"><b>Nach dem Plan</b></div>`;
}
const info = S.plan.wochen.find((w) => w.kw === kw(m)) || {};
const diese = h >= m && h <= so;
if (pause) {
html += `<div class="kal-woche ${diese ? "diese" : ""}"><div class="kal-kw"><div class="nr">KW ${kw(m)}</div><div class="klein">${spanne(m, so)}</div></div>
<div class="kal-tag" style="grid-column:2 / -1"><span class="muted">${esc(pause.titel)}</span>${tageMitSlots(m)}</div></div>`;
continue;
}
html += `<div class="kal-woche ${diese ? "diese" : ""}"><div class="kal-kw"><div class="nr">KW ${kw(m)}</div>
<div class="klein">${spanne(m, so)}</div>${info.titel ? `<div class="titel">${esc(info.titel)}</div>` : ""}</div>`;
for (let i = 0; i < 7; i++) {
const d = plus(m, i);
const slots = S.slots.filter((s) => amTag(s, d) && sichtbar(s));
html += `<div class="kal-tag ${i > 4 ? "we" : ""} ${d === h ? "heute" : ""} ${d < h ? "vorbei" : ""}">
<div class="dnr">${ttmm(d)}${d === h ? " heute" : ""}</div>${slots.map(eintrag).join("")}${roadmapEintraege(d)}</div>`;
}
html += `</div>`;
}
if (S.plan.ausblick) {
const a = S.plan.ausblick;
html += `<div class="kal-phase"><b>${esc(a.titel)}</b><span class="klein">${a.punkte.map((p) => esc(p)).join(" ")}</span></div>`;
}
return `<div class="kalender">${html}</div>`;
}
// In einer Pausenwoche stehen keine festen Slots. Falls doch einer dort landet, nicht verschlucken.
function tageMitSlots(m) {
const slots = S.slots.filter((s) => s.datum >= m && s.datum <= plus(m, 6) && sichtbar(s));
return slots.length ? `<div style="margin-top:8px;max-width:320px">${slots.map(eintrag).join("")}</div>` : "";
}
// ---------------------------------------------------------------- Liste
function tabelle(slots, h) {
return `<div class="tab"><table class="daten">
<thead><tr><th>Datum</th><th>Format</th><th>Kanäle</th><th>Blickwinkel</th><th>Funnel</th><th>Notiz</th><th>Status</th></tr></thead>
<tbody>${slots.map((s) => `<tr class="klickbar ${s.datum < h ? "vorbei" : ""} ${amTag(s, h) ? "heute" : ""}" data-slot="${esc(s.id)}">
<td class="datum ${s.wichtig ? "wichtig" : ""}">${s.bis ? `${kurzDatum(s.datum)} bis ${kurzDatum(s.bis)}` : kurzDatum(s.datum)}</td>
<td><span class="art ${art(s)}"></span>${mdInline(s.format)}</td>
<td>${kanalBadges(s.kanaele)}</td>
<td>${esc(S.plan.saeulen.find((x) => x.kuerzel === s.saeule)?.name || s.saeule)}</td>
<td>${funnel(s, S.plan) ? `<span class="fu fu-${funnel(s, S.plan)}">${FUNNEL_NAME[funnel(s, S.plan)]}</span>` : ""}</td>
<td>${mdInline(s.notiz)}</td>
<td>${pille(s.status)}</td>
</tr>`).join("")}</tbody></table></div>`;
}
function wochen(slots, h) {
const nach = new Map();
for (const s of slots) {
const m = montag(s.datum);
if (!nach.has(m)) nach.set(m, []);
nach.get(m).push(s);
}
return [...nach.entries()].map(([m, liste]) => {
const info = S.plan.wochen.find((w) => w.kw === kw(m)) || {};
return `<div class="zwischentitel">KW ${kw(m)}${info.titel ? `, ${esc(info.titel)}` : ""}<span class="klein">${spanne(m, plus(m, 6))}</span></div>
${info.text ? `<p class="phase-text">${esc(info.text)}</p>` : ""}${tabelle(liste, h)}`;
}).join("");
}
function liste(h) {
const slots = S.slots.filter(sichtbar);
const vergeben = new Set();
let html = "";
S.plan.phasen.forEach((p) => {
const drin = slots.filter((s) => s.datum >= p.von && s.datum <= p.bis);
drin.forEach((s) => vergeben.add(s.id));
html += `<section class="block"><h2 class="phase-titel">Phase ${p.nr}, ${esc(p.name)}<span class="klein">${spanne(p.von, p.bis)}</span></h2>
<p class="phase-text">${esc(p.text)}</p>${wochen(drin, h) || `<div class="leer">Keine Slots mit diesem Filter.</div>`}</section>`;
});
const rest = slots.filter((s) => !vergeben.has(s.id));
if (rest.length) html += `<section class="block"><h2 class="phase-titel">Weitere Slots</h2>${wochen(rest, h)}</section>`;
for (const p of S.plan.pausen) html += `<section class="block"><h2 class="phase-titel">${esc(p.titel)}<span class="klein">${spanne(p.von, p.bis)}</span></h2><p class="phase-text">${esc(p.text)}</p></section>`;
if (S.plan.ausblick) {
const a = S.plan.ausblick;
html += `<section class="block"><h2 class="phase-titel">${esc(a.titel)}</h2>${a.punkte.map((p) => `<p class="phase-text" style="margin:0">${mdInline(p)}</p>`).join("")}</section>`;
}
return html;
}
// ---------------------------------------------------------------- Schublade
function naechsterWerktag(d) {
let x = plus(d, 1);
while (["Sa", "So"].includes(wt(x))) x = plus(x, 1);
return x;
}
function formatText(code) {
const f = S.plan.formate.find((x) => x.kuerzel === code);
const l = S.plan.linkedin.find((x) => x.kuerzel === code);
if (l) return `<p><b>${esc(code)} ${esc(l.name)}</b></p><p class="klein">${mdInline(l.text)}</p>`;
if (f) return `<p><b>${esc(code)}</b> ${esc(f.name)}</p><p class="klein">Aufwand ${esc(f.aufwand)}. <a href="#/formate/${encodeURIComponent(code)}">In der Formatbibliothek lesen</a></p>`;
return `<p><a href="#/formate/${encodeURIComponent(code)}">${esc(code)} in der Formatbibliothek lesen</a></p>`;
}
function slotSchublade(s, h) {
const phase = S.plan.phasen.find((p) => s.datum >= p.von && s.datum <= p.bis);
const info = S.plan.wochen.find((w) => w.kw === kw(s.datum)) || {};
const saeule = S.plan.saeulen.find((x) => x.kuerzel === s.saeule);
const reihe = S.slots.filter(sichtbar);
const i = reihe.findIndex((x) => x.id === s.id);
const vor = i > 0 ? reihe[i - 1] : null;
const nach = i >= 0 && i < reihe.length - 1 ? reihe[i + 1] : null;
// L1 nimmt das Carousel der Vorwoche. Die Notiz nennt das Datum, daraus wird ein Link.
let grundlage = "";
const vom = s.notiz.match(/Carousel vom (\d{2})\.(\d{2})\./);
if (vom) {
const quelle = S.slots.find((x) => x.datum.endsWith(`-${vom[2]}-${vom[1]}`) && art(x) === "carousel");
if (quelle) grundlage = `<dt>Grundlage</dt><dd><a href="#/plan/${esc(quelle.id)}">${kurzDatum(quelle.datum)}, ${esc(ohneMd(quelle.format))}</a> ${pille(quelle.status)}</dd>`;
}
// Umgekehrt: wird dieses Carousel später als L1 verwertet?
let verwertet = "";
if (art(s) === "carousel") {
const nutzer = S.slots.filter((x) => x.notiz.includes(`Carousel vom ${ttmm(s.datum)}`));
if (nutzer.length) verwertet = `<dt>Wiederverwertet</dt><dd>${nutzer.map((x) => `<a href="#/plan/${esc(x.id)}">${kurzDatum(x.datum)}, ${esc(ohneMd(x.format))}</a>`).join("<br>")}</dd>`;
}
const zeiten = [...new Set(s.kanaele.map((k) => S.plan.uhrzeiten?.[k] ? `${k === "LinkedIn" ? "LinkedIn" : "Instagram und Co."} um ${S.plan.uhrzeiten[k]}` : null).filter(Boolean))];
schublade(`
<div class="ueber">KW ${kw(s.datum)}${info.titel ? `, ${esc(info.titel)}` : ""}${phase ? `. Phase ${phase.nr}, ${esc(phase.name)}` : ""}</div>
<h2>${esc(ohneMd(s.format))}</h2>
<div class="unter">${langDatum(s.datum)}${s.bis ? ` bis ${langDatum(s.bis)}` : ""}, ${abstand(h, s.datum)}. ${ART_NAME[art(s)]}.</div>
<dl class="felder">
<dt>Status</dt><dd><div class="schalter">${SLOT_STATUS.map((st) => `<button data-status="${st}" class="${s.status === st ? "an" : ""}">${st}</button>`).join("")}</div></dd>
<dt>Kanäle</dt><dd>${esc(s.kanaele.join(", "))}${zeiten.length ? `<span class="klein">${esc(zeiten.join(", "))}</span>` : ""}</dd>
${codes(s.format).length ? `<dt>Format</dt><dd>${codes(s.format).map(formatText).join("")}</dd>` : ""}
${s.saeule ? `<dt>Blickwinkel</dt><dd>${saeule ? `<b>${esc(saeule.name)}</b><span class="klein">${esc(saeule.text)}</span>` : esc(s.saeule === "offen" ? "Meister oder Nerds, je nach Trend, immer im Thema" : s.saeule)}</dd>` : ""}
${funnel(s, S.plan) ? `<dt>Funnel</dt><dd><span class="fu fu-${funnel(s, S.plan)}">${FUNNEL_NAME[funnel(s, S.plan)]}</span><span class="klein">${esc(S.plan.funnel.stufen.find((x) => x.id === funnel(s, S.plan))?.text || "")}</span></dd>` : ""}
${s.notiz ? `<dt>Notiz</dt><dd>${mdInline(s.notiz)}</dd>` : ""}
${s.noah ? `<dt>Für Noah</dt><dd>${esc(s.noah)}</dd>` : ""}
${grundlage}${verwertet}
<dt>Kennung</dt><dd><span class="kennung">${esc(s.id)}</span><span class="klein">Zum Ändern Claude sagen, zum Beispiel „Schieb ${esc(s.id)} auf ${kurzDatum(naechsterWerktag(s.datum))}“</span></dd>
</dl>
<div class="blaettern">
${vor ? `<a href="#/plan/${esc(vor.id)}">Vorher: ${kurzDatum(vor.datum)}</a>` : "<span></span>"}
${nach ? `<a href="#/plan/${esc(nach.id)}">Danach: ${kurzDatum(nach.datum)}</a>` : ""}
</div>
`, { zurueck: "#/plan" }).querySelectorAll("[data-status]").forEach((b) => {
b.onclick = () => statusSetzen("redaktionsplan", s.id, b.dataset.status);
});
}
// ---------------------------------------------------------------- Funnel
// Mix je Phase und gesamt, mit der Zielspanne für Top (Vorgabe Noah).
function funnelBlock() {
const p = S.plan;
const ziel = p.funnel.ziel_top;
// Noahs Vorgabe gilt für die Reels. Der Mix aller Beiträge steht klein daneben.
const posts = (von, bis) => S.slots.filter((s) => s.datum >= von && s.datum <= bis);
const reels = (liste) => liste.filter((s) => art(s) === "reel");
const zeilen = [
...p.phasen.map((ph) => [`Phase ${ph.nr}`, posts(ph.von, ph.bis)]),
["Gesamt", S.slots],
];
return `<section class="block funnel-block">
<h2>Funnel der Reels <span class="neben">${esc(p.funnel.ziel_text)}</span></h2>
${zeilen.map(([name, liste]) => {
const m = funnelMix(reels(liste), p);
const alle = funnelMix(liste, p);
return `<div class="fzeile ${m.top < ziel[0] || m.top > ziel[1] ? "daneben" : ""}">
<span class="fname">${esc(name)}</span>${funnelBalken(m, ziel)}
<span class="fwerte"><b>Top ${m.top} %</b>, Middle ${m.middle} %, Bottom ${m.bottom} %
<span class="klein" style="display:block">alle Beiträge: Top ${alle.top} %, Middle ${alle.middle} %, Bottom ${alle.bottom} %</span></span></div>`;
}).join("")}
<div class="legende" style="margin-top:8px">${p.funnel.stufen.map((f) => `<span><span class="fu fu-${f.id}">${esc(f.name)}</span> ${esc(f.kurz || "")}</span>`).join("")}</div>
</section>`;
}
// ---------------------------------------------------------------- Export
// Was Noah immer wieder will: der Plan für einen Zeitraum, ohne Codes,
// interne Termine und Säulen. Der Server baut die Datei und legt sie in
// den Downloads-Ordner.
const ausfuhr = { von: null, bis: null, format: "pdf", ideen: false, ergebnis: null, laeuft: false };
function vorlagen(h) {
const m = montag(h);
const posts = S.slots.filter((s) => !s.kanaele.includes("intern"));
return [
["Diese Woche", m, plus(m, 6)],
["Nächste Woche", plus(m, 7), plus(m, 13)],
["Nächste 2 Wochen", plus(m, 7), plus(m, 20)],
["Nächste 4 Wochen", plus(m, 7), plus(m, 34)],
["Ganzer Plan", posts[0]?.datum || m, S.plan.phasen.at(-1).bis],
];
}
function imZeitraum(von, bis) {
return S.slots.filter((s) => !s.kanaele.includes("intern") && s.status !== "ausgefallen" && (s.bis || s.datum) >= von && s.datum <= bis);
}
function exportSchublade(h) {
const v = vorlagen(h);
if (!ausfuhr.von) [, ausfuhr.von, ausfuhr.bis] = v[2];
const gueltig = ausfuhr.von && ausfuhr.bis && ausfuhr.von <= ausfuhr.bis;
const drin = gueltig ? imZeitraum(ausfuhr.von, ausfuhr.bis) : [];
const wochen = [...new Set(drin.map((s) => kw(s.datum)))];
const el = schublade(`
<div class="ueber">Redaktionsplan</div>
<h2>Exportieren</h2>
<div class="unter">Für Noah: welcher Content wann auf welchen Kanälen kommt. Ohne Codes, interne Termine und Säulen.</div>
<dl class="felder">
<dt>Zeitraum</dt><dd>
<div class="schalter">${v.map(([name, a, b], i) => `<button data-vorlage="${i}" class="${ausfuhr.von === a && ausfuhr.bis === b ? "an" : ""}">${esc(name)}</button>`).join("")}</div>
<div class="datumfelder">
<label>von <input type="date" id="ex-von" value="${esc(ausfuhr.von)}"></label>
<label>bis <input type="date" id="ex-bis" value="${esc(ausfuhr.bis)}"></label>
</div>
</dd>
<dt>Enthält</dt><dd>${!gueltig ? `<span style="color:var(--rot)">Das Ende liegt vor dem Anfang.</span>`
: drin.length ? `<b>${drin.length} ${drin.length === 1 ? "Beitrag" : "Beiträge"}</b><span class="klein">${wochen.length > 1 ? `KW ${wochen[0]} bis KW ${wochen.at(-1)}` : `KW ${wochen[0]}`}, ${kurzDatum(drin[0].datum)} bis ${kurzDatum(drin.at(-1).datum)}</span>`
: `<span class="muted">Kein Beitrag in diesem Zeitraum.</span>`}</dd>
<dt>Format</dt><dd><div class="schalter">${[["pdf", "PDF"], ["html", "HTML"], ["md", "Markdown"]].map(([w, t]) =>
`<button data-format="${w}" class="${ausfuhr.format === w ? "an" : ""}">${t}</button>`).join("")}</div></dd>
<dt>Dazu</dt><dd><label class="kreuz"><input type="checkbox" id="ex-ideen" ${ausfuhr.ideen ? "checked" : ""}> Weitere Ideen zum Thema anhängen</label>
<span class="klein">${S.plan.ideen?.length || 0} Ideen aus dem Pool, mit Funnel</span></dd>
</dl>
<div class="ausfuehren">
<button class="knopf voll" id="ex-los" ${!gueltig || ausfuhr.laeuft ? "disabled" : ""}>${ausfuhr.laeuft ? "Wird gebaut" : "Exportieren"}</button>
<span class="klein">Landet in deinem Downloads-Ordner.</span>
</div>
${ausfuhr.ergebnis ? `<div class="ergebnis">
<div><b>Gespeichert</b><span class="klein">${esc(ausfuhr.ergebnis.name)}</span></div>
<div class="ergebnis-knoepfe"><button class="knopf" data-oeffnen>Öffnen</button><button class="knopf" data-zeigen>Im Finder zeigen</button></div>
</div>` : ""}
`, { zurueck: "#/plan" });
const neu = () => { ausfuhr.ergebnis = null; exportSchublade(h); };
el.querySelectorAll("[data-vorlage]").forEach((b) => {
b.onclick = () => { [, ausfuhr.von, ausfuhr.bis] = v[Number(b.dataset.vorlage)]; neu(); };
});
el.querySelector("#ex-von").onchange = (e) => { ausfuhr.von = e.target.value; neu(); };
el.querySelector("#ex-bis").onchange = (e) => { ausfuhr.bis = e.target.value; neu(); };
el.querySelectorAll("[data-format]").forEach((b) => {
b.onclick = () => { ausfuhr.format = b.dataset.format; neu(); };
});
el.querySelector("#ex-ideen").onchange = (e) => { ausfuhr.ideen = e.target.checked; neu(); };
el.querySelector("#ex-los").onclick = async () => {
ausfuhr.laeuft = true;
ausfuhr.ergebnis = null;
exportSchublade(h);
try {
const r = await fetch("/api/export", {
method: "POST", headers: { "Content-Type": "application/json" },
body: JSON.stringify({ von: ausfuhr.von, bis: ausfuhr.bis, format: ausfuhr.format, ideen: ausfuhr.ideen }),
});
const j = await r.json();
if (!r.ok || !j.ok) throw new Error(j.fehler || `Fehler ${r.status}`);
ausfuhr.ergebnis = j;
meldung("Export gespeichert");
} catch (e) {
meldung(`Export fehlgeschlagen: ${e.message}`, true);
}
ausfuhr.laeuft = false;
if (location.hash === "#/plan/export") exportSchublade(h);
};
const oeffnen = (zeigen) => fetch("/api/oeffnen", {
method: "POST", headers: { "Content-Type": "application/json" },
body: JSON.stringify({ pfad: ausfuhr.ergebnis.pfad, zeigen }),
});
el.querySelector("[data-oeffnen]")?.addEventListener("click", () => oeffnen(false));
el.querySelector("[data-zeigen]")?.addEventListener("click", () => oeffnen(true));
}
// ---------------------------------------------------------------- Seite
export function zeichnen(main, r, { erstesMal } = {}) {
const h = heute();
const p = S.plan;
const erster = S.slots.find((s) => !s.kanaele.includes("intern"));
const ende = p.phasen.at(-1).bis;
const anzahl = S.slots.filter((s) => !s.kanaele.includes("intern")).length;
main.innerHTML = `
<header class="seitenkopf">
<div><h1>Redaktionsplan</h1>
<div class="unter">${erster ? ttmm(erster.datum) : ""} bis ${ttmm(ende)}${ende.slice(0, 4)}, ${anzahl} Beiträge. ${esc(p.status)} vom ${ttmm(p.stand)}${p.stand.slice(0, 4)}.</div>
<div class="thema">Thema: <b>${esc(p.thema.name)}</b></div></div>
<div style="display:flex;gap:12px;align-items:center">
<div class="schalter">
<button data-ansicht="kalender" class="${zustand.ansicht === "kalender" ? "an" : ""}">Kalender</button>
<button data-ansicht="liste" class="${zustand.ansicht === "liste" ? "an" : ""}">Liste</button>
</div>
<a class="knopf voll" href="#/plan/export">Exportieren</a>
</div>
</header>
<div class="schalterleiste">
<label class="auswahl">Kanal <select data-wahl="kanal">${KANAL_FILTER.map(([w, t]) => `<option value="${esc(w)}" ${zustand.kanal === w ? "selected" : ""}>${esc(t)}</option>`).join("")}</select></label>
<label class="auswahl">Blickwinkel <select data-wahl="saeule"><option value="alle">Alle</option>${p.saeulen.map((s) => `<option value="${esc(s.kuerzel)}" ${zustand.saeule === s.kuerzel ? "selected" : ""}>${esc(s.name)}</option>`).join("")}</select></label>
<label class="auswahl">Funnel <select data-wahl="funnel"><option value="alle">Alle</option>${p.funnel.stufen.map((f) => `<option value="${f.id}" ${zustand.funnel === f.id ? "selected" : ""}>${esc(f.name)}</option>`).join("")}</select></label>
${zustand.ansicht === "kalender" ? `<label class="kreuz"><input type="checkbox" data-roadmap ${zustand.roadmap ? "checked" : ""}> Roadmap-Termine</label>` : ""}
<div class="legende" style="margin-left:auto">
${["carousel", "reel", "linkedin", "story"].map((a) => `<span><span class="art ${a}"></span>${ART_NAME[a]}</span>`).join("")}
</div>
</div>
${funnelBlock()}
${zustand.ansicht === "kalender" ? kalender(h) : liste(h)}
<section class="block" id="flex"><h2>Flex-Slots <span class="neben">hängen von anderen ab und erscheinen, wenn sie fertig sind</span></h2>
<div class="tab"><table class="daten"><thead><tr><th>Flex-Slot</th><th>Von wem</th><th>Wenn er kommt</th></tr></thead><tbody>
${p.flex.map((f) => `<tr><td><b>${esc(f.name)}</b>${f.erschienen?.length ? `<span class="klein" style="display:block">bisher ${f.erschienen.map(ttmm).join(", ")}</span>` : ""}</td>
<td>${esc(f.von)}</td><td>${mdInline(f.dann)}</td></tr>`).join("")}
</tbody></table></div></section>
<section class="block" id="tests"><h2>Entscheidungen und Tests</h2>
<div class="tab"><table class="daten"><thead><tr><th>Wann</th><th>Test</th><th>Frage</th><th>Grundlage</th><th>Ergebnis</th></tr></thead><tbody>
${p.tests.map((t) => `<tr class="${t.termine.length && t.termine.at(-1) < h ? "vorbei" : ""}">
<td class="datum">${t.termine.length ? t.termine.map((d, i) => (i ? ttmm(d) : kurzDatum(d))).join(", ") : esc(t.wann || "offen")}</td>
<td><b>${t.id.startsWith("T") ? esc(t.id) + " " : ""}${esc(t.titel)}</b></td>
<td>${esc(t.frage)}</td><td class="klein">${esc(t.grundlage)}</td><td>${t.ergebnis ? mdInline(t.ergebnis) : `<span class="muted">offen</span>`}</td></tr>`).join("")}
</tbody></table></div></section>
`;
main.querySelectorAll("[data-ansicht]").forEach((b) => {
b.onclick = () => { zustand.ansicht = b.dataset.ansicht; merken(); zeichnen(main, r); };
});
main.querySelectorAll("select[data-wahl]").forEach((sel) => {
sel.onchange = () => { zustand[sel.dataset.wahl] = sel.value; merken(); zeichnen(main, r); };
});
const rm = main.querySelector("[data-roadmap]");
if (rm) rm.onchange = () => { zustand.roadmap = rm.checked; merken(); zeichnen(main, r); };
main.querySelectorAll("[data-slot]").forEach((el) => {
el.onclick = () => { location.hash = `#/plan/${el.dataset.slot}`; };
});
if (r.rest[0] === "export") exportSchublade(h);
const slot = r.rest[0] && S.slots.find((s) => s.id === r.rest[0]);
if (slot) {
main.querySelectorAll(`[data-slot="${slot.id}"]`).forEach((el) => el.classList.add("ausgewaehlt"));
slotSchublade(slot, h);
}
// Beim ersten Öffnen zur laufenden Woche springen, wenn sie weiter unten liegt.
if (erstesMal) {
const teil = r.query.get("teil");
const ziel = teil ? main.querySelector(`#${CSS.escape(teil)}`) : !slot && zustand.ansicht === "kalender" ? main.querySelector(".kal-woche.diese") : null;
if (ziel && (teil || ziel.getBoundingClientRect().top > window.innerHeight * 0.6)) {
requestAnimationFrame(() => ziel.scrollIntoView({ block: teil ? "start" : "center" }));
}
}
}
+114
View File
@@ -0,0 +1,114 @@
// Roadmap: Zeitstrahl, Arbeitspakete, Status je Schritt.
import { S, statusSetzen } from "../app.js";
import {
heute, plus, tag, ttmm, kurzDatum, MON_KURZ,
esc, mdInline, ohneMd, zustaendig, istOffen, SCHRITT_STATUS, dokLink,
} from "../hilfen.js";
const SPEICHER = "hg-roadmap";
const zustand = { person: "alle", status: "alle" };
try { Object.assign(zustand, JSON.parse(localStorage.getItem(SPEICHER) || "{}")); } catch { /* egal */ }
const merken = () => { try { localStorage.setItem(SPEICHER, JSON.stringify(zustand)); } catch { /* egal */ } };
const ROADMAP_MD = "Brainstorming Kickoff/Strategie/Roadmap.md";
function passt(s) {
if (zustand.person !== "alle" && !zustaendig(s, zustand.person)) return false;
if (zustand.status === "offen" && !istOffen(s)) return false;
if (zustand.status === "erledigt" && s.status !== "erledigt") return false;
if (zustand.status === "später" && s.status !== "später") return false;
return true;
}
function zeitstrahl(h) {
const eintraege = S.roadmap.zeitstrahl;
const von = eintraege[0].von.slice(0, 8) + "01";
const ende = eintraege.at(-1).bis;
const bis = plus(`${ende.slice(0, 7)}-01`, 32).slice(0, 8) + "01";
const gesamt = tag(bis) - tag(von);
const pos = (d) => Math.max(0, Math.min(100, ((tag(d) - tag(von)) / gesamt) * 100));
const monate = [];
for (let d = von; d < bis; d = plus(`${d.slice(0, 7)}-01`, 32).slice(0, 8) + "01") {
const m = Number(d.slice(5, 7)) - 1;
monate.push(`<span style="left:${pos(d)}%">${MON_KURZ[m]}${m === 0 ? " " + d.slice(0, 4) : ""}</span>`);
}
const zeilen = eintraege.map((z) => {
const a = pos(z.von);
const e = pos(plus(z.bis, 1));
const klasse = z.offen ? "offen" : h > z.bis ? "vorbei" : h >= z.von ? "jetzt" : "";
const text = ohneMd(z.text);
// Text rechts neben den Balken, außer der Balken reicht schon weit nach rechts.
const textStil = e < 60 ? `left:${e}%;max-width:${100 - e}%` : `right:${100 - a}%;max-width:${a}%;text-align:right;padding-left:0;padding-right:8px`;
return `<div class="zs-zeile"><div class="wann">${esc(ohneMd(z.wann))}</div>
<div class="zs-bahn"><div class="zs-balken ${klasse}" style="left:${a}%;width:${Math.max(e - a, 0.6)}%" title="${esc(text)}"></div>
<div class="zs-text" style="${textStil};overflow:hidden;text-overflow:ellipsis" title="${esc(text)}">${esc(text)}</div></div></div>`;
}).join("");
const heuteLinie = h >= von && h < bis
? `<div class="zs-heute-linie" style="left:calc(170px + (100% - 170px) * ${pos(h) / 100})" title="heute"></div>` : "";
return `<section class="block"><h2>Zeitstrahl</h2><div class="zs-rahmen"><div class="zs-skala">${monate.join("")}</div>${zeilen}${heuteLinie}</div></section>`;
}
const ABSCHNITT = { A: "A.", B1: "B1.", C: "C.", D: "D.", E: "E.", F: "F.", G: "G.", H: "H." };
function paket(p, h) {
const schritte = p.schritte.filter(passt);
if (!schritte.length) return "";
const zaehlen = p.schritte.filter((s) => s.status !== "entfällt");
const fertig = zaehlen.filter((s) => s.status === "erledigt").length;
const anteil = zaehlen.length ? Math.round((fertig / zaehlen.length) * 100) : 0;
return `<section class="block paket">
<h2><span><span class="pid">${esc(p.id)}</span>${esc(p.titel)}</span>
<a class="neben" href="${dokLink(ROADMAP_MD, `?abschnitt=${encodeURIComponent(ABSCHNITT[p.id] || p.id)}`)}">im Dokument</a></h2>
<div class="paket-unter"><span>${fertig} von ${zaehlen.length} erledigt</span><span class="balken"><span style="width:${anteil}%"></span></span></div>
${schritte.map((s) => {
const ueber = istOffen(s) && s.faellig && s.faellig < h && !s.wiederkehrend;
return `<div class="schritt ${esc(s.status)}">
<input type="checkbox" data-haken="${esc(s.id)}" ${s.status === "erledigt" ? "checked" : ""} title="erledigt">
<div class="sid">${esc(s.id)}</div>
<div><div class="kurz">${esc(s.kurz)}</div>
<details><summary>Details${s.abhaengig ? `, braucht ${esc(s.abhaengig)}` : ""}</summary><div class="lang">${mdInline(s.text)}${s.voraussetzung ? ` <span class="muted">Voraussetzung: ${esc(s.voraussetzung)}.</span>` : ""}</div></details></div>
<div class="wer">${esc(s.wer || "")}</div>
<div class="wann ${ueber ? "ueberfaellig" : ""}">${s.faellig ? kurzDatum(s.faellig) : esc(s.wann || "")}${s.wiederkehrend ? `<span class="klein" style="display:block">wiederkehrend</span>` : ""}</div>
<select data-status="${esc(s.id)}" aria-label="Status">${SCHRITT_STATUS.map((st) => `<option ${st === s.status ? "selected" : ""}>${st}</option>`).join("")}</select>
</div>`;
}).join("")}
</section>`;
}
export function zeichnen(main) {
const h = heute();
const r = S.roadmap;
const personen = ["alle", ...r.personen.map((p) => p.name)];
const schalter = (gruppe, wert, text) =>
`<button class="${zustand[gruppe] === wert ? "an" : ""}" data-gruppe="${gruppe}" data-wert="${esc(wert)}">${esc(text)}</button>`;
const alle = S.schritte;
const offenZahl = alle.filter(istOffen).length;
const fertigZahl = alle.filter((s) => s.status === "erledigt").length;
const pakete = r.pakete.map((p) => paket(p, h)).join("");
main.innerHTML = `
<header class="seitenkopf">
<div><h1>Roadmap</h1>
<div class="unter">${offenZahl} offen, ${fertigZahl} erledigt. ${esc(r.status)} vom ${ttmm(r.stand)}${r.stand.slice(0, 4)}.</div></div>
<a class="knopf" href="${dokLink(ROADMAP_MD)}">Roadmap.md lesen</a>
</header>
${zeitstrahl(h)}
<div class="schalterleiste">
<div class="schalter"><span class="lbl">Wer</span>${personen.map((p) => schalter("person", p, p === "alle" ? "Alle" : p)).join("")}</div>
<div class="schalter"><span class="lbl">Status</span>${[["alle", "Alle"], ["offen", "offen"], ["erledigt", "erledigt"], ["später", "später"]].map(([w, t]) => schalter("status", w, t)).join("")}</div>
</div>
${pakete || `<div class="leer">Keine Schritte mit diesem Filter.</div>`}
`;
main.querySelectorAll("[data-gruppe]").forEach((b) => {
b.onclick = () => { zustand[b.dataset.gruppe] = b.dataset.wert; merken(); zeichnen(main); };
});
main.querySelectorAll("[data-haken]").forEach((box) => {
box.onchange = () => statusSetzen("roadmap", box.dataset.haken, box.checked ? "erledigt" : "offen");
});
main.querySelectorAll("select[data-status]").forEach((sel) => {
sel.onchange = () => statusSetzen("roadmap", sel.dataset.status, sel.value);
});
}
+172
View File
@@ -0,0 +1,172 @@
// Übersicht: was diese Woche ansteht, was als Nächstes kommt, was offen ist.
import { S, statusSetzen } from "../app.js";
import {
heute, plus, montag, kw, ttmm, wt, kurzDatum, tageZwischen, abstand,
esc, mdInline, ohneMd, kanalBadges, art, pille, zustaendig, istOffen, verlaufSvg,
WT_LANG, MONATE, tag,
} from "../hilfen.js";
export function aktuellePhase(h) {
const phasen = S.plan.phasen;
const p = phasen.find((x) => h >= x.von && h <= x.bis);
if (p) return `Phase ${p.nr}, ${p.name}`;
if (h < phasen[0].von) return "Vorbereitung";
const pause = S.plan.pausen.find((x) => h >= x.von && h <= x.bis);
if (pause) return pause.titel;
return "nach dem Plan";
}
const istPost = (s) => !s.kanaele.includes("intern");
function slotZeile(s) {
return `<a class="e ${art(s)} ${s.wichtig ? "wichtig" : ""} st-${esc(s.status)}" href="#/plan/${esc(s.id)}">
<span class="f">${esc(ohneMd(s.format))}</span>
<span class="u">${s.status !== "geplant" ? `<span class="s">${esc(s.status)}</span>` : ""}</span>
</a>`;
}
function aufgabe(s) {
return `<label class="aufgabe" title="${esc(ohneMd(s.text))}">
<input type="checkbox" data-schritt="${esc(s.id)}" ${s.status === "erledigt" ? "checked" : ""}>
<span class="id">${esc(s.id)}</span>
<span class="was">${esc(s.kurz)}</span>
<span class="wer">${esc(s.wer)}</span>
</label>`;
}
// Viele Schritte an einem Tag: die ersten vier zeigen, den Rest zum Aufklappen.
function aufgaben(schritte) {
if (schritte.length <= 5) return schritte.map(aufgabe).join("");
return schritte.slice(0, 4).map(aufgabe).join("") +
`<details><summary>${schritte.length - 4} weitere Schritte</summary>${schritte.slice(4).map(aufgabe).join("")}</details>`;
}
export function zeichnen(main) {
const h = heute();
const d = tag(h);
const posts = S.slots.filter(istPost);
// Zähler: vor dem ersten Beitrag zählt der Start, danach der nächste Beitrag.
const erschienen = posts.some((s) => s.status === "erschienen");
const naechster = posts.find((s) => s.datum >= h && s.status !== "erschienen" && s.status !== "ausgefallen");
let zaehler = `<div class="zaehler"><span>Kein Beitrag mehr im Plan.</span></div>`;
if (naechster) {
const n = tageZwischen(h, naechster.datum);
const erst = !erschienen && naechster === posts[0];
const was = `<a href="#/plan/${esc(naechster.id)}">${kurzDatum(naechster.datum)}, ${esc(ohneMd(naechster.format))}</a>`;
zaehler = n === 0
? `<div class="zaehler"><b>Heute</b><span>${erst ? "erscheint der erste Beitrag" : "erscheint"}:<br>${was}</span></div>`
: `<div class="zaehler"><b>${n}</b><span>${n === 1 ? "Tag" : "Tage"} bis zum ${erst ? "ersten" : "nächsten"} Beitrag<br>${was}</span></div>`;
}
// Überfälliges
const ueberfaellig = S.schritte.filter((s) => istOffen(s) && s.faellig && s.faellig < h && !s.wiederkehrend);
const unmarkiert = posts.filter((s) => s.datum < h && (s.status === "geplant" || s.status === "fertig"));
let warnung = "";
if (ueberfaellig.length || unmarkiert.length) {
warnung = `<section class="block warnung" style="margin-bottom:34px"><h2>Offen geblieben</h2>
${ueberfaellig.length ? `<div class="zeile" style="grid-template-columns:150px 1fr"><span>Roadmap, über dem Termin</span><span>${ueberfaellig.map((s) => `${esc(s.id)} ${esc(s.kurz)}`).join(", ")}</span></div>` : ""}
${unmarkiert.length ? `<div class="zeile" style="grid-template-columns:150px 1fr"><span>Beiträge ohne Status</span><span>${unmarkiert.map((s) => `<a href="#/plan/${esc(s.id)}">${kurzDatum(s.datum)}</a>`).join(", ")}</span></div>` : ""}
</section>`;
}
// Diese Woche, Tag für Tag
const m = montag(h);
const tage = [];
for (let i = 0; i < 7; i++) {
const t = plus(m, i);
const slots = S.slots.filter((s) => s.datum === t || (s.bis && s.datum < t && s.bis >= t));
const schritte = S.schritte.filter((s) => s.faellig === t && s.status !== "später" && s.status !== "entfällt");
if (!slots.length && !schritte.length && t !== h) continue;
tage.push(`<div class="zeile tagzeile ${t === h ? "heute" : ""} ${t < h ? "vorbei" : ""}">
<div class="datum">${wt(t)} ${ttmm(t)}<span class="klein">${t === h ? "heute" : abstand(h, t)}</span></div>
<div>${slots.map(slotZeile).join("")}${aufgaben(schritte)}${!slots.length && !schritte.length ? `<span class="muted">Nichts geplant.</span>` : ""}</div>
</div>`);
}
// Als Nächstes
const kommende = posts.filter((s) => s.datum >= h && s.status !== "ausgefallen" && s.status !== "erschienen").slice(0, 7);
const naechste = kommende.map((s) => `<a class="zeile naechst ${s.wichtig ? "wichtig" : ""}" href="#/plan/${esc(s.id)}">
<span class="datum">${kurzDatum(s.datum)}</span>
<span><span class="art ${art(s)}"></span><b>${esc(ohneMd(s.format))}</b>${s.notiz ? `<span class="klein notiz">${mdInline(s.notiz)}</span>` : ""}</span>
${kanalBadges(s.kanaele)}
</a>`).join("");
// Entscheidungen
const tests = S.plan.tests.map((t) => ({ ...t, naechst: t.termine.find((x) => x >= h) || null }))
.filter((t) => t.naechst || !t.termine.length)
.sort((a, b) => (a.naechst || "9999").localeCompare(b.naechst || "9999"));
const testsHtml = tests.map((t) => `<div class="zeile" style="grid-template-columns:76px 1fr">
<span class="datum">${t.naechst ? kurzDatum(t.naechst) : "offen"}<span class="klein">${t.naechst ? abstand(h, t.naechst) : esc(t.wann || "")}</span></span>
<span><b>${t.id.startsWith("T") ? esc(t.id) + " " : ""}${esc(t.titel)}</b><span class="klein" style="display:block">${esc(t.frage)}</span>
${t.ergebnis ? `<span class="klein" style="display:block">Ergebnis: ${mdInline(t.ergebnis)}</span>` : ""}</span>
</div>`).join("");
// Kanäle
const kanaeleHtml = S.kanaele.kanaele.map((k) => `<div class="zeile" style="grid-template-columns:1fr auto">
<span>${k.url ? `<a href="${esc(k.url)}" target="_blank" rel="noopener"><b>${esc(k.name)}</b></a>` : `<b>${esc(k.name)}</b>`}
<span class="klein" style="display:block">${esc(k.notiz)}${k.schritt && k.status !== "aktiv" ? `, Schritt ${esc(k.schritt)}` : ""}${k.metricool ? ", in Metricool" : ""}</span></span>
${pille(k.status)}
</div>`).join("");
// Instagram
const verlauf = S.kanaele.follower_instagram;
const letzter = verlauf.at(-1);
const ns = S.kanaele.nordstern;
const instaHtml = letzter ? `<div style="display:flex;align-items:baseline;gap:12px;margin-top:4px">
<span class="gross">${letzter.wert}</span><span class="klein">Follower, ${letzter.wert - verlauf[0].wert} mehr als am ${ttmm(verlauf[0].datum)}</span></div>
${verlaufSvg(verlauf)}
<div class="klein">Stand ${ttmm(letzter.datum)}, aus Metricool.</div>
<div class="klein" style="margin-top:12px;padding-top:10px;border-top:1px solid var(--linie-2)"><b style="color:var(--tinte)">Nordstern:</b> ${esc(ns.name)}. ${ns.ziel ? `Ziel ${esc(ns.ziel)} pro Monat.` : esc(ns.hinweis)}</div>` : `<div class="leer">Noch keine Zahlen.</div>`;
// Roadmap je Paket
const roadmapHtml = S.roadmap.pakete.map((p) => {
const zaehlen = p.schritte.filter((s) => s.status !== "entfällt");
const fertig = zaehlen.filter((s) => s.status === "erledigt").length;
const anteil = zaehlen.length ? Math.round((fertig / zaehlen.length) * 100) : 0;
return `<a class="zeile" href="#/roadmap" style="grid-template-columns:28px 1fr 64px;text-decoration:none">
<span class="id">${esc(p.id)}</span>
<span><span style="display:block;overflow:hidden;text-overflow:ellipsis;white-space:nowrap">${esc(p.titel)}</span><span class="balken" style="display:block;margin-top:5px"><span style="width:${anteil}%"></span></span></span>
<span class="klein" style="text-align:right">${fertig} von ${zaehlen.length}</span>
</a>`;
}).join("");
// Wer ist dran
const personenHtml = S.roadmap.personen.map((p) => {
const eigene = S.schritte.filter((s) => istOffen(s) && zustaendig(s, p.name));
const n = eigene.filter((s) => s.faellig).sort((a, b) => a.faellig.localeCompare(b.faellig))[0];
return `<div class="zeile" style="grid-template-columns:70px 1fr 28px">
<b>${esc(p.name)}</b>
<span class="klein">${n ? `${esc(n.id)} ${esc(n.kurz)}, ${kurzDatum(n.faellig)}` : esc(p.zusatz || "nichts mit Termin")}</span>
<span style="text-align:right;font-weight:700">${eigene.length}</span>
</div>`;
}).join("");
main.innerHTML = `
<header class="seitenkopf">
<div><div class="ueber">KW ${kw(h)}, ${esc(aktuellePhase(h))}</div>
<h1>${WT_LANG[d.getUTCDay()]}, ${d.getUTCDate()}. ${MONATE[d.getUTCMonth()]}</h1>
<div class="thema">Thema: <b>${esc(S.plan.thema.name)}</b></div></div>
${zaehler}
</header>
${warnung}
<div class="raster r-2-1">
<section class="block"><h2>Diese Woche <span class="neben">KW ${kw(h)}, ${ttmm(m)} bis ${ttmm(plus(m, 6))}</span></h2>${tage.join("")}</section>
<section class="block"><h2>Als Nächstes <a class="neben" href="#/plan">Redaktionsplan</a></h2>${naechste || `<div class="leer">Nichts mehr geplant.</div>`}</section>
</div>
<div class="raster r-3">
<section class="block"><h2>Entscheidungen</h2>${testsHtml || `<div class="leer">Keine offenen.</div>`}</section>
<section class="block"><h2>Kanäle</h2>${kanaeleHtml}</section>
<section class="block"><h2>Instagram <span class="neben">hivegrid.de</span></h2>${instaHtml}</section>
</div>
<div class="raster r-2">
<section class="block"><h2>Roadmap <a class="neben" href="#/roadmap">alle Schritte</a></h2>${roadmapHtml}</section>
<section class="block"><h2>Wer ist dran <span class="neben">offene Schritte</span></h2>${personenHtml}</section>
</div>
`;
main.querySelectorAll("[data-schritt]").forEach((box) => {
box.onchange = () => statusSetzen("roadmap", box.dataset.schritt, box.checked ? "erledigt" : "offen");
});
}
+122
View File
@@ -0,0 +1,122 @@
// Webinar: Stand, Unterlagen, Ablauf und alle Slides auf einen Blick.
//
// Stand, Unterlagen und Ablauf stehen in daten/webinar.json. Die Slides kommen
// direkt aus webinar/slides: Reihenfolge und Teile aus quelle/deck.json, die
// Titel aus den Slide-Dateien, die Bilder aus export/ (npm run export).
import { S } from "../app.js";
import { esc, langDatum, dokLink, pille } from "../hilfen.js";
const SLIDES = "/webinar/slides";
const url = (pfad) => "/" + pfad.split("/").map(encodeURIComponent).join("/");
// Reihenfolge, Teile und Titel der Slides. Fehlt etwas, bleibt der Block leer
// statt die ganze Seite zu stören.
async function deckLesen() {
try {
const deck = await fetch(`${SLIDES}/quelle/deck.json`, { cache: "no-store" }).then((r) => r.json());
const leser = new DOMParser();
const titel = await Promise.all(deck.order.map(async (id) => {
const html = await fetch(`${SLIDES}/quelle/slides/${id}.html`, { cache: "no-store" }).then((r) => r.text()).catch(() => "");
const doc = leser.parseFromString(html, "text/html");
doc.querySelectorAll("aside").forEach((a) => a.remove());
return (doc.querySelector("h1, h2")?.textContent || id).replace(/\s+/g, " ").trim();
}));
const starts = Object.values(deck.sections || {}).map((s) => [s.start, s.description]);
const folien = deck.order.map((id, i) => ({ id, nr: i + 1, titel: titel[i] }));
return { folien, teile: starts };
} catch {
return { folien: [], teile: [] };
}
}
function unterlage(u) {
const knoepfe = [];
if (u.art === "ansehen") knoepfe.push(`<a class="knopf" href="${url(u.pfad)}" target="_blank" rel="noopener">Ansehen</a>`);
if (u.art === "laden") knoepfe.push(`<a class="knopf" href="${url(u.pfad)}" download>Herunterladen</a>`);
if (u.art === "extern") knoepfe.push(`<a class="knopf" href="${esc(u.pfad)}" target="_blank" rel="noopener">Öffnen</a>`);
if (u.art === "dok") knoepfe.push(`<a class="knopf" href="${dokLink(u.pfad)}">Lesen</a>`);
if (u.pdf) knoepfe.push(`<a class="knopf" href="${url(u.pdf)}" target="_blank" rel="noopener">PDF</a>`);
return `<div class="zeile unterlage">
<span><b>${esc(u.name)}</b><span class="klein" style="display:block">${esc(u.text)}</span></span>
<span class="knoepfe">${knoepfe.join("")}</span>
</div>`;
}
function folienBlock(deck) {
if (!deck.folien.length) return `<div class="leer">Die Slides ließen sich nicht lesen.</div>`;
const gruppen = [];
for (const f of deck.folien) {
const teil = deck.teile.find(([start]) => start === f.id);
if (teil || !gruppen.length) gruppen.push({ name: teil ? teil[1] : "", folien: [] });
gruppen.at(-1).folien.push(f);
}
return gruppen.map((g) => `
${g.name ? `<div class="folien-teil">${esc(g.name)}</div>` : ""}
<div class="folien">${g.folien.map((f) => `
<a class="folie-vorschau" href="${SLIDES}/Praesentation.html#f${f.nr}" target="_blank" rel="noopener" title="${esc(f.titel)}">
<img src="${SLIDES}/export/${String(f.nr).padStart(2, "0")}.png" alt="" loading="lazy">
<span><span class="nr">${f.nr}</span>${esc(f.titel)}</span>
</a>`).join("")}
</div>`).join("");
}
export async function zeichnen(main) {
const w = S.webinar;
if (!w) {
main.innerHTML = `<section class="block warnung"><h2>Keine Webinar-Daten</h2><p>daten/webinar.json fehlt.</p></section>`;
return;
}
const deck = await deckLesen();
const nrVon = (id) => deck.folien.find((f) => f.id === id)?.nr;
const ablauf = w.ablauf.map((a, i) => {
const von = nrVon(a.start);
const bis = i + 1 < w.ablauf.length ? (nrVon(w.ablauf[i + 1].start) || 0) - 1 : deck.folien.length;
return { ...a, slides: von && bis ? (von === bis ? `${von}` : `${von} bis ${bis}`) : "" };
});
const fertig = w.schritte.filter((s) => s.status === "erledigt").length;
main.innerHTML = `
<header class="seitenkopf">
<div><div class="ueber">${esc(w.plattform)}, ${w.termin ? esc(langDatum(w.termin)) : "Termin offen"}, ${esc(w.dauer)}</div>
<h1>Webinar</h1>
<div class="unter"><b style="color:var(--tinte)">${esc(w.titel)}</b> ${esc(w.untertitel)}</div>
<div class="thema">Mit <b>${esc(w.sprecher)}</b>. ${esc(w.stand_text)}</div></div>
<a class="knopf voll" href="${SLIDES}/Praesentation.html" target="_blank" rel="noopener">Präsentation ansehen</a>
</header>
<div class="raster r-2-1">
<section class="block"><h2>Unterlagen</h2>
<div class="zeilen">${w.unterlagen.map(unterlage).join("")}</div>
</section>
<section class="block"><h2>Stand <span class="neben">${fertig} von ${w.schritte.length} erledigt</span></h2>
<div class="zeilen">${w.schritte.map((s) => `<div class="zeile" style="grid-template-columns:96px 1fr">
${pille(s.status)}
<span><b>${esc(s.name)}</b>${s.notiz ? `<span class="klein" style="display:block">${esc(s.notiz)}</span>` : ""}</span>
</div>`).join("")}</div>
</section>
</div>
<section class="block"><h2>Ablauf <span class="neben">${esc(w.dauer)}</span></h2>
<div class="tab"><table class="daten">
<thead><tr><th>Minute</th><th>Teil</th><th>Wer</th><th>Knackpunkt</th><th>Slides</th></tr></thead>
<tbody>${ablauf.map((a) => `<tr>
<td class="datum">${esc(a.minuten)}</td>
<td><b>${esc(a.teil)}</b></td>
<td style="white-space:nowrap">${esc(a.wer)}</td>
<td>${esc(a.knackpunkt)}</td>
<td style="white-space:nowrap">${esc(a.slides)}</td>
</tr>`).join("")}</tbody>
</table></div>
</section>
<section class="block"><h2>Slides <span class="neben">${deck.folien.length} Slides, zum Öffnen anklicken</span></h2>
${folienBlock(deck)}
</section>
<section class="block"><h2>Noch offen</h2>
<div class="zeilen">${w.offen.map((o) => `<div class="zeile" style="grid-template-columns:1fr">${esc(o)}</div>`).join("")}</div>
</section>
<p class="klein">Stand ${esc(w.stand.split("-").reverse().join("."))}. Neu bauen: im Ordner <code>webinar/slides</code> <code>npm run export</code>, das Skript-PDF mit <code>node skript-pdf.mjs HiveGrid-Webinar-Skript.pdf --quelle Skript-kurz.md --fuer-noah</code> im Ordner <code>webinar</code>.</p>`;
}