Sortieren und Filtern wie in Excel in jeder Tabelle, Ansichten je Benutzer (0.13.0)
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
This commit is contained in:
@@ -1,6 +1,7 @@
|
||||
// U1/U2 in der Oberfläche: Anmeldeseite, Einrichtung, wer angemeldet ist, Benutzerverwaltung.
|
||||
|
||||
import { type Feld, type Zeile, TEST_BENUTZER, api, dialog, esc, inhalt, merke, seite, tabelle } from "./ui.js";
|
||||
import { type Feld, type Zeile, TEST_BENUTZER, api, dialog, esc, inhalt, merke, seite } from "./ui.js";
|
||||
import { liste as tabelle } from "./liste.js";
|
||||
|
||||
export type Rolle = "inhaber" | "buero" | "mitarbeiter";
|
||||
export interface Sitzung {
|
||||
@@ -153,14 +154,18 @@ export async function benutzerSeite(s: Sitzung): Promise<void> {
|
||||
}
|
||||
};
|
||||
seite("Benutzer", { text: "Neuer Benutzer", aktion: () => void oeffnen(null) });
|
||||
inhalt.appendChild(tabelle([
|
||||
{ titel: "Name", wert: (z) => esc(z.name) },
|
||||
{ titel: "Anmeldename", wert: (z) => esc(z.anmeldename), klasse: "optional" },
|
||||
{ titel: "Rolle", wert: (z) => esc(ROLLE_TEXT[z.rolle as Rolle]) },
|
||||
{ titel: "Kontakt", wert: (z) => esc(kontaktName[z.kontakt_id] ?? ""), klasse: "optional" },
|
||||
...(testversion ? [] : [{ titel: "Passwort", wert: (z: Zeile) => (z.hat_passwort ? "vergeben" : '<span class="fehler">fehlt</span>') }]),
|
||||
{ titel: "Zugang", wert: (z) => (z.aktiv ? "aktiv" : '<span class="fehler">gesperrt</span>') },
|
||||
], liste, (z) => void oeffnen(z)));
|
||||
inhalt.appendChild(tabelle({
|
||||
schluessel: "benutzer", einheit: ["Benutzer", "Benutzer"],
|
||||
spalten: [
|
||||
{ id: "name", titel: "Name", wert: (z) => esc(z.name) },
|
||||
{ id: "anmeldename", titel: "Anmeldename", wert: (z) => esc(z.anmeldename), klasse: "optional" },
|
||||
{ id: "rolle", titel: "Rolle", wert: (z) => esc(ROLLE_TEXT[z.rolle as Rolle]) },
|
||||
{ id: "kontakt", titel: "Kontakt", wert: (z) => esc(kontaktName[z.kontakt_id] ?? ""), klasse: "optional" },
|
||||
...(testversion ? [] : [{ id: "passwort", titel: "Passwort", wert: (z: Zeile) => (z.hat_passwort ? "vergeben" : '<span class="fehler">fehlt</span>') }]),
|
||||
{ id: "zugang", titel: "Zugang", wert: (z) => (z.aktiv ? "aktiv" : '<span class="fehler">gesperrt</span>') },
|
||||
],
|
||||
zeilen: liste, klick: (z) => void oeffnen(z),
|
||||
}));
|
||||
inhalt.insertAdjacentHTML("beforeend", testversion
|
||||
? `<p class="hinweis">Testversion: Passwörter gibt es erst auf dem Server. Unten links wählst du, als wer du arbeitest, und siehst so z. B. die Mitarbeiter-Ansicht.</p>`
|
||||
: `<p class="hinweis">Mitarbeiter sehen am Handy nur ihre eigenen Einsätze mit Adresse, ihre Stunden und die Ablage ihrer Projekte, keine Beträge. Das Büro sieht alles außer Löhnen, Jahresplan, BWA und dieser Seite.</p>`);
|
||||
|
||||
213
src/web/app.ts
213
src/web/app.ts
@@ -1,11 +1,12 @@
|
||||
// Oberfläche. Die Reiter folgen dem Lastenheft; Projektseite und Listen nach Vorbild Plancraft.
|
||||
|
||||
import { kalenderwoche, terminplanSeite } from "./gantt.js";
|
||||
import { type Feld, type Zeile, MONATSNAMEN, api, bearbeitbareAuswahl, bearbeiten, bestaetigen, dat, dialog, esc, euro, heute, hinweis,
|
||||
huelle, inhalt, optionenHtml, seite, tabelle, abgemeldet, lies, merke, TEST_BENUTZER } from "./ui.js";
|
||||
import { type Feld, type Zeile, MONATSNAMEN, api, bearbeiten, bestaetigen, dat, dialog, esc, euro, heute, hinweis,
|
||||
huelle, inhalt, optionenHtml, seite, abgemeldet, lies, merke, TEST_BENUTZER } from "./ui.js";
|
||||
import { type Sitzung, anmeldeSeite, benutzerSeite, werLeiste } from "./anmeldung.js";
|
||||
import { ablageSeite, meineEinsaetze } from "./mitarbeiter.js";
|
||||
import { meinUrlaub } from "./urlaub.js";
|
||||
import { AUGE, AUGE_ZU, ansichtMerken, ansichtenLaden, filterMenue, filterText, gespeicherteAnsicht, liste } from "./liste.js";
|
||||
import { mitarbeiterSeite, personalSeite } from "./personal.js";
|
||||
import { meineStunden, stundenSeite } from "./stunden.js";
|
||||
|
||||
@@ -27,13 +28,18 @@ async function kontakte(): Promise<void> {
|
||||
seite("Kontakte", { text: "Neuer Kontakt", aktion: neu });
|
||||
const zeilen = await api<Zeile[]>("kontakte");
|
||||
const rolle = Object.fromEntries(ROLLEN);
|
||||
inhalt.appendChild(tabelle([
|
||||
{ titel: "Name", wert: (z) => esc(z.name) },
|
||||
{ titel: "Firma", wert: (z) => esc(z.firma), klasse: "optional" },
|
||||
{ titel: "Rolle", wert: (z) => esc(rolle[z.rolle]) },
|
||||
{ titel: "Telefon", wert: (z) => (z.telefon ? `<a href="tel:${esc(z.telefon)}">${esc(z.telefon)}</a>` : "") },
|
||||
{ titel: "E-Mail", wert: (z) => esc(z.email), klasse: "optional" },
|
||||
], zeilen, async (z) => (await bearbeiten("kontakte", "Kontakt bearbeiten", KONTAKT_FELDER, z)) && kontakte()));
|
||||
inhalt.appendChild(liste({
|
||||
schluessel: "kontakte", einheit: ["Kontakt", "Kontakte"], vorgabe: { sort: [["name", "auf"]] },
|
||||
spalten: [
|
||||
{ id: "name", titel: "Name", wert: (z) => esc(z.name) },
|
||||
{ id: "firma", titel: "Firma", wert: (z) => esc(z.firma), klasse: "optional" },
|
||||
{ id: "rolle", titel: "Rolle", wert: (z) => esc(rolle[z.rolle]) },
|
||||
{ id: "gewerk", titel: "Gewerk", wert: (z) => esc(z.gewerk), klasse: "optional" },
|
||||
{ id: "telefon", titel: "Telefon", wert: (z) => (z.telefon ? `<a href="tel:${esc(z.telefon)}">${esc(z.telefon)}</a>` : "") },
|
||||
{ id: "email", titel: "E-Mail", wert: (z) => esc(z.email), klasse: "optional" },
|
||||
],
|
||||
zeilen, klick: async (z) => (await bearbeiten("kontakte", "Kontakt bearbeiten", KONTAKT_FELDER, z)) && kontakte(),
|
||||
}));
|
||||
}
|
||||
|
||||
const STATUS: [string, string][] = [
|
||||
@@ -75,16 +81,22 @@ async function projekte(): Promise<void> {
|
||||
seite("Projekte", { text: "Neues Projekt", aktion: neu });
|
||||
const [zeilen, kontaktListe] = await Promise.all([api<Zeile[]>("projekte"), api<Zeile[]>("kontakte")]);
|
||||
const name = Object.fromEntries(kontaktListe.map((k) => [k.id, k.name]));
|
||||
inhalt.appendChild(tabelle([
|
||||
{ titel: "Name", wert: (z) => `<strong>${esc(z.bezeichnung)}</strong><span class="unter"><span class="nur-schmal">${esc(z.nummer)} · </span>${esc([ortZeile(z), name[z.bauherr_id]].filter(Boolean).join(" · ") || "–")}</span>` },
|
||||
{ titel: "Nummer", wert: (z) => esc(z.nummer), klasse: "optional" },
|
||||
{ titel: "Status", wert: (z) => etikett(z.status) },
|
||||
{ titel: "Umsatz netto", wert: (z) => euro(z.umsatz_netto), klasse: "zahl optional" },
|
||||
{ titel: "Kosten", wert: (z) => euro(kostenSumme(z)), klasse: "zahl optional" },
|
||||
{ titel: "Rohertrag", wert: (z) => euro(z.umsatz_netto - kostenSumme(z)), klasse: "zahl optional" },
|
||||
], zeilen, (z) => (location.hash = `projekt-${z.id}`)));
|
||||
const gesamt = zeilen.reduce((s, z) => s + z.umsatz_netto - kostenSumme(z), 0);
|
||||
inhalt.insertAdjacentHTML("beforeend", `<p class="anzahl">${zeilen.length} Projekte</p><p>Rohertrag gesamt: <strong>${euro(gesamt)}</strong></p>`);
|
||||
const statusRang = Object.fromEntries(STATUS.map(([k], i) => [k, i]));
|
||||
inhalt.appendChild(liste({
|
||||
schluessel: "projekte", einheit: ["Projekt", "Projekte"],
|
||||
spalten: [
|
||||
{ id: "name", titel: "Name", text: (z) => z.bezeichnung, wert: (z) => `<strong>${esc(z.bezeichnung)}</strong><span class="unter"><span class="nur-schmal">${esc(z.nummer)} · </span>${esc([ortZeile(z), name[z.bauherr_id]].filter(Boolean).join(" · ") || "–")}</span>` },
|
||||
{ id: "nummer", titel: "Nummer", wert: (z) => esc(z.nummer), klasse: "optional" },
|
||||
{ id: "kunde", titel: "Kunde", wert: (z) => esc(name[z.bauherr_id] ?? ""), klasse: "optional" },
|
||||
{ id: "ort", titel: "Ort", wert: (z) => esc(z.baustelle_ort ?? ""), klasse: "optional" },
|
||||
{ id: "status", titel: "Status", wert: (z) => etikett(z.status), sortWert: (z) => statusRang[z.status] ?? 99 },
|
||||
{ id: "umsatz", titel: "Umsatz netto", art: "zahl", wert: (z) => euro(z.umsatz_netto), sortWert: (z) => z.umsatz_netto, klasse: "zahl optional" },
|
||||
{ id: "kosten", titel: "Kosten", art: "zahl", wert: (z) => euro(kostenSumme(z)), sortWert: kostenSumme, klasse: "zahl optional" },
|
||||
{ id: "rohertrag", titel: "Rohertrag", art: "zahl", wert: (z) => euro(z.umsatz_netto - kostenSumme(z)), sortWert: (z) => z.umsatz_netto - kostenSumme(z), klasse: "zahl optional" },
|
||||
],
|
||||
zeilen, klick: (z) => (location.hash = `projekt-${z.id}`),
|
||||
fuss: (sichtbar) => `<p>Rohertrag ${sichtbar.length === zeilen.length ? "gesamt" : "der gezeigten Projekte"}: <strong>${euro(sichtbar.reduce((s, z) => s + z.umsatz_netto - kostenSumme(z), 0))}</strong></p>`,
|
||||
}));
|
||||
}
|
||||
|
||||
// ---------- Projektseite (P2), aufgebaut wie bei Plancraft ----------
|
||||
@@ -116,7 +128,6 @@ const kachel = (art: string, titel: string, inhaltHtml: string) => `<section cla
|
||||
// Dokumente, Berichte, Ablage und Zahlungsplan, rechts statt des Chats die offenen Aufgaben des Projekts
|
||||
let projektOben = "uebersicht";
|
||||
let projektTeil = "dokumente";
|
||||
const projektAufgabenFilter = { kategorie: "", erledigte: false };
|
||||
const ZAHLUNGSART_TEXT = Object.fromEntries(ZAHLUNGSARTEN);
|
||||
const stundenText = (h: number) => { const m = Math.round(h * 60); return `${Math.floor(m / 60)}:${String(m % 60).padStart(2, "0")} Std.`; };
|
||||
const groesseText = (b: number) => (b >= 1048576 ? `${(b / 1048576).toFixed(1).replace(".", ",")} MB` : `${Math.max(1, Math.round(b / 1024))} KB`);
|
||||
@@ -208,12 +219,17 @@ async function projektSeite(id: string): Promise<void> {
|
||||
];
|
||||
ziel.querySelector<HTMLButtonElement>('[data-a="kosten-neu"]')!.onclick = async () =>
|
||||
(await bearbeiten("kosten", "Neue Kosten", felder, null, { projekt_id: id, art: "material", status: "geplant", termin: heute() })) && neuLaden();
|
||||
ziel.querySelector(".kosten-liste")!.append(eigeneKosten.length ? tabelle([
|
||||
{ titel: "Bezeichnung", wert: (k) => `${esc(k.bezeichnung)}<span class="unter">${esc([Object.fromEntries(KOSTENARTEN)[k.art], kontakt[k.kontakt_id]?.name].filter(Boolean).join(" · "))}</span>` },
|
||||
{ titel: "Termin", wert: (k) => dat(k.termin) },
|
||||
{ titel: "Status", wert: (k) => esc(k.status), klasse: "optional" },
|
||||
{ titel: "Netto", wert: (k) => euro(k.netto), klasse: "zahl" },
|
||||
], eigeneKosten, async (k) => (await bearbeiten("kosten", "Kosten bearbeiten", felder, k)) && neuLaden()) : leer("Noch keine Einzelkosten."));
|
||||
ziel.querySelector(".kosten-liste")!.append(eigeneKosten.length ? liste({
|
||||
schluessel: "projekt-kosten", klein: true, einheit: ["Position", "Positionen"],
|
||||
spalten: [
|
||||
{ id: "bezeichnung", titel: "Bezeichnung", text: (k) => k.bezeichnung, wert: (k) => `${esc(k.bezeichnung)}<span class="unter">${esc(kontakt[k.kontakt_id]?.name ?? "")}</span>` },
|
||||
{ id: "art", titel: "Art", wert: (k) => esc(Object.fromEntries(KOSTENARTEN)[k.art] ?? k.art) },
|
||||
{ id: "termin", titel: "Termin", art: "datum", wert: (k) => dat(k.termin), sortWert: (k) => k.termin },
|
||||
{ id: "status", titel: "Status", wert: (k) => esc(k.status), klasse: "optional" },
|
||||
{ id: "netto", titel: "Netto", art: "zahl", wert: (k) => euro(k.netto), sortWert: (k) => k.netto, klasse: "zahl" },
|
||||
],
|
||||
zeilen: eigeneKosten, klick: async (k) => (await bearbeiten("kosten", "Kosten bearbeiten", felder, k)) && neuLaden(),
|
||||
}) : leer("Noch keine Einzelkosten."));
|
||||
}
|
||||
};
|
||||
|
||||
@@ -287,34 +303,26 @@ async function projektSeite(id: string): Promise<void> {
|
||||
}
|
||||
teil.append(info);
|
||||
if (eigeneZahlungen.length) {
|
||||
teil.append(tabelle([
|
||||
{ titel: "Bezeichnung", wert: (z) => `${esc(z.bezeichnung)}<span class="unter">${esc(ZAHLUNGSART_TEXT[z.art] ?? "")}</span>` },
|
||||
{ titel: "Termin", wert: (z) => `${dat(z.termin)}${z.vorgang_id ? `<span class="unter">nach ${esc(vorgangName(z.vorgang_id))}</span>` : ""}` },
|
||||
{ titel: "Status", wert: (z) => `<span class="etikett zahlung-${esc(z.status)}">${esc(z.status)}</span>`, klasse: "optional" },
|
||||
{ titel: "Netto", wert: (z) => euro(z.netto), klasse: "zahl" },
|
||||
], eigeneZahlungen, async (z) => (await bearbeiten("zahlungen", "Zahlung bearbeiten", felder, z)) && neuLaden()));
|
||||
teil.append(liste({
|
||||
schluessel: "projekt-zahlungen", klein: true, einheit: ["Rate", "Raten"],
|
||||
spalten: [
|
||||
{ id: "bezeichnung", titel: "Bezeichnung", text: (z) => z.bezeichnung, wert: (z) => `${esc(z.bezeichnung)}<span class="unter">${esc(ZAHLUNGSART_TEXT[z.art] ?? "")}</span>` },
|
||||
{ id: "termin", titel: "Termin", art: "datum", sortWert: (z) => z.termin, wert: (z) => `${dat(z.termin)}${z.vorgang_id ? `<span class="unter">nach ${esc(vorgangName(z.vorgang_id))}</span>` : ""}` },
|
||||
{ id: "status", titel: "Status", text: (z) => z.status, wert: (z) => `<span class="etikett zahlung-${esc(z.status)}">${esc(z.status)}</span>`, klasse: "optional" },
|
||||
{ id: "netto", titel: "Netto", art: "zahl", wert: (z) => euro(z.netto), sortWert: (z) => z.netto, klasse: "zahl" },
|
||||
],
|
||||
zeilen: eigeneZahlungen, klick: async (z) => (await bearbeiten("zahlungen", "Zahlung bearbeiten", felder, z)) && neuLaden(),
|
||||
}));
|
||||
teil.insertAdjacentHTML("beforeend", `<p class="summe">Summe ${euro(summe)}${umsatz && summe !== umsatz ? ` · Auftragswert ${euro(umsatz)}, Rest ${euro(umsatz - summe)}` : ""}</p>`);
|
||||
}
|
||||
}
|
||||
|
||||
// ---------- rechts: offene Aufgaben statt Chat ----------
|
||||
const zeigeAufgaben = () => {
|
||||
const f = projektAufgabenFilter;
|
||||
const liste = eigeneAufgaben
|
||||
.filter((a) => (f.erledigte || !a.erledigt_am) && (!f.kategorie || (f.kategorie === "ohne" ? !a.kategorie_id : a.kategorie_id === f.kategorie)))
|
||||
.sort((a, b) => Number(!!a.erledigt_am) - Number(!!b.erledigt_am) || (a.faellig_am ?? "9999").localeCompare(b.faellig_am ?? "9999"));
|
||||
const offen = eigeneAufgaben.filter((a) => !a.erledigt_am).length;
|
||||
const seite = inhalt.querySelector<HTMLElement>(".projekt-aufgaben")!;
|
||||
seite.innerHTML = `<div class="aufgaben-kopf"><h2>Offene Aufgaben <small>${offen}</small></h2><button class="haupt" data-a="aufgabe-neu">+ Aufgabe</button></div>
|
||||
<div class="aufgaben-filter"><select id="pa-kategorie" aria-label="Kategorie">${optionenHtml([["", "Alle Kategorien"], ["ohne", "Ohne Kategorie"], ...kategorieOptionen(aufgabenDat.kategorien).slice(1)], f.kategorie)}</select>
|
||||
<label class="schalter"><input type="checkbox" id="pa-erledigte"${f.erledigte ? " checked" : ""}> Erledigte</label></div>
|
||||
${liste.length ? `<ul class="aufgaben-liste">${liste.map((a) => {
|
||||
const ueber = !a.erledigt_am && a.faellig_am && a.faellig_am < heute();
|
||||
return `<li class="${a.erledigt_am ? "erledigt" : ""}"><input type="checkbox" data-erledigt="${a.id}" aria-label="Erledigt"${a.erledigt_am ? " checked" : ""}>
|
||||
<button class="aufgabe" data-aufgabe="${a.id}"><span class="text">${esc(a.text)}</span><span class="meta">${a.kategorie_id ? `<span class="kategorie">${esc(aufgabenDat.namen.kategorie[a.kategorie_id] ?? "")}</span>` : ""}${a.faellig_am ? `<span class="${ueber ? "fehler" : ""}">${ueber ? "überfällig seit " : "fällig "}${dat(a.faellig_am)}</span>` : ""}</span></button></li>`;
|
||||
}).join("")}</ul>` : `<p class="hinweis leer">${offen ? "Keine Aufgabe in dieser Auswahl." : "Keine offenen Aufgaben zu diesem Projekt."}</p>`}`;
|
||||
seite.querySelector<HTMLSelectElement>("#pa-kategorie")!.onchange = (ev) => { f.kategorie = (ev.target as HTMLSelectElement).value; zeigeAufgaben(); };
|
||||
seite.querySelector<HTMLInputElement>("#pa-erledigte")!.onchange = (ev) => { f.erledigte = (ev.target as HTMLInputElement).checked; zeigeAufgaben(); };
|
||||
seite.innerHTML = `<div class="aufgaben-kopf"><h2>Offene Aufgaben <small>${offen}</small></h2><button class="haupt" data-a="aufgabe-neu">+ Aufgabe</button></div>`;
|
||||
seite.append(aufgabenTabelle(eigeneAufgaben, aufgabenDat.namen, aufgabenDat.felder, neuLaden, true));
|
||||
};
|
||||
|
||||
zeigeOben();
|
||||
@@ -376,7 +384,8 @@ async function projektSeite(id: string): Promise<void> {
|
||||
}
|
||||
|
||||
async function terminplan(): Promise<void> {
|
||||
await terminplanSeite({ api, dialog, esc, seite: (t) => seite(t), inhalt });
|
||||
await terminplanSeite({ api, dialog, esc, seite: (t) => seite(t), inhalt, filterMenue, filterText,
|
||||
ansicht: { lies: gespeicherteAnsicht, setze: ansichtMerken }, auge: [AUGE, AUGE_ZU] });
|
||||
}
|
||||
|
||||
// Liquidität (Henning, 20.10.2026): oben die Lage in Zahlen und als Kontostandverlauf, darunter je Woche
|
||||
@@ -384,14 +393,17 @@ async function terminplan(): Promise<void> {
|
||||
let liquiOffen = new Set<string>();
|
||||
async function liquiditaetSeite(ansicht = "woche", anzahl = 8): Promise<void> {
|
||||
const leiste = seite("Liquidität");
|
||||
leiste.innerHTML = `<select id="l-ansicht" aria-label="Zeitraster"><option value="woche">Wochen</option><option value="monat">Monate</option></select>
|
||||
leiste.innerHTML = `<select id="l-ansicht" aria-label="Zeitraster"><option value="woche">Wochen</option><option value="monat">Monate</option><option value="liste">Einzelne Zahlungen</option></select>
|
||||
<select id="l-anzahl" aria-label="Anzahl">${[4, 8, 12, 26, 52].map((n) => `<option>${n}</option>`).join("")}</select>
|
||||
<button class="neben" id="l-alle">Alle Zahlungen aufklappen</button>`;
|
||||
${ansicht === "liste" ? "" : '<button class="neben" id="l-alle">Alle Zahlungen aufklappen</button>'}`;
|
||||
const a = leiste.querySelector("#l-ansicht") as HTMLSelectElement;
|
||||
const n = leiste.querySelector("#l-anzahl") as HTMLSelectElement;
|
||||
a.value = ansicht;
|
||||
n.value = String(anzahl);
|
||||
a.onchange = n.onchange = () => liquiditaetSeite(a.value, Number(n.value));
|
||||
// „Einzelne Zahlungen“: dieselben Wochen, aber jede Zahlung als Zeile zum Sortieren und Filtern
|
||||
const einzeln = ansicht === "liste";
|
||||
if (einzeln) ansicht = "woche";
|
||||
const [perioden, projekte, einst] = await Promise.all([
|
||||
api<Zeile[]>(`liquiditaet?ansicht=${ansicht}&anzahl=${anzahl}&start=${heute()}`), api<Zeile[]>("projekte"), api<Zeile>("einstellungen"),
|
||||
]);
|
||||
@@ -426,8 +438,31 @@ async function liquiditaetSeite(ansicht = "woche", anzahl = 8): Promise<void> {
|
||||
}).join("")}</div></section>`);
|
||||
}
|
||||
|
||||
// Tabelle: je Zeitraum eine Zeile, aufgeklappt jede Zahlung mit Datum
|
||||
const heuteD = heute();
|
||||
if (einzeln) {
|
||||
// Kontostand nach jeder Zahlung, in zeitlicher Reihenfolge gerechnet; bleibt beim Umsortieren an der Zahlung
|
||||
let stand = perioden.length ? perioden[0]!.kontostand - perioden[0]!.saldo : startsaldo;
|
||||
const posten = perioden.flatMap((p) => p.posten as Zeile[])
|
||||
.sort((x, y) => (x.datum < y.datum ? -1 : x.datum > y.datum ? 1 : x.betrag - y.betrag))
|
||||
.map((x, i) => ({ ...x, id: `${x.datum}-${i}-${x.bezeichnung}`, stand: (stand += x.betrag) }));
|
||||
inhalt.append(liste({
|
||||
schluessel: "liquiditaet-zahlungen", einheit: ["Zahlung", "Zahlungen"], leer: "Keine Zahlungen im Zeitraum.",
|
||||
zeilenKlasse: (x) => (x.datum < heuteD ? "vorbei" : ""),
|
||||
spalten: [
|
||||
{ id: "datum", titel: "Fällig am", art: "datum", wert: (x) => dat(x.datum), sortWert: (x) => x.datum },
|
||||
{ id: "was", titel: "Was", text: (x) => x.bezeichnung, wert: (x) => `${esc(x.bezeichnung)}<span class="unter nur-schmal">${esc(x.gruppe)}</span>` },
|
||||
{ id: "gruppe", titel: "Art", wert: (x) => esc(x.gruppe), klasse: "optional" },
|
||||
{ id: "projekt", titel: "Projekt", wert: (x) => (x.projekt ? `${esc(x.projekt)}${projektName.get(x.projekt) ? ` ${esc(projektName.get(x.projekt))}` : ""}` : ""), klasse: "optional" },
|
||||
{ id: "betrag", titel: "Betrag", art: "zahl", wert: (x) => `<span class="${x.betrag < 0 ? "aus" : "ein"}">${euro(x.betrag)}</span>`, sortWert: (x) => x.betrag, klasse: "zahl" },
|
||||
{ id: "stand", titel: "Kontostand danach", art: "zahl", wert: (x) => `<span class="${x.stand < 0 ? "fehler" : ""}">${euro(x.stand)}</span>`, sortWert: (x) => x.stand, klasse: "zahl optional" },
|
||||
],
|
||||
zeilen: posten,
|
||||
fuss: (l) => (l.length === posten.length ? "" : `<p>Summe der gezeigten Zahlungen: <strong>${euro(l.reduce((s, x) => s + x.betrag, 0))}</strong></p>`),
|
||||
}));
|
||||
return;
|
||||
}
|
||||
|
||||
// Tabelle: je Zeitraum eine Zeile, aufgeklappt jede Zahlung mit Datum
|
||||
const zeile = (x: Zeile) => {
|
||||
const projekt = x.projekt ? `${esc(x.projekt)}${projektName.get(x.projekt) ? ` ${esc(projektName.get(x.projekt))}` : ""}` : "";
|
||||
return `<tr class="posten${x.datum < heuteD ? " vorbei" : ""}"><td>${dat(x.datum)}</td><td>${esc(x.bezeichnung)}<span class="unter">${esc(x.gruppe)}</span></td>
|
||||
@@ -470,13 +505,19 @@ async function laufendeKosten(): Promise<void> {
|
||||
seite("Laufende Kosten", { text: "Neue Position", aktion: neu });
|
||||
const zeilen = await api<Zeile[]>("laufende-kosten");
|
||||
const r = Object.fromEntries(RHYTHMEN);
|
||||
inhalt.appendChild(tabelle([
|
||||
{ titel: "Kategorie", wert: (z) => esc(z.kategorie) }, { titel: "Bezeichnung", wert: (z) => esc(z.bezeichnung) },
|
||||
{ titel: "Rhythmus", wert: (z) => esc(r[z.rhythmus]) }, { titel: "Ab", wert: (z) => dat(z.start), klasse: "optional" },
|
||||
{ titel: "Betrag", wert: (z) => euro(z.betrag), klasse: "zahl" },
|
||||
], zeilen, async (z) => (await bearbeiten("laufende-kosten", "Laufende Kosten bearbeiten", LK_FELDER, z)) && laufendeKosten()));
|
||||
const monat = zeilen.filter((z) => z.rhythmus === "monatlich" && (!z.ende || z.ende >= heute())).reduce((s, z) => s + z.betrag, 0);
|
||||
inhalt.insertAdjacentHTML("beforeend", `<p>Monatlich: <strong>${euro(monat)}</strong></p>`);
|
||||
const monatlich = (l: Zeile[]) => l.filter((z) => z.rhythmus === "monatlich" && (!z.ende || z.ende >= heute())).reduce((s, z) => s + z.betrag, 0);
|
||||
inhalt.appendChild(liste({
|
||||
schluessel: "laufende-kosten", einheit: ["Position", "Positionen"],
|
||||
spalten: [
|
||||
{ id: "kategorie", titel: "Kategorie", wert: (z) => esc(z.kategorie) }, { id: "bezeichnung", titel: "Bezeichnung", wert: (z) => esc(z.bezeichnung) },
|
||||
{ id: "rhythmus", titel: "Rhythmus", wert: (z) => esc(r[z.rhythmus]), sortWert: (z) => RHYTHMEN.findIndex(([k]) => k === z.rhythmus) },
|
||||
{ id: "start", titel: "Ab", art: "datum", wert: (z) => dat(z.start), sortWert: (z) => z.start, klasse: "optional" },
|
||||
{ id: "ende", titel: "Endet", art: "datum", wert: (z) => dat(z.ende), sortWert: (z) => z.ende, klasse: "optional" },
|
||||
{ id: "betrag", titel: "Betrag", art: "zahl", wert: (z) => euro(z.betrag), sortWert: (z) => z.betrag, klasse: "zahl" },
|
||||
],
|
||||
zeilen, klick: async (z) => (await bearbeiten("laufende-kosten", "Laufende Kosten bearbeiten", LK_FELDER, z)) && laufendeKosten(),
|
||||
fuss: (sichtbar) => `<p>Monatlich${sichtbar.length === zeilen.length ? "" : " (gezeigte Positionen)"}: <strong>${euro(monatlich(sichtbar))}</strong></p>`,
|
||||
}));
|
||||
}
|
||||
|
||||
// G4: Kategorien für Aufgaben, im Auswahlmenü über „Kategorien bearbeiten …“ pflegbar
|
||||
@@ -558,18 +599,38 @@ async function neueAufgabe(vorgaben: Zeile = {}): Promise<boolean> {
|
||||
return bearbeiten("aufgaben", "Neue Aufgabe", (await aufgabenDaten()).felder, null, vorgaben);
|
||||
}
|
||||
|
||||
function aufgabenTabelle(zeilen: Zeile[], namen: AufgabenNamen, felder: Feld[], neuLaden: () => void, ohneProjekt = false): HTMLTableElement {
|
||||
// Aufgaben sortieren und filtern wie in Excel (Henning, 20.10.2026); Erledigte sind ein Filter auf der Hakenspalte
|
||||
const AUFGABEN_VORGABE = { sort: [["faellig", "auf"]] as [string, "auf"][], filter: { erledigt: ["erledigt"] } };
|
||||
const AUFGABEN_VORLAGEN = [
|
||||
{ name: "Meine Woche", ansicht: { sort: [["faellig", "auf"], ["kategorie", "auf"]] as [string, "auf"][], filter: { erledigt: ["erledigt"] }, zeit: { faellig: "bis-wochenende" } } },
|
||||
{ name: "Erledigte", ansicht: { sort: [["faellig", "ab"]] as [string, "ab"][], filter: { erledigt: ["offen"] } } },
|
||||
];
|
||||
|
||||
function aufgabenTabelle(zeilen: Zeile[], namen: AufgabenNamen, felder: Feld[], neuLaden: () => void, ohneProjekt = false): HTMLElement {
|
||||
const zuordnung = (z: Zeile) => [ohneProjekt ? "" : namen.projekt[z.projekt_id], namen.kontakt[z.kontakt_id]].filter(Boolean).map(esc).join(" · ");
|
||||
const t = tabelle([
|
||||
{ titel: "", wert: (z) => `<input type="checkbox" data-id="${z.id}" aria-label="Erledigt"${z.erledigt_am ? " checked" : ""}>` },
|
||||
{ titel: "Aufgabe", wert: (z) => `${z.erledigt_am ? `<s>${esc(z.text)}</s>` : esc(z.text)}${zuordnung(z) ? `<span class="unter">${zuordnung(z)}</span>` : ""}` },
|
||||
{ titel: "Kategorie", wert: (z) => (z.kategorie_id ? `<span class="kategorie">${esc(namen.kategorie[z.kategorie_id])}</span>` : "") },
|
||||
{ titel: "Fällig", wert: (z) => `<span class="${!z.erledigt_am && z.faellig_am && z.faellig_am < heute() ? "fehler" : ""}">${dat(z.faellig_am)}</span>` },
|
||||
], zeilen, async (z) => (await bearbeiten("aufgaben", "Aufgabe bearbeiten", felder, z)) && neuLaden());
|
||||
t.classList.add("aufgaben-tabelle");
|
||||
const t = liste({
|
||||
schluessel: ohneProjekt ? "projekt-aufgaben" : "aufgaben", klein: ohneProjekt, einheit: ["Aufgabe", "Aufgaben"], klasse: "aufgaben-tabelle",
|
||||
vorgabe: AUFGABEN_VORGABE, vorlagen: ohneProjekt ? [] : AUFGABEN_VORLAGEN, leer: "Noch keine Aufgaben.",
|
||||
zeilenKlasse: (z) => (z.erledigt_am ? "erledigt" : ""),
|
||||
spalten: [
|
||||
{ id: "erledigt", titel: "Erledigt", kopf: '<span aria-label="Erledigt">✓</span>', text: (z) => (z.erledigt_am ? "erledigt" : "offen"),
|
||||
wert: (z) => `<input type="checkbox" data-id="${z.id}" aria-label="Erledigt"${z.erledigt_am ? " checked" : ""}>` },
|
||||
{ id: "text", titel: "Aufgabe", text: (z) => z.text,
|
||||
wert: (z) => `${z.erledigt_am ? `<s>${esc(z.text)}</s>` : esc(z.text)}${zuordnung(z) ? `<span class="unter${ohneProjekt ? "" : " nur-schmal"}">${zuordnung(z)}</span>` : ""}` },
|
||||
...(ohneProjekt ? [] : [
|
||||
{ id: "projekt", titel: "Projekt", wert: (z: Zeile) => esc(namen.projekt[z.projekt_id] ?? ""), klasse: "optional" },
|
||||
{ id: "kontakt", titel: "Kunde / Kontakt", wert: (z: Zeile) => esc(namen.kontakt[z.kontakt_id] ?? ""), klasse: "optional" },
|
||||
]),
|
||||
{ id: "kategorie", titel: "Kategorie", text: (z) => namen.kategorie[z.kategorie_id] ?? "",
|
||||
wert: (z) => (z.kategorie_id ? `<span class="kategorie">${esc(namen.kategorie[z.kategorie_id])}</span>` : "") },
|
||||
{ id: "faellig", titel: "Fällig", art: "datum", sortWert: (z) => z.faellig_am,
|
||||
wert: (z) => `<span class="${!z.erledigt_am && z.faellig_am && z.faellig_am < heute() ? "fehler" : ""}">${dat(z.faellig_am)}</span>` },
|
||||
],
|
||||
zeilen, klick: async (z) => (await bearbeiten("aufgaben", "Aufgabe bearbeiten", felder, z)) && neuLaden(),
|
||||
});
|
||||
t.addEventListener("click", async (ev) => {
|
||||
const box = ev.target as HTMLInputElement;
|
||||
if (box.type !== "checkbox") return;
|
||||
if (box.type !== "checkbox" || !box.dataset.id) return;
|
||||
ev.stopPropagation();
|
||||
await api(`aufgaben/${box.dataset.id}`, "PATCH", { erledigt_am: box.checked ? new Date().toISOString() : null });
|
||||
neuLaden();
|
||||
@@ -577,25 +638,12 @@ function aufgabenTabelle(zeilen: Zeile[], namen: AufgabenNamen, felder: Feld[],
|
||||
return t;
|
||||
}
|
||||
|
||||
// Filter der Aufgabenliste bleiben beim Wechsel zwischen den Reitern erhalten
|
||||
const aufgabenFilter = { kategorie: "", projekt: "", erledigte: false };
|
||||
|
||||
async function aufgaben(): Promise<void> {
|
||||
const leiste = seite("Aufgaben", { text: "Neue Aufgabe", aktion: async () => (await neueAufgabe()) && aufgaben() });
|
||||
const [d, alle] = await Promise.all([aufgabenDaten(), api<Zeile[]>("aufgaben")]);
|
||||
const f = aufgabenFilter;
|
||||
if (f.kategorie && f.kategorie !== "ohne" && !d.namen.kategorie[f.kategorie]) f.kategorie = "";
|
||||
leiste.innerHTML = `<select id="a-kategorie" aria-label="Kategorie">${optionenHtml([["", "Alle Kategorien"], ["ohne", "Ohne Kategorie"], ...kategorieOptionen(d.kategorien).slice(1)], f.kategorie, KATEGORIEN_BEARBEITEN)}</select>
|
||||
<select id="a-projekt" aria-label="Projekt">${optionenHtml([["", "Alle Projekte"], ["ohne", "Ohne Projekt"], ...d.projekte.map((p): [string, string] => [p.id, `${p.nummer} ${p.bezeichnung}`])], f.projekt)}</select>
|
||||
<label class="schalter"><input type="checkbox" id="a-erledigte"${f.erledigte ? " checked" : ""}> Erledigte zeigen</label>`;
|
||||
const kat = leiste.querySelector("#a-kategorie") as HTMLSelectElement;
|
||||
bearbeitbareAuswahl(kat, KATEGORIEN_BEARBEITEN, () => { f.kategorie = kat.value; aufgaben(); });
|
||||
(leiste.querySelector("#a-projekt") as HTMLSelectElement).onchange = (ev) => { f.projekt = (ev.target as HTMLSelectElement).value; aufgaben(); };
|
||||
(leiste.querySelector("#a-erledigte") as HTMLInputElement).onchange = (ev) => { f.erledigte = (ev.target as HTMLInputElement).checked; aufgaben(); };
|
||||
const passt = (wert: string | null, filter: string) => !filter || (filter === "ohne" ? !wert : wert === filter);
|
||||
const zeilen = alle.filter((a) => (f.erledigte || !a.erledigt_am) && passt(a.kategorie_id, f.kategorie) && passt(a.projekt_id, f.projekt));
|
||||
inhalt.appendChild(aufgabenTabelle(zeilen, d.namen, d.felder, aufgaben));
|
||||
inhalt.insertAdjacentHTML("beforeend", `<p class="anzahl">${zeilen.length} von ${alle.length} Aufgaben</p>`);
|
||||
leiste.innerHTML = '<button class="neben" data-a="kategorien">Kategorien bearbeiten</button>';
|
||||
leiste.querySelector<HTMLElement>('[data-a="kategorien"]')!.onclick = async () => { await kategorienBearbeiten(); void aufgaben(); };
|
||||
inhalt.appendChild(aufgabenTabelle(alle, d.namen, d.felder, aufgaben));
|
||||
}
|
||||
|
||||
const WOCHENTAG = ["", "Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"];
|
||||
@@ -851,6 +899,7 @@ async function start(): Promise<void> {
|
||||
REITER = reiterFuer(s);
|
||||
nav.innerHTML = REITER.map(([id, titel]) => `<button data-r="${id}">${symbol(id)}<span>${titel}</span></button>`).join("");
|
||||
werLeiste(s);
|
||||
await ansichtenLaden();
|
||||
window.addEventListener("hashchange", zeige);
|
||||
await zeige();
|
||||
}
|
||||
|
||||
@@ -18,7 +18,17 @@ export interface Hilfen {
|
||||
esc(v: unknown): string;
|
||||
seite(titel: string): HTMLElement;
|
||||
inhalt: HTMLElement;
|
||||
/** Filtermenü und gespeicherte Ansicht wie in den Tabellen (liste.ts) */
|
||||
filterMenue(anker: HTMLElement, o: { titel: string; werte: FilterWert[]; aus: string[]; fertig: (aus: string[]) => void }): void;
|
||||
filterText(werte: FilterWert[], aus: string[]): string;
|
||||
ansicht: { lies(schluessel: string): GanttAnsicht; setze(schluessel: string, a: GanttAnsicht): void };
|
||||
auge: [string, string];
|
||||
}
|
||||
interface FilterWert { wert: string; text: string; anzahl: number }
|
||||
interface GanttAnsicht { sort: [string, "auf" | "ab"][]; filter: Record<string, string[]>; zeit: Record<string, string>; aus: string[] }
|
||||
/** Ausgeblendete Zeilen gerade zeigen (bis zum Neuladen der Seite) */
|
||||
let ausZeigen = false;
|
||||
const OHNE = "(ohne Besetzung)";
|
||||
|
||||
interface Plan {
|
||||
projekte: Zeile[];
|
||||
@@ -35,7 +45,7 @@ interface Plan {
|
||||
}
|
||||
|
||||
const ZOOM: Record<string, number> = { tag: 24, woche: 10, monat: 4 };
|
||||
// Zoom wie in MS Project: − und + oder Ziehen an der Zeitskala (Regler auf Hennings Wunsch entfernt) (Henning, 20.10.2026), Pixel je Tag
|
||||
// Zoom wie in MS Project: Ziehen an der Zeitskala; Regler und −/+ auf Hennings Wunsch entfernt (Henning, 20.10.2026), Pixel je Tag
|
||||
const ZOOM_MIN = 2, ZOOM_MAX = 48;
|
||||
const zoomGrenzen = (w: number) => Math.round(Math.min(ZOOM_MAX, Math.max(ZOOM_MIN, w)) * 10) / 10;
|
||||
/** Welcher Tag beim Zoomen an welcher Stelle (Pixel ab dem Zeitbereich) stehen bleibt */
|
||||
@@ -116,27 +126,47 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
const personen = new Map<string, string>();
|
||||
for (const k of plan.leute) personen.set(k.id, k.rolle === "subunternehmer" && k.firma ? k.firma : k.name);
|
||||
for (const b of plan.besetzungen) { const w = wer(b); if (w && !personen.has(w)) personen.set(w, b.anzeige); }
|
||||
let filter = merke<string>("gantt-person") ?? "";
|
||||
if (filter && !personen.has(filter)) filter = "";
|
||||
const passt = (v: Zeile) => !filter || plan.besetzungen.some((b) => b.vorgang_id === v.id && wer(b) === filter);
|
||||
// Filtern und Ausblenden wie in den Tabellen; die Reihenfolge bleibt die gezogene (Henning, 20.10.2026)
|
||||
const ansicht = h.ansicht.lies("terminplan");
|
||||
const personAus = ansicht.filter.person ?? [], projektAus = ansicht.filter.projekt ?? [];
|
||||
const ausgeblendet = new Set(ansicht.aus);
|
||||
const filter = personAus.length > 0;
|
||||
const passt = (v: Zeile) => {
|
||||
if (!filter) return true;
|
||||
const leute = plan.besetzungen.filter((b) => b.vorgang_id === v.id).map(wer);
|
||||
return leute.length ? leute.some((p) => p && !personAus.includes(p)) : !personAus.includes(OHNE);
|
||||
};
|
||||
const sichtbarZeile = (id: string) => ausZeigen || !ausgeblendet.has(id);
|
||||
const setzeAnsicht = (neu: Partial<GanttAnsicht>) => { h.ansicht.setze("terminplan", { ...ansicht, ...neu }); void terminplanSeite(h, plan); };
|
||||
|
||||
const projekteAlle = plan.projekte.filter((p) => mitFertigen || p.status !== "abgeschlossen");
|
||||
const personWerte: FilterWert[] = [...[...personen].sort((a, b) => a[1].localeCompare(b[1], "de")).map(([id, name]) => ({ wert: id, text: name, anzahl: new Set(plan.besetzungen.filter((b) => wer(b) === id).map((b) => b.vorgang_id)).size })),
|
||||
{ wert: OHNE, text: OHNE, anzahl: plan.vorgaenge.filter((v) => !plan.besetzungen.some((b) => b.vorgang_id === v.id)).length }];
|
||||
const projektWerte: FilterWert[] = projekteAlle.map((p) => ({ wert: p.id, text: `${p.nummer} ${p.bezeichnung}`, anzahl: 0 }));
|
||||
const filterWerte: Record<string, FilterWert[]> = { person: personWerte, projekt: projektWerte };
|
||||
const filterKnopf = (id: string, titel: string, aus: string[]) => aus.length
|
||||
? `<span class="chip"><button class="chip-text" data-filter="${id}" title="${titel} filtern">${esc(titel)}: ${esc(h.filterText(filterWerte[id]!, aus))}</button><button data-filter-weg="${id}" aria-label="Filter ${titel} entfernen">✕</button></span>`
|
||||
: `<button class="neben" data-filter="${id}" aria-haspopup="true">${titel} ▾</button>`;
|
||||
const alleIds = new Set([...plan.projekte, ...plan.abschnitte, ...plan.vorgaenge].map((x) => x.id as string));
|
||||
const anzahlAus = ansicht.aus.filter((id) => alleIds.has(id)).length;
|
||||
|
||||
leiste.innerHTML = `${Object.keys(ZOOM).map((z) => `<button class="neben${ZOOM[z] === W ? " an" : ""}" data-zoom="${z}">${z[0]!.toUpperCase() + z.slice(1)}</button>`).join("")}
|
||||
<span class="g-zoom" title="Zeitskala zoomen; du kannst auch an der Zeitskala nach links oder rechts ziehen"><button class="neben" data-a="kleiner" aria-label="Verkleinern">−</button><button class="neben" data-a="groesser" aria-label="Vergrößern">+</button></span>
|
||||
<button class="neben" data-a="heute">Heute</button>
|
||||
<select data-a="person" title="Nur Vorgänge dieser Person zeigen"><option value="">Alle Personen</option>${[...personen].sort((a, b) => a[1].localeCompare(b[1], "de")).map(([id, name]) => `<option value="${esc(id)}"${id === filter ? " selected" : ""}>${esc(name)}</option>`).join("")}</select>
|
||||
${filterKnopf("projekt", "Projekte", projektAus)}${filterKnopf("person", "Personal", personAus)}
|
||||
${anzahlAus ? `<span class="g-aus">${anzahlAus} ausgeblendet · <button class="verweis" data-a="aus-zeigen">${ausZeigen ? "wieder verbergen" : "einblenden"}</button>${ausZeigen ? ' · <button class="verweis" data-a="alle-ein">alle wieder einblenden</button>' : ""}</span>` : ""}
|
||||
<label class="schalter"><input type="checkbox" data-a="fertige"${mitFertigen ? " checked" : ""}> Abgeschlossene zeigen</label>
|
||||
<span class="hinweis">In eine Zelle klicken zum Bearbeiten: Enter speichert und geht eine Zeile tiefer, Tab eine Spalte weiter, Esc bricht ab. Zeile an der Nummer anfassen und verschieben. Spaltenbreite am Spaltenkopf ziehen, die Trennleiste blendet Spalten aus, an der Zeitskala ziehen zoomt. Balken ziehen verschiebt, rechter Rand ändert die Dauer. Freitag ist Reserve.</span>
|
||||
<span class="fehler g-meldung" role="status"></span>`;
|
||||
|
||||
const projekte = plan.projekte.filter((p) => mitFertigen || p.status !== "abgeschlossen");
|
||||
const projekte = projekteAlle.filter((p) => !projektAus.includes(p.id));
|
||||
const farbe = (p: Zeile, i: number) => (/^#[0-9a-f]{6}$/i.test(p.farbe ?? "") ? p.farbe : FARBEN[i % FARBEN.length]);
|
||||
|
||||
// Zeilennummern wie die Nr. in MS Project (Henning, 20.10.2026): fortlaufend über Projekte, Abschnitte
|
||||
// und Vorgänge; Zuklappen und der Personenfilter ändern sie nicht, Verschieben schon.
|
||||
// und Vorgänge; Zuklappen, Filter und Ausblenden ändern sie nicht, Verschieben schon.
|
||||
// Ausgeblendete abgeschlossene Projekte zählen hinten weiter, damit Verknüpfungen dorthin lesbar bleiben.
|
||||
const zeilenNr = new Map<string, number>();
|
||||
let zaehler = 0;
|
||||
for (const p of [...projekte, ...plan.projekte.filter((p) => !projekte.includes(p))]) {
|
||||
for (const p of [...projekteAlle, ...plan.projekte.filter((p) => !projekteAlle.includes(p))]) {
|
||||
zeilenNr.set(p.id, ++zaehler);
|
||||
for (const a of plan.abschnitte.filter((a) => a.projekt_id === p.id)) {
|
||||
zeilenNr.set(a.id, ++zaehler);
|
||||
@@ -185,15 +215,17 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
const abs = plan.abschnitte.filter((a) => a.projekt_id === p.id);
|
||||
const vs = plan.vorgaenge.filter((v) => abs.some((a) => a.id === v.abschnitt_id) && passt(v));
|
||||
if (filter && !vs.length) return;
|
||||
if (!sichtbarZeile(p.id)) return;
|
||||
const spanne = (l: Zeile[]) => (l.length ? { von: l.reduce((m, v) => (v.anfang < m ? v.anfang : m), l[0]!.anfang), bis: l.reduce((m, v) => (v.ende > m ? v.ende : m), l[0]!.ende) } : {});
|
||||
reihen.push({ art: "p", obj: p, projekt: p, farbe: f, ...spanne(vs) });
|
||||
if (zu.has(p.id)) return;
|
||||
for (const a of abs) {
|
||||
const av = vs.filter((v) => v.abschnitt_id === a.id);
|
||||
if (filter && !av.length) continue;
|
||||
if (!sichtbarZeile(a.id)) continue;
|
||||
reihen.push({ art: "a", obj: a, projekt: p, farbe: f, ...spanne(av) });
|
||||
if (zu.has(a.id)) continue;
|
||||
for (const v of av) reihen.push({ art: "v", obj: v, projekt: p, farbe: f, von: v.anfang, bis: v.ende });
|
||||
for (const v of av) if (sichtbarZeile(v.id)) reihen.push({ art: "v", obj: v, projekt: p, farbe: f, von: v.anfang, bis: v.ende });
|
||||
}
|
||||
});
|
||||
const zeileVon = new Map<string, number>();
|
||||
@@ -258,7 +290,7 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
if (r.art === "p") {
|
||||
const raten = (plan.zahlungen ?? []).filter((z) => z.projekt_id === o.id);
|
||||
links = `${nr}<span class="name ebene0" style="box-shadow:inset 4px 0 0 ${r.farbe}">${klapp}<span class="text" title="${esc(o.bezeichnung)}">${esc(o.nummer)} ${esc(o.bezeichnung)}${o.bauherr ? ` <small>${esc(o.bauherr)}</small>` : ""}</span>
|
||||
<span class="aktionen"><button class="plus" data-neu-abschnitt="${o.id}" title="Abschnitt hinzufügen">+</button></span></span>
|
||||
<span class="aktionen"><button class="plus" data-neu-abschnitt="${o.id}" title="Abschnitt hinzufügen">+</button><button class="auge-g" data-ausblenden="${o.id}" title="${ausgeblendet.has(o.id) ? "Wieder einblenden" : "Zeile ausblenden"}">${ausgeblendet.has(o.id) ? h.auge[0] : h.auge[1]}</button></span></span>
|
||||
${dauerZelle()}<span></span>${datumZelle(r.von)}${datumZelle(r.bis)}
|
||||
<span>${raten.length ? `<button class="verweis g-raten" data-raten="${o.id}" title="Zahlungsplan öffnen">€ ${raten.length} ${raten.length === 1 ? "Rate" : "Raten"}</button>`
|
||||
: Number(o.umsatz_netto) > 0 && o.zahlungsplan === "fest"
|
||||
@@ -269,7 +301,7 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
balken += raten.map((z) => `<div class="zahlung-ms ${esc(z.status ?? "geplant")}" data-raten="${o.id}" style="left:${x(z.termin) + W / 2 - 9}px;--farbe:${r.farbe}" title="${esc(z.bezeichnung)} · ${formatEuro(Number(z.netto))} netto · fällig ${formatDatum(z.termin)} · ${esc(z.status ?? "geplant")}">€</div>`).join("");
|
||||
} else if (r.art === "a") {
|
||||
links = `${nr}<span class="name ebene1">${klapp}<span class="text zelle" data-id="${o.id}" data-feld="abschnitt" title="Klicken zum Umbenennen">${esc(o.name)}</span>
|
||||
<span class="aktionen"><button class="plus" data-neu-vorgang="${o.id}" title="Vorgang hinzufügen">+</button><button class="weg" data-weg="abschnitte/${o.id}" title="Abschnitt mit allen Vorgängen löschen">✕</button></span></span>
|
||||
<span class="aktionen"><button class="plus" data-neu-vorgang="${o.id}" title="Vorgang hinzufügen">+</button><button class="auge-g" data-ausblenden="${o.id}" title="${ausgeblendet.has(o.id) ? "Wieder einblenden" : "Zeile ausblenden"}">${ausgeblendet.has(o.id) ? h.auge[0] : h.auge[1]}</button><button class="weg" data-weg="abschnitte/${o.id}" title="Abschnitt mit allen Vorgängen löschen">✕</button></span></span>
|
||||
${dauerZelle()}<span></span>${datumZelle(r.von)}${datumZelle(r.bis)}<span></span>`;
|
||||
if (r.von) balken = sammel() + beschriftung(x(r.von), x(r.bis!) + W, esc(o.name), r.von, r.bis);
|
||||
} else {
|
||||
@@ -277,7 +309,7 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
const zelle = (feld: string, klasse: string, inhaltHtml: string, titel: string) =>
|
||||
`<span class="${klasse} zelle" data-id="${o.id}" data-feld="${feld}" title="${titel}">${inhaltHtml}</span>`;
|
||||
links = `${nr}<span class="name ebene2">${zelle("name", "text", esc(o.name), "Bezeichnung")}
|
||||
<span class="aktionen"><button class="weg" data-weg="vorgaenge/${o.id}" title="Vorgang löschen">✕</button></span></span>
|
||||
<span class="aktionen"><button class="auge-g" data-ausblenden="${o.id}" title="${ausgeblendet.has(o.id) ? "Wieder einblenden" : "Zeile ausblenden"}">${ausgeblendet.has(o.id) ? h.auge[0] : h.auge[1]}</button><button class="weg" data-weg="vorgaenge/${o.id}" title="Vorgang löschen">✕</button></span></span>
|
||||
${zelle("dauer", "zahl", dauerText(ms ? 0 : Math.ceil(o.dauer)) + dauerHinweis(o), dauerTitel(o))}
|
||||
${zelle("vg", "vg", esc(vorgaengerText(linksVon(o.id), zeilenNr)), "Vorgänger: Zeilennummer, z. B. 5 oder 5AA+2")}
|
||||
${zelle("start", "zahl", tabellenDatum(o.anfang), "Anfang")}${zelle("ende", "zahl", tabellenDatum(o.ende), "Ende")}
|
||||
@@ -290,14 +322,15 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
: `<div class="balken vorgang${imKonflikt.has(o.id) ? " konflikt" : ""}" data-bar="${o.id}" style="left:${links0}px;width:${breite}px" title="${esc(o.name)} · ${formatDatum(o.anfang)} – ${formatDatum(o.ende)} · ${dauerText(Math.ceil(o.dauer))}">${reduziertHtml(o, links0)}<i class="griff-rechts" data-dauer="${o.id}"></i></div>`
|
||||
+ beschriftung(links0, links0 + breite, esc(o.name), o.anfang, o.ende, leute);
|
||||
}
|
||||
return `<div class="g-zeile ${r.art}" data-zeile="${o.id}" style="top:${i * ZEILE}px"><div class="g-links">${links}</div></div>
|
||||
return `<div class="g-zeile ${r.art}${ausgeblendet.has(o.id) ? " ausgeblendet" : ""}" data-zeile="${o.id}" style="top:${i * ZEILE}px"><div class="g-links">${links}</div></div>
|
||||
<div class="g-balken" style="top:${i * ZEILE}px">${balken}</div>`;
|
||||
}).join("");
|
||||
|
||||
// T16: Auslastung des eigenen Teams je Woche unter dem Plan; mit Personenfilter nur diese Person
|
||||
const team = plan.team ?? [];
|
||||
const nameVon = new Map(plan.leute.map((k) => [k.id, k.name]));
|
||||
const nurPerson = filter && team.includes(filter) ? filter : "";
|
||||
const gezeigtePersonen = [...personen.keys()].filter((p) => !personAus.includes(p));
|
||||
const nurPerson = filter && gezeigtePersonen.length === 1 && team.includes(gezeigtePersonen[0]!) ? gezeigtePersonen[0]! : "";
|
||||
const auslastungHtml = team.length && reihen.length ? (() => {
|
||||
const std = (n: number) => zahlText(Math.round(n * 10) / 10);
|
||||
const bloecke = (plan.auslastung ?? []).filter((w) => w.ab >= von && w.ab <= bis).map((w) => {
|
||||
@@ -342,7 +375,7 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
<svg class="g-pfeile" width="${tage * W}" height="${hoehe}">${pfeile}</svg>
|
||||
${zeilenHtml}${auslastungHtml}
|
||||
</div></div>
|
||||
${reihen.length ? "" : '<p class="hinweis" style="padding:16px">Noch keine Projekte im Terminplan.</p>'}</div>
|
||||
${reihen.length ? "" : `<p class="hinweis" style="padding:16px">${filter || projektAus.length || anzahlAus ? "Nichts passt zu den Filtern. Oben unter Projekte und Personal lassen sie sich wieder entfernen." : "Noch keine Projekte im Terminplan."}</p>`}</div>
|
||||
<div class="g-trenner" role="separator" aria-orientation="vertical" aria-label="Trennleiste zwischen Tabelle und Zeitplan" title="Ziehen: Spalten ein- oder ausblenden; Doppelklick: alle Spalten zeigen"></div>`;
|
||||
const box = rahmen.querySelector<HTMLElement>(".gantt")!;
|
||||
if (plan.ueberschneidungen.length) {
|
||||
@@ -440,9 +473,15 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
leiste.addEventListener("click", (ev) => {
|
||||
const b = (ev.target as HTMLElement).closest("button");
|
||||
if (b?.dataset.zoom) zoome(ZOOM[b.dataset.zoom]!);
|
||||
if (b?.dataset.a === "kleiner") zoome(W / 1.4);
|
||||
if (b?.dataset.a === "groesser") zoome(W * 1.4);
|
||||
if (b?.dataset.a === "heute") nachHeute();
|
||||
if (b?.dataset.filter) {
|
||||
const id = b.dataset.filter;
|
||||
h.filterMenue(b, { titel: id === "person" ? "Personal" : "Projekte", werte: filterWerte[id]!, aus: ansicht.filter[id] ?? [],
|
||||
fertig: (aus) => setzeAnsicht({ filter: { ...ansicht.filter, [id]: aus } }) });
|
||||
}
|
||||
if (b?.dataset.filterWeg) setzeAnsicht({ filter: { ...ansicht.filter, [b.dataset.filterWeg]: [] } });
|
||||
if (b?.dataset.a === "aus-zeigen") { ausZeigen = !ausZeigen; void terminplanSeite(h, plan); }
|
||||
if (b?.dataset.a === "alle-ein") { ausZeigen = false; setzeAnsicht({ aus: ansicht.aus.filter((id) => !alleIds.has(id)) }); }
|
||||
});
|
||||
// an der Zeitskala ziehen: nach rechts größer, nach links kleiner
|
||||
box.querySelector<HTMLElement>(".g-zeit")!.addEventListener("pointerdown", (ev) => {
|
||||
@@ -465,12 +504,16 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
document.addEventListener("pointermove", zieh);
|
||||
document.addEventListener("pointerup", los);
|
||||
});
|
||||
leiste.querySelector<HTMLSelectElement>('[data-a="person"]')!.onchange = (ev) => { merke("gantt-person", (ev.target as HTMLSelectElement).value); neuLaden(); };
|
||||
leiste.querySelector<HTMLInputElement>('[data-a="fertige"]')!.onchange = (ev) => { merke("gantt-fertige", (ev.target as HTMLInputElement).checked); neuLaden(); };
|
||||
|
||||
// Klicks in der linken Spalte
|
||||
box.addEventListener("click", async (ev) => {
|
||||
const t = ev.target as HTMLElement;
|
||||
const auge = t.closest<HTMLElement>("[data-ausblenden]");
|
||||
if (auge) {
|
||||
const id = auge.dataset.ausblenden!;
|
||||
return setzeAnsicht({ aus: ausgeblendet.has(id) ? ansicht.aus.filter((x) => x !== id) : [...ansicht.aus, id] });
|
||||
}
|
||||
if (t.dataset.klapp) {
|
||||
zu.has(t.dataset.klapp) ? zu.delete(t.dataset.klapp) : zu.add(t.dataset.klapp);
|
||||
merke("gantt-zu", [...zu]);
|
||||
|
||||
393
src/web/liste.ts
Normal file
393
src/web/liste.ts
Normal file
@@ -0,0 +1,393 @@
|
||||
// Tabellen mit Sortieren und Filtern wie in Excel (Henning, 20.10.2026), überall gleich:
|
||||
// Spaltenkopf anklicken öffnet das Menü (sortieren, als weitere Sortierung, suchen, Werte abhaken, bei Datum Zeiträume),
|
||||
// oben stehen Sortierung und Filter als Chips, das Auge blendet einzelne Zeilen aus, Ansichten lassen sich speichern.
|
||||
// Die Ansicht merkt sich das Programm je Benutzer auf dem Server, damit sie am Handy und im Büro gleich ist.
|
||||
|
||||
import { type Ansicht, type Richtung, type SpaltenWerte, LEER, ZEITRAEUME, ZEITRAUM_TEXT, ansichtAus, gleich, leereAnsicht, monatText, monatVon, passt, sortiere } from "../domain/ansicht.js";
|
||||
import { type Zeile, api, dialog, esc, heute } from "./ui.js";
|
||||
|
||||
export interface Spalte {
|
||||
/** fester Schlüssel, unter dem Filter und Sortierung gespeichert werden */
|
||||
id: string;
|
||||
titel: string;
|
||||
wert: (z: Zeile) => string;
|
||||
klasse?: string;
|
||||
art?: "text" | "zahl" | "datum";
|
||||
/** Wert für Filterliste und Suche; Standard ist der angezeigte Text */
|
||||
text?: (z: Zeile) => string;
|
||||
/** Wert zum Sortieren; bei Datum das ISO-Datum, bei Zahlen die Zahl */
|
||||
sortWert?: (z: Zeile) => string | number | null | undefined;
|
||||
/** Kopf statt des Titels, z. B. ein Haken */
|
||||
kopf?: string;
|
||||
/** ohne Sortieren und Filtern */
|
||||
fest?: boolean;
|
||||
}
|
||||
|
||||
export interface ListenOptionen {
|
||||
/** Name der Tabelle für die gespeicherte Ansicht, z. B. „aufgaben“ */
|
||||
schluessel: string;
|
||||
spalten: Spalte[];
|
||||
zeilen: Zeile[];
|
||||
klick?: (z: Zeile) => void;
|
||||
/** Ansicht, solange der Benutzer nichts geändert hat (und nach „Zurücksetzen“) */
|
||||
vorgabe?: Partial<Ansicht>;
|
||||
/** fertige Ansichten, z. B. „Meine Woche“ */
|
||||
vorlagen?: { name: string; ansicht: Partial<Ansicht> }[];
|
||||
/** für die Zeile unter der Tabelle: [Einzahl, Mehrzahl] */
|
||||
einheit?: [string, string];
|
||||
/** zusätzlicher Text unter der Tabelle, aus den sichtbaren Zeilen (z. B. eine Summe) */
|
||||
fuss?: (sichtbar: Zeile[]) => string;
|
||||
/** eingebettete Tabelle: Leiste nur bei aktiven Filtern, ohne gespeicherte Ansichten */
|
||||
klein?: boolean;
|
||||
zeilenKlasse?: (z: Zeile) => string;
|
||||
/** Text, wenn es gar keine Zeilen gibt */
|
||||
leer?: string;
|
||||
klasse?: string;
|
||||
}
|
||||
|
||||
interface Gespeichert { aktuell?: unknown; name?: string | null; ansichten?: { name: string; ansicht: unknown }[] }
|
||||
|
||||
let speicher: Record<string, Gespeichert> = {};
|
||||
const warten = new Map<string, ReturnType<typeof setTimeout>>();
|
||||
|
||||
/** Beim Start und nach einem Benutzerwechsel: die Ansichten des Benutzers holen */
|
||||
export async function ansichtenLaden(): Promise<void> {
|
||||
try { speicher = await api<Record<string, Gespeichert>>("ich/ansichten"); } catch { speicher = {}; }
|
||||
}
|
||||
|
||||
function merken(schluessel: string): void {
|
||||
clearTimeout(warten.get(schluessel));
|
||||
warten.set(schluessel, setTimeout(() => {
|
||||
warten.delete(schluessel);
|
||||
api(`ich/ansichten/${schluessel}`, "PUT", speicher[schluessel]).catch(() => { /* bleibt bis zum Neuladen erhalten */ });
|
||||
}, 500));
|
||||
}
|
||||
|
||||
/** Für Seiten ohne Tabelle (Terminplan): die aktuelle Ansicht lesen und merken */
|
||||
export function gespeicherteAnsicht(schluessel: string): Ansicht {
|
||||
const g = speicher[schluessel];
|
||||
return g?.aktuell ? ansichtAus(g.aktuell) : leereAnsicht();
|
||||
}
|
||||
export function ansichtMerken(schluessel: string, a: Ansicht): void {
|
||||
(speicher[schluessel] ??= {}).aktuell = { ...a, aus: a.aus.slice(-1000) };
|
||||
merken(schluessel);
|
||||
}
|
||||
|
||||
export const AUGE = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M2 12s3.5-7 10-7 10 7 10 7-3.5 7-10 7S2 12 2 12z"/><circle cx="12" cy="12" r="3"/></svg>';
|
||||
export const AUGE_ZU = '<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"><path d="M3 3l18 18M10.6 5.1A10 10 0 0 1 12 5c6.5 0 10 7 10 7a17 17 0 0 1-3.2 4.1M6.6 6.6C3.8 8.4 2 12 2 12s3.5 7 10 7c1.8 0 3.4-.5 4.8-1.3M9.9 9.9a3 3 0 0 0 4.2 4.2"/></svg>';
|
||||
const TRICHTER = '<svg viewBox="0 0 24 24" fill="currentColor" aria-hidden="true"><path d="M3 4h18l-7 8.5V19l-4 2v-8.5z"/></svg>';
|
||||
|
||||
const SORT_TEXT: Record<string, [string, string]> = {
|
||||
text: ["Von A bis Z sortieren", "Von Z bis A sortieren"],
|
||||
zahl: ["Nach Größe sortieren (aufsteigend)", "Nach Größe sortieren (absteigend)"],
|
||||
datum: ["Vom ältesten zum neuesten sortieren", "Vom neuesten zum ältesten sortieren"],
|
||||
};
|
||||
|
||||
/** Offenes Menü (Spaltenfilter oder Ansichten); es gibt immer höchstens eins */
|
||||
let offenesMenue: { schliessen: () => void } | null = null;
|
||||
addEventListener("hashchange", () => offenesMenue?.schliessen());
|
||||
|
||||
/** Ein schwebendes Menü an einem Knopf; am Handy als Blatt von unten */
|
||||
export function menue(anker: HTMLElement, html: string, klasse = ""): HTMLElement {
|
||||
offenesMenue?.schliessen();
|
||||
const m = document.createElement("div");
|
||||
m.className = `filter-menue ${klasse}`;
|
||||
m.setAttribute("role", "dialog");
|
||||
m.innerHTML = html;
|
||||
document.body.appendChild(m);
|
||||
const r = anker.getBoundingClientRect();
|
||||
if (innerWidth > 640) {
|
||||
const breite = m.offsetWidth;
|
||||
m.style.left = `${Math.max(8, Math.min(r.left, innerWidth - breite - 8))}px`;
|
||||
const unten = r.bottom + 4;
|
||||
m.style.top = `${unten + m.offsetHeight > innerHeight - 8 ? Math.max(8, r.top - m.offsetHeight - 4) : unten}px`;
|
||||
} else m.classList.add("blatt");
|
||||
const aussen = (ev: PointerEvent) => { if (!m.contains(ev.target as Node) && !anker.contains(ev.target as Node)) schliessen(); };
|
||||
const taste = (ev: KeyboardEvent) => { if (ev.key === "Escape") schliessen(); };
|
||||
const schliessen = () => {
|
||||
m.remove();
|
||||
removeEventListener("pointerdown", aussen, true);
|
||||
removeEventListener("keydown", taste);
|
||||
if (offenesMenue?.schliessen === schliessen) offenesMenue = null;
|
||||
};
|
||||
addEventListener("pointerdown", aussen, true);
|
||||
addEventListener("keydown", taste);
|
||||
offenesMenue = { schliessen };
|
||||
return m;
|
||||
}
|
||||
export const menueSchliessen = () => offenesMenue?.schliessen();
|
||||
|
||||
export interface FilterWert { wert: string; text: string; anzahl: number }
|
||||
|
||||
/**
|
||||
* Das Filtermenü einer Spalte wie in Excel: Sortieren (wenn `sortieren`), Zeitraum (wenn `zeit`), Suche und Werte mit Haken.
|
||||
* Meldet über `fertig` die abgewählten Werte und den Zeitraum.
|
||||
*/
|
||||
export function filterMenue(anker: HTMLElement, o: {
|
||||
titel: string; art?: Spalte["art"]; werte: FilterWert[]; aus: string[]; zeit?: string | null;
|
||||
sortiert?: Richtung | null; weitereSortierung?: boolean; sortieren?: (r: Richtung | null, dazu: boolean) => void;
|
||||
fertig: (aus: string[], zeit: string) => void;
|
||||
}): void {
|
||||
const [auf, ab] = SORT_TEXT[o.art ?? "text"]!;
|
||||
const aktiv = o.aus.length > 0 || !!o.zeit;
|
||||
const m = menue(anker, `<div class="fm-kopf"><b>${esc(o.titel)}</b><button type="button" class="fm-zu" data-m="zu" aria-label="Schließen">✕</button></div>
|
||||
${o.sortieren ? `<button type="button" class="fm-zeile${o.sortiert === "auf" ? " an" : ""}" data-m="auf"><span>↑</span>${auf}</button>
|
||||
<button type="button" class="fm-zeile${o.sortiert === "ab" ? " an" : ""}" data-m="ab"><span>↓</span>${ab}</button>
|
||||
${o.weitereSortierung ? `<div class="fm-weitere"><span>+ als weitere Sortierung</span><button type="button" class="neben" data-m="dazu-auf" title="aufsteigend">↑</button><button type="button" class="neben" data-m="dazu-ab" title="absteigend">↓</button></div>` : ""}
|
||||
${o.sortiert ? '<button type="button" class="fm-zeile" data-m="sort-weg"><span>✕</span>Sortierung entfernen</button>' : ""}<hr>` : ""}
|
||||
<button type="button" class="fm-zeile" data-m="filter-weg"${aktiv ? "" : " disabled"}><span>${TRICHTER}</span>Filter entfernen</button>
|
||||
${o.art === "datum" ? `<label class="fm-zeit">Datumsfilter <select data-m="zeit"><option value="">alle Daten</option>${ZEITRAEUME.map(([k, t]) => `<option value="${k}"${k === o.zeit ? " selected" : ""}>${t}</option>`).join("")}</select></label>` : ""}
|
||||
<input type="search" class="fm-suche" placeholder="Suchen" aria-label="Werte durchsuchen">
|
||||
<div class="fm-werte"><label class="fm-alle"><input type="checkbox" data-m="alle"> <span>(Alles auswählen)</span></label>
|
||||
${o.werte.map((w, i) => `<label data-i="${i}"><input type="checkbox" data-w="${i}"${o.aus.includes(w.wert) ? "" : " checked"}> <span>${esc(w.text)}</span><small>${w.anzahl || ""}</small></label>`).join("")}
|
||||
${o.werte.length ? "" : '<p class="hinweis">Keine Werte.</p>'}</div>
|
||||
<div class="knoepfe"><button type="button" class="neben" data-m="zu">Abbrechen</button><button type="button" class="haupt" data-m="ok">OK</button></div>`);
|
||||
const suche = m.querySelector<HTMLInputElement>(".fm-suche")!;
|
||||
const kasten = (i: number) => m.querySelector<HTMLInputElement>(`[data-w="${i}"]`)!;
|
||||
const alle = m.querySelector<HTMLInputElement>('[data-m="alle"]')!;
|
||||
const ok = m.querySelector<HTMLButtonElement>('[data-m="ok"]')!;
|
||||
const sichtbar = () => o.werte.map((_, i) => i).filter((i) => !m.querySelector<HTMLElement>(`label[data-i="${i}"]`)!.hidden);
|
||||
const stand = () => {
|
||||
const s = sichtbar(), an = s.filter((i) => kasten(i).checked).length;
|
||||
alle.checked = s.length > 0 && an === s.length;
|
||||
alle.indeterminate = an > 0 && an < s.length;
|
||||
ok.disabled = an === 0 && o.werte.length > 0;
|
||||
};
|
||||
suche.oninput = () => {
|
||||
const q = suche.value.trim().toLocaleLowerCase("de");
|
||||
o.werte.forEach((w, i) => { m.querySelector<HTMLElement>(`label[data-i="${i}"]`)!.hidden = !!q && !w.text.toLocaleLowerCase("de").includes(q); });
|
||||
m.querySelector<HTMLElement>(".fm-alle span")!.textContent = q ? "(Alle Suchergebnisse auswählen)" : "(Alles auswählen)";
|
||||
stand();
|
||||
};
|
||||
m.addEventListener("change", (ev) => {
|
||||
if (ev.target === alle) for (const i of sichtbar()) kasten(i).checked = alle.checked;
|
||||
stand();
|
||||
});
|
||||
stand();
|
||||
if (innerWidth > 640) suche.focus();
|
||||
m.addEventListener("click", (ev) => {
|
||||
const b = (ev.target as HTMLElement).closest<HTMLElement>("[data-m]");
|
||||
const was = b?.dataset.m;
|
||||
if (!was || b instanceof HTMLInputElement || b instanceof HTMLSelectElement) return;
|
||||
if (was === "zu") return menueSchliessen();
|
||||
if (["auf", "ab", "dazu-auf", "dazu-ab", "sort-weg"].includes(was)) {
|
||||
menueSchliessen();
|
||||
return o.sortieren?.(was === "sort-weg" ? null : was.endsWith("ab") ? "ab" : "auf", was.startsWith("dazu"));
|
||||
}
|
||||
if (was === "filter-weg") { menueSchliessen(); return o.fertig([], ""); }
|
||||
if (was === "ok") {
|
||||
// wie Excel: mit Suchbegriff gilt nur, was gefunden und abgehakt ist
|
||||
const s = new Set(sichtbar());
|
||||
const aus = o.werte.filter((w, i) => !(s.has(i) && kasten(i).checked)).map((w) => w.wert);
|
||||
const zeit = m.querySelector<HTMLSelectElement>('[data-m="zeit"]')?.value ?? "";
|
||||
menueSchliessen();
|
||||
o.fertig(aus, zeit);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/** Text eines Filters für den Chip: „Kategorie: Büro, Einkauf“ oder „Kategorie: ohne Büro“ */
|
||||
export function filterText(alleWerte: FilterWert[], aus: string[], zeit?: string | null): string {
|
||||
const teile: string[] = [];
|
||||
if (zeit) teile.push(ZEITRAUM_TEXT[zeit] ?? zeit);
|
||||
if (aus.length) {
|
||||
const text = (w: string) => alleWerte.find((x) => x.wert === w)?.text ?? w;
|
||||
const an = alleWerte.filter((w) => !aus.includes(w.wert));
|
||||
const liste = (l: string[]) => (l.length > 3 ? `${l.slice(0, 3).join(", ")} +${l.length - 3}` : l.join(", "));
|
||||
teile.push(an.length && an.length <= aus.length ? liste(an.map((w) => w.text)) : `ohne ${liste(aus.map(text))}`);
|
||||
}
|
||||
return teile.join(", ");
|
||||
}
|
||||
|
||||
/** Eine Tabelle mit Sortieren, Filtern, Ausblenden und Ansichten */
|
||||
export function liste(o: ListenOptionen): HTMLElement {
|
||||
const wurzel = document.createElement("div");
|
||||
wurzel.className = `liste${o.klein ? " klein" : ""}`;
|
||||
const g = (speicher[o.schluessel] ??= {});
|
||||
const vorgabe = ansichtAus({ ...leereAnsicht(), ...o.vorgabe });
|
||||
const vorlagen = (o.vorlagen ?? []).map((v) => ({ name: v.name, ansicht: ansichtAus({ ...leereAnsicht(), ...v.ansicht }) }));
|
||||
const basis = (name: string | null | undefined): Ansicht => {
|
||||
const s = g.ansichten?.find((x) => x.name === name);
|
||||
return s ? ansichtAus(s.ansicht) : vorlagen.find((x) => x.name === name)?.ansicht ?? vorgabe;
|
||||
};
|
||||
let name: string | null = g.name && (g.ansichten?.some((x) => x.name === g.name) || vorlagen.some((x) => x.name === g.name)) ? g.name : null;
|
||||
let a: Ansicht = g.aktuell ? ansichtAus(g.aktuell) : basis(name);
|
||||
let zeigeAus = false;
|
||||
const setze = (neu: Ansicht, neuerName = name) => {
|
||||
a = { ...neu, aus: neu.aus.slice(-1000) };
|
||||
name = neuerName;
|
||||
Object.assign(g, { aktuell: a, name });
|
||||
merken(o.schluessel);
|
||||
zeichne();
|
||||
};
|
||||
|
||||
// Werte jeder Spalte einmal ausrechnen
|
||||
const z = o.zeilen;
|
||||
const ids = z.map((x, i) => String(x.id ?? i));
|
||||
const tmp = document.createElement("div");
|
||||
const klartext = (html: string) => { tmp.innerHTML = html; return (tmp.textContent ?? "").replace(/\s+/g, " ").trim(); };
|
||||
const beweglich = o.spalten.filter((s) => !s.fest);
|
||||
const sw: SpaltenWerte[] = beweglich.map((s) => {
|
||||
const sortWerte = z.map((x) => (s.sortWert ? s.sortWert(x) : undefined));
|
||||
const werte = z.map((x, i) => (s.art === "datum" ? monatVon(sortWerte[i] as string | null) : (s.text ? s.text(x) : klartext(s.wert(x))) || LEER));
|
||||
return { id: s.id, art: s.art, wert: (i) => werte[i]!, sort: (i) => (s.sortWert ? sortWerte[i] : werte[i] === LEER ? null : werte[i]) };
|
||||
});
|
||||
const spalte = (id: string) => beweglich.find((s) => s.id === id)!;
|
||||
const werteVon = (id: string): FilterWert[] => {
|
||||
const s = sw.find((x) => x.id === id)!;
|
||||
const h = heute();
|
||||
const n = new Map<string, number>();
|
||||
z.forEach((_, i) => { if (passt(i, a, sw, h, id)) n.set(s.wert(i), (n.get(s.wert(i)) ?? 0) + 1); });
|
||||
for (const w of a.filter[id] ?? []) if (!n.has(w)) n.set(w, 0);
|
||||
const erster = new Map<string, number>();
|
||||
z.forEach((_, i) => { if (!erster.has(s.wert(i))) erster.set(s.wert(i), i); });
|
||||
return [...n].map(([wert, anzahl]) => ({ wert, anzahl, text: s.art === "datum" ? monatText(wert) : wert }))
|
||||
.sort((x, y) => (x.wert === LEER ? 1 : y.wert === LEER ? -1 : s.art === "datum" ? (x.wert < y.wert ? -1 : 1)
|
||||
: s.art === "zahl" && erster.has(x.wert) && erster.has(y.wert) ? Number(s.sort(erster.get(x.wert)!)) - Number(s.sort(erster.get(y.wert)!))
|
||||
: x.text.localeCompare(y.text, "de", { numeric: true })));
|
||||
};
|
||||
const alleWerte = (id: string) => {
|
||||
const s = sw.find((x) => x.id === id)!;
|
||||
return [...new Set(z.map((_, i) => s.wert(i)))].map((w) => ({ wert: w, text: s.art === "datum" ? monatText(w) : w, anzahl: 0 }));
|
||||
};
|
||||
|
||||
function zeichne(): void {
|
||||
const h = heute();
|
||||
const ausSet = new Set(a.aus);
|
||||
const gefiltert = z.map((_, i) => i).filter((i) => passt(i, a, sw, h));
|
||||
const versteckt = gefiltert.filter((i) => ausSet.has(ids[i]!));
|
||||
const zeigen = sortiere(zeigeAus ? gefiltert : gefiltert.filter((i) => !ausSet.has(ids[i]!)), a.sort, sw);
|
||||
const filterIds = beweglich.map((s) => s.id).filter((id) => a.filter[id]?.length || a.zeit[id]);
|
||||
const geaendert = !gleich(a, basis(name));
|
||||
|
||||
const sortChip = a.sort.length ? `<span class="chip sort"><span>Sortiert: ${a.sort.map(([id, r], n) => `${a.sort.length > 1 ? `${n + 1}. ` : ""}${esc(spalte(id)?.titel ?? id)} ${r === "auf" ? "↑" : "↓"}`).join(" · ")}</span><button type="button" data-a="sort-weg" aria-label="Sortierung entfernen">✕</button></span>` : "";
|
||||
const chips = filterIds.map((id) => `<span class="chip"><button type="button" class="chip-text" data-menue="${id}">${TRICHTER}${esc(spalte(id).titel)}: ${esc(filterText(alleWerte(id), a.filter[id] ?? [], a.zeit[id]))}</button><button type="button" data-chip-weg="${id}" aria-label="Filter ${esc(spalte(id).titel)} entfernen">✕</button></span>`).join("");
|
||||
const leisteZeigen = !o.klein || filterIds.length || (a.sort.length && !gleich({ ...a, filter: {}, zeit: {}, aus: [] }, { ...vorgabe, filter: {}, zeit: {}, aus: [] }));
|
||||
const leiste = leisteZeigen ? `<div class="liste-leiste">
|
||||
${o.klein ? "" : `<button type="button" class="neben ansicht-knopf" data-a="ansichten" aria-haspopup="true">Ansicht: <b>${esc(name ?? "Standard")}</b>${geaendert ? " <i>geändert</i>" : ""} ▾</button>`}
|
||||
${o.klein ? "" : '<button type="button" class="neben nur-schmal" data-a="spalten" aria-haspopup="true">Sortieren und filtern ▾</button>'}
|
||||
${sortChip}${chips}
|
||||
${geaendert ? '<button type="button" class="verweis" data-a="zuruecksetzen">Zurücksetzen</button>' : ""}</div>` : "";
|
||||
|
||||
const kopf = o.spalten.map((s) => {
|
||||
if (s.fest) return `<th class="${s.klasse ?? ""}">${s.kopf ?? esc(s.titel)}</th>`;
|
||||
const nr = a.sort.findIndex(([id]) => id === s.id);
|
||||
const r = nr >= 0 ? a.sort[nr]![1] : null;
|
||||
const gefiltertHier = filterIds.includes(s.id);
|
||||
return `<th class="${s.klasse ?? ""}${r || gefiltertHier ? " aktiv" : ""}"${r ? ` aria-sort="${r === "auf" ? "ascending" : "descending"}"` : ""}>
|
||||
<button type="button" class="th-knopf" data-menue="${s.id}" title="Sortieren und filtern">${s.kopf ?? esc(s.titel)}<span class="th-zeichen">${r ? `${r === "auf" ? "↑" : "↓"}${a.sort.length > 1 ? `<sup>${nr + 1}</sup>` : ""}` : ""}${gefiltertHier ? TRICHTER : ""}<i>▾</i></span></button></th>`;
|
||||
}).join("");
|
||||
const zeile = (i: number) => {
|
||||
const x = z[i]!, weg = ausSet.has(ids[i]!);
|
||||
return `<tr data-i="${i}" class="${o.klick ? "klickbar" : ""}${weg ? " ausgeblendet" : ""} ${o.zeilenKlasse?.(x) ?? ""}">${o.spalten.map((s) => `<td class="${s.klasse ?? ""}">${s.wert(x)}</td>`).join("")}
|
||||
<td class="auge-spalte"><button type="button" class="auge" data-aus="${esc(ids[i])}" title="${weg ? "Wieder einblenden" : "Zeile ausblenden"}" aria-label="${weg ? "Wieder einblenden" : "Zeile ausblenden"}">${weg ? AUGE : AUGE_ZU}</button></td></tr>`;
|
||||
};
|
||||
const breite = o.spalten.length + 1;
|
||||
const rumpf = !z.length ? `<tr class="leer"><td colspan="${breite}">${esc(o.leer ?? "Noch nichts eingetragen.")}</td></tr>`
|
||||
: !zeigen.length ? `<tr class="leer"><td colspan="${breite}">${versteckt.length ? "Alle passenden Zeilen sind ausgeblendet." : "Nichts passt zu den Filtern."} <button type="button" class="verweis" data-a="${versteckt.length ? "aus-zeigen" : "filter-alle-weg"}">${versteckt.length ? "Einblenden" : "Filter entfernen"}</button></td></tr>`
|
||||
: zeigen.map(zeile).join("");
|
||||
const [eins, mehr] = o.einheit ?? ["Eintrag", "Einträge"];
|
||||
const sichtbar = zeigen.length;
|
||||
const anzahl = !z.length ? "" : `${sichtbar === z.length ? `${z.length} ${z.length === 1 ? eins : mehr}` : `${sichtbar} von ${z.length} ${z.length === 1 ? eins : mehr}`}${versteckt.length
|
||||
? ` · ${versteckt.length} ausgeblendet · <button type="button" class="verweis" data-a="aus-zeigen">${zeigeAus ? "wieder verbergen" : "einblenden"}</button>${zeigeAus ? ' · <button type="button" class="verweis" data-a="alle-ein">alle wieder einblenden</button>' : ""}` : ""}`;
|
||||
wurzel.innerHTML = `${leiste}<div class="tabelle-rolle"><table class="${o.klasse ?? ""}"><thead><tr>${kopf}<th class="auge-spalte" aria-label="Ausblenden"></th></tr></thead><tbody>${rumpf}</tbody></table></div>
|
||||
${anzahl && (!o.klein || sichtbar !== z.length || versteckt.length) ? `<p class="anzahl">${anzahl}</p>` : ""}${o.fuss ? o.fuss(zeigen.filter((i) => !ausSet.has(ids[i]!)).map((i) => z[i]!)) : ""}`;
|
||||
}
|
||||
|
||||
function spaltenMenue(id: string, anker: HTMLElement): void {
|
||||
const s = spalte(id);
|
||||
const nr = a.sort.findIndex(([x]) => x === id);
|
||||
filterMenue(anker, {
|
||||
titel: s.titel, art: s.art, werte: werteVon(id), aus: a.filter[id] ?? [], zeit: a.zeit[id],
|
||||
sortiert: nr >= 0 ? a.sort[nr]![1] : null, weitereSortierung: a.sort.some(([x]) => x !== id),
|
||||
sortieren: (r, dazu) => {
|
||||
const ohne = a.sort.filter(([x]) => x !== id);
|
||||
setze({ ...a, sort: r === null ? ohne : dazu ? [...ohne, [id, r]] : [[id, r]] });
|
||||
},
|
||||
fertig: (aus, zeit) => {
|
||||
const filter = { ...a.filter }, zeiten = { ...a.zeit };
|
||||
if (aus.length) filter[id] = aus; else delete filter[id];
|
||||
if (zeit) zeiten[id] = zeit; else delete zeiten[id];
|
||||
setze({ ...a, filter, zeit: zeiten });
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
function ansichtenMenue(anker: HTMLElement): void {
|
||||
const eigene = g.ansichten ?? [];
|
||||
const geaendert = !gleich(a, basis(name));
|
||||
const eintrag = (n: string | null, text: string) => `<button type="button" class="fm-zeile${n === name ? " an" : ""}" data-v="${esc(n ?? "")}"><span>${n === name ? "✓" : ""}</span>${esc(text)}</button>`;
|
||||
const m = menue(anker, `<div class="fm-kopf"><b>Ansichten</b><button type="button" class="fm-zu" data-m="zu" aria-label="Schließen">✕</button></div>
|
||||
${eintrag(null, "Standard")}${vorlagen.filter((v) => !eigene.some((e) => e.name === v.name)).map((v) => eintrag(v.name, v.name)).join("")}${eigene.map((v) => eintrag(v.name, v.name)).join("")}<hr>
|
||||
<button type="button" class="fm-zeile" data-m="neu"><span>+</span>Aktuelle Ansicht speichern …</button>
|
||||
${name && eigene.some((e) => e.name === name) && geaendert ? `<button type="button" class="fm-zeile" data-m="ueber"><span>↻</span>„${esc(name)}“ mit der aktuellen Ansicht überschreiben</button>` : ""}
|
||||
${name && eigene.some((e) => e.name === name) ? `<button type="button" class="fm-zeile" data-m="weg"><span>✕</span>„${esc(name)}“ löschen</button>` : ""}
|
||||
<p class="hinweis">Eine Ansicht merkt sich Sortierung, Filter und ausgeblendete Zeilen.</p>`, "ansichten-menue");
|
||||
m.addEventListener("click", async (ev) => {
|
||||
const b = (ev.target as HTMLElement).closest<HTMLElement>("[data-v],[data-m]");
|
||||
if (!b) return;
|
||||
if (b.dataset.v !== undefined) { menueSchliessen(); return setze(basis(b.dataset.v || null), b.dataset.v || null); }
|
||||
const was = b.dataset.m;
|
||||
menueSchliessen();
|
||||
if (was === "neu") {
|
||||
const r = await dialog("Ansicht speichern", [{ name: "name", titel: "Name der Ansicht", pflicht: true, hilfe: "z. B. Meine Woche" }], {}, false);
|
||||
if (r?.aktion !== "speichern") return;
|
||||
const n = String(r.daten.name).slice(0, 40);
|
||||
g.ansichten = [...eigene.filter((e) => e.name !== n), { name: n, ansicht: a }];
|
||||
setze(a, n);
|
||||
} else if (was === "ueber" && name) {
|
||||
g.ansichten = eigene.map((e) => (e.name === name ? { name, ansicht: a } : e));
|
||||
setze(a, name);
|
||||
} else if (was === "weg" && name) {
|
||||
g.ansichten = eigene.filter((e) => e.name !== name);
|
||||
setze(a, vorlagen.some((v) => v.name === name) ? name : null);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function spaltenAuswahl(anker: HTMLElement): void {
|
||||
const m = menue(anker, `<div class="fm-kopf"><b>Sortieren und filtern nach</b><button type="button" class="fm-zu" data-m="zu" aria-label="Schließen">✕</button></div>
|
||||
${beweglich.map((s) => `<button type="button" class="fm-zeile" data-s="${s.id}"><span>${a.sort.some(([x]) => x === s.id) || a.filter[s.id] || a.zeit[s.id] ? "•" : ""}</span>${esc(s.titel)}</button>`).join("")}`);
|
||||
m.addEventListener("click", (ev) => {
|
||||
const b = (ev.target as HTMLElement).closest<HTMLElement>("[data-s],[data-m]");
|
||||
if (b?.dataset.m === "zu") return menueSchliessen();
|
||||
if (b?.dataset.s) spaltenMenue(b.dataset.s, anker);
|
||||
});
|
||||
}
|
||||
|
||||
wurzel.addEventListener("click", (ev) => {
|
||||
const t = ev.target as HTMLElement;
|
||||
const knopf = t.closest<HTMLElement>("[data-menue],[data-aus],[data-chip-weg],[data-a]");
|
||||
if (knopf && wurzel.contains(knopf)) {
|
||||
ev.stopPropagation();
|
||||
if (knopf.dataset.menue) return spaltenMenue(knopf.dataset.menue, knopf);
|
||||
if (knopf.dataset.aus) {
|
||||
const id = knopf.dataset.aus;
|
||||
return setze({ ...a, aus: a.aus.includes(id) ? a.aus.filter((x) => x !== id) : [...a.aus, id] });
|
||||
}
|
||||
if (knopf.dataset.chipWeg) {
|
||||
const filter = { ...a.filter }, zeit = { ...a.zeit };
|
||||
delete filter[knopf.dataset.chipWeg];
|
||||
delete zeit[knopf.dataset.chipWeg];
|
||||
return setze({ ...a, filter, zeit });
|
||||
}
|
||||
switch (knopf.dataset.a) {
|
||||
case "sort-weg": return setze({ ...a, sort: [] });
|
||||
case "zuruecksetzen": zeigeAus = false; return setze(basis(name));
|
||||
case "filter-alle-weg": return setze({ ...a, filter: {}, zeit: {} });
|
||||
case "aus-zeigen": zeigeAus = !zeigeAus; return zeichne();
|
||||
case "alle-ein": zeigeAus = false; return setze({ ...a, aus: a.aus.filter((x) => !ids.includes(x)) });
|
||||
case "ansichten": return ansichtenMenue(knopf);
|
||||
case "spalten": return spaltenAuswahl(knopf);
|
||||
}
|
||||
return;
|
||||
}
|
||||
// Zeile anklicken öffnet sie; Links, Knöpfe und Eingaben in der Zeile behalten ihre eigene Wirkung
|
||||
if (!o.klick || t.closest("a,button,input,select,label,textarea")) return;
|
||||
const tr = t.closest<HTMLElement>("tr[data-i]");
|
||||
if (tr && wurzel.contains(tr)) o.klick(z[Number(tr.dataset.i)]!);
|
||||
});
|
||||
|
||||
zeichne();
|
||||
return wurzel;
|
||||
}
|
||||
@@ -3,7 +3,8 @@
|
||||
|
||||
import { formatEuro } from "../domain/geld.js";
|
||||
import { ABWESENHEIT_TEXT, modellText, type AbwesenheitArt } from "../domain/personal.js";
|
||||
import { type Feld, type Zeile, api, dat, dialog, esc, heute, inhalt, seite, tabelle } from "./ui.js";
|
||||
import { type Feld, type Zeile, api, dat, dialog, esc, heute, inhalt, seite } from "./ui.js";
|
||||
import { liste as tabelle } from "./liste.js";
|
||||
import { entscheiden } from "./urlaub.js";
|
||||
|
||||
const WT = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"];
|
||||
@@ -31,13 +32,17 @@ export async function personalSeite(): Promise<void> {
|
||||
inhalt.insertAdjacentHTML("beforeend", '<p class="hinweis leer">Noch keine Mitarbeiter. Lege einen an oder gib einem Kontakt die Rolle „Mitarbeiter“.</p>');
|
||||
return;
|
||||
}
|
||||
inhalt.appendChild(tabelle([
|
||||
{ titel: "Name", wert: (z) => `${esc(z.name)}${z.antraege ? ` <span class="marke schlecht">${z.antraege} Antrag${z.antraege > 1 ? "e" : ""}</span>` : ""}` },
|
||||
{ titel: "Arbeitszeit", wert: (z) => esc(modellText(z.stunden)) + (z.eigenesModell ? "" : ' <small class="hinweis">(Vorgabe)</small>'), klasse: "optional" },
|
||||
{ titel: "Heute", wert: (z) => heuteText(z.heute) },
|
||||
{ titel: "Resturlaub", wert: (z) => `${tageText(z.urlaub.rest)} <small class="hinweis">von ${zahl(z.urlaub.anspruch + z.urlaub.uebertrag)}</small>` },
|
||||
{ titel: "Zugang", wert: (z) => (z.anmeldename ? esc(z.anmeldename) : '<span class="hinweis">keiner</span>'), klasse: "optional" },
|
||||
], liste, (z) => { location.hash = `mitarbeiter-${z.id}`; }));
|
||||
inhalt.appendChild(tabelle({
|
||||
schluessel: "personal", einheit: ["Person", "Personen"],
|
||||
spalten: [
|
||||
{ id: "name", titel: "Name", text: (z) => z.name, wert: (z) => `${esc(z.name)}${z.antraege ? ` <span class="marke schlecht">${z.antraege} Antrag${z.antraege > 1 ? "e" : ""}</span>` : ""}` },
|
||||
{ id: "arbeitszeit", titel: "Arbeitszeit", text: (z) => modellText(z.stunden), wert: (z) => esc(modellText(z.stunden)) + (z.eigenesModell ? "" : ' <small class="hinweis">(Vorgabe)</small>'), klasse: "optional" },
|
||||
{ id: "heute", titel: "Heute", wert: (z) => heuteText(z.heute) },
|
||||
{ id: "rest", titel: "Resturlaub", art: "zahl", text: (z) => tageText(z.urlaub.rest), sortWert: (z) => z.urlaub.rest, wert: (z) => `${tageText(z.urlaub.rest)} <small class="hinweis">von ${zahl(z.urlaub.anspruch + z.urlaub.uebertrag)}</small>` },
|
||||
{ id: "zugang", titel: "Zugang", text: (z) => z.anmeldename ?? "", wert: (z) => (z.anmeldename ? esc(z.anmeldename) : '<span class="hinweis">keiner</span>'), klasse: "optional" },
|
||||
],
|
||||
zeilen: liste, klick: (z) => { location.hash = `mitarbeiter-${z.id}`; },
|
||||
}));
|
||||
}
|
||||
|
||||
async function neuerMitarbeiter(): Promise<void> {
|
||||
@@ -96,11 +101,15 @@ export async function mitarbeiterSeite(kontaktId: string, inhaber: boolean): Pro
|
||||
// Modelle
|
||||
const mZiel = raster.querySelector("#modelle")!;
|
||||
if (eigeneModelle.length) {
|
||||
mZiel.appendChild(tabelle([
|
||||
{ titel: "Gültig ab", wert: (m) => dat(m.gueltig_ab) },
|
||||
...WT.map((t, i) => ({ titel: t, wert: (m: Zeile) => zahl(m.stunden[i]) || "–", klasse: "zahl" })),
|
||||
{ titel: "Woche", wert: (m) => `${zahl(m.stunden.reduce((s: number, h: number) => s + h, 0))} Std.`, klasse: "zahl" },
|
||||
], eigeneModelle, (m) => void modellDialog(m)));
|
||||
mZiel.appendChild(tabelle({
|
||||
schluessel: "arbeitszeitmodelle", klein: true,
|
||||
spalten: [
|
||||
{ id: "ab", titel: "Gültig ab", art: "datum", wert: (m) => dat(m.gueltig_ab), sortWert: (m) => m.gueltig_ab },
|
||||
...WT.map((t, i) => ({ id: `t${i}`, titel: t, art: "zahl" as const, wert: (m: Zeile) => zahl(m.stunden[i]) || "–", sortWert: (m: Zeile) => m.stunden[i], klasse: "zahl" })),
|
||||
{ id: "woche", titel: "Woche", art: "zahl", wert: (m) => `${zahl(m.stunden.reduce((s: number, h: number) => s + h, 0))} Std.`, sortWert: (m) => m.stunden.reduce((s: number, h: number) => s + h, 0), klasse: "zahl" },
|
||||
],
|
||||
zeilen: eigeneModelle, klick: (m) => void modellDialog(m),
|
||||
}));
|
||||
} else mZiel.innerHTML = `<p class="hinweis">Noch kein eigenes Modell. Bis dahin gilt die Vorgabe: ${esc(modellText(ich?.stunden ?? [8, 8, 8, 8, 8, 0, 0]))}</p>`;
|
||||
|
||||
// Verfügbarkeit: ganz frei grau schraffiert, teilweise halb gefüllt mit Zahl (M8)
|
||||
@@ -115,13 +124,17 @@ export async function mitarbeiterSeite(kontaktId: string, inhaber: boolean): Pro
|
||||
|
||||
// Abwesenheiten
|
||||
const aZiel = raster.querySelector("#abw")!;
|
||||
if (eigeneAbw.length) aZiel.appendChild(tabelle([
|
||||
{ titel: "Art", wert: (a) => esc(ABWESENHEIT_TEXT[a.art as AbwesenheitArt]) },
|
||||
{ titel: "Zeitraum", wert: (a) => (a.von === a.bis ? `${WT[wtag(a.von)]} ${dat(a.von)}` : `${dat(a.von)} – ${dat(a.bis)}`) },
|
||||
{ titel: "Umfang", wert: (a) => (a.halbtag ? "halber Tag" : a.stunden ? `${zahl(a.stunden)} Std.` : "ganztags") },
|
||||
{ titel: "Status", wert: (a) => `<span class="marke ${a.status === "genehmigt" ? "gut" : a.status === "beantragt" ? "offen" : "grau"}">${a.status === "beantragt" ? "beantragt, entscheiden" : esc(a.status)}</span>` },
|
||||
{ titel: "Notiz", wert: (a) => esc(a.notiz ?? ""), klasse: "optional" },
|
||||
], eigeneAbw, (a) => void (a.status === "beantragt" && a.art === "urlaub" ? entscheiden(a.id).then((ja) => { if (ja) void neuLaden(); }) : abwDialog(a))));
|
||||
if (eigeneAbw.length) aZiel.appendChild(tabelle({
|
||||
schluessel: "abwesenheiten", klein: true, einheit: ["Abwesenheit", "Abwesenheiten"],
|
||||
spalten: [
|
||||
{ id: "art", titel: "Art", wert: (a) => esc(ABWESENHEIT_TEXT[a.art as AbwesenheitArt]) },
|
||||
{ id: "zeitraum", titel: "Zeitraum", art: "datum", sortWert: (a) => a.von, wert: (a) => (a.von === a.bis ? `${WT[wtag(a.von)]} ${dat(a.von)}` : `${dat(a.von)} – ${dat(a.bis)}`) },
|
||||
{ id: "umfang", titel: "Umfang", wert: (a) => (a.halbtag ? "halber Tag" : a.stunden ? `${zahl(a.stunden)} Std.` : "ganztags") },
|
||||
{ id: "status", titel: "Status", text: (a) => a.status, wert: (a) => `<span class="marke ${a.status === "genehmigt" ? "gut" : a.status === "beantragt" ? "offen" : "grau"}">${a.status === "beantragt" ? "beantragt, entscheiden" : esc(a.status)}</span>` },
|
||||
{ id: "notiz", titel: "Notiz", wert: (a) => esc(a.notiz ?? ""), klasse: "optional" },
|
||||
],
|
||||
zeilen: eigeneAbw, klick: (a) => void (a.status === "beantragt" && a.art === "urlaub" ? entscheiden(a.id).then((ja) => { if (ja) void neuLaden(); }) : abwDialog(a)),
|
||||
}));
|
||||
else aZiel.innerHTML = '<p class="hinweis">Keine Abwesenheiten eingetragen.</p>';
|
||||
|
||||
// ---------- Dialoge ----------
|
||||
|
||||
@@ -3,6 +3,7 @@
|
||||
|
||||
import { type Abzugsart, dauerText, minuten, rechneTag, regelPause, uhrzeit } from "../domain/zeit.js";
|
||||
import { type Zeile, api, dat, dateiSpeichern, esc, heute, inhalt, lies, merke, seite } from "./ui.js";
|
||||
import { liste as tabelleMit } from "./liste.js";
|
||||
|
||||
const WT = ["So", "Mo", "Di", "Mi", "Do", "Fr", "Sa"];
|
||||
const WT_LANG = ["Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag"];
|
||||
@@ -266,14 +267,22 @@ export async function stundenSeite(): Promise<void> {
|
||||
return `<div><small>${esc(l.name)}</small><b>${dauerText(ist)} Std.</b>${soll ? `<small>Soll ${dauerText(soll)} · <span class="${ist - soll < 0 ? "fehler" : ""}">${ist - soll >= 0 ? "+" : ""}${dauerText(ist - soll)}</span></small>` : ""}</div>`;
|
||||
}).join("")}</div>`);
|
||||
|
||||
const tabelle = document.createElement("div");
|
||||
tabelle.className = "tabelle-rolle";
|
||||
tabelle.innerHTML = d.tage.length ? `<table><thead><tr><th>Tag</th><th>Person</th><th>Zeit</th><th class="zahl">Pause</th><th class="zahl">Abzug</th><th class="zahl">Arbeitszeit</th><th class="optional">Baustellen</th></tr></thead>
|
||||
<tbody>${d.tage.map((t: Zeile, i: number) => `<tr class="klickbar" data-i="${i}"><td>${WT[wt(t.datum)]} ${dat(t.datum).slice(0, 6)}</td><td>${esc(t.name)}</td><td>${t.beginn}–${t.ende}</td>
|
||||
<td class="zahl">${t.pause_min || ""}</td><td class="zahl">${t.abzug_min || ""}</td><td class="zahl"><b>${dauerText(t.netto_min)}</b></td>
|
||||
<td class="optional">${esc(t.anteile.map((a: Zeile) => `${a.nummer ? `${a.nummer}${a.vorgang ? ` ${a.vorgang}` : ""}` : a.taetigkeit || "ohne Baustelle"}${t.anteile.length > 1 ? ` ${zahl(a.stunden)}` : ""}`).join(", "))}${t.notiz ? ` <i>${esc(t.notiz)}</i>` : ""}</td></tr>`).join("")}</tbody></table>`
|
||||
: '<p class="hinweis leer">In diesem Monat sind keine Stunden gebucht.</p>';
|
||||
inhalt.appendChild(tabelle);
|
||||
const baustellen = (t: Zeile) => t.anteile.map((a: Zeile) => `${a.nummer ? `${a.nummer}${a.vorgang ? ` ${a.vorgang}` : ""}` : a.taetigkeit || "ohne Baustelle"}${t.anteile.length > 1 ? ` ${zahl(a.stunden)}` : ""}`).join(", ");
|
||||
inhalt.appendChild(tabelleMit({
|
||||
schluessel: "stunden", einheit: ["Tag", "Tage"], leer: "In diesem Monat sind keine Stunden gebucht.",
|
||||
zeilen: d.tage.map((t: Zeile) => ({ ...t, id: t.id ?? `${t.kontakt_id}-${t.datum}` })),
|
||||
spalten: [
|
||||
{ id: "tag", titel: "Tag", art: "datum", wert: (t) => `${WT[wt(t.datum)]} ${dat(t.datum).slice(0, 6)}`, sortWert: (t) => t.datum },
|
||||
{ id: "person", titel: "Person", wert: (t) => esc(t.name) },
|
||||
{ id: "zeit", titel: "Zeit", wert: (t) => `${t.beginn}–${t.ende}`, sortWert: (t) => t.beginn },
|
||||
{ id: "pause", titel: "Pause", art: "zahl", wert: (t) => String(t.pause_min || ""), sortWert: (t) => t.pause_min || 0, klasse: "zahl" },
|
||||
{ id: "abzug", titel: "Abzug", art: "zahl", wert: (t) => String(t.abzug_min || ""), sortWert: (t) => t.abzug_min || 0, klasse: "zahl" },
|
||||
{ id: "arbeitszeit", titel: "Arbeitszeit", art: "zahl", wert: (t) => `<b>${dauerText(t.netto_min)}</b>`, sortWert: (t) => t.netto_min, klasse: "zahl" },
|
||||
{ id: "baustellen", titel: "Baustellen", text: baustellen, wert: (t) => `${esc(baustellen(t))}${t.notiz ? ` <i>${esc(t.notiz)}</i>` : ""}`, klasse: "optional" },
|
||||
],
|
||||
klick: (t) => void oeffne(d.tage.find((x: Zeile) => x.kontakt_id === t.kontakt_id && x.datum === t.datum) ?? t),
|
||||
fuss: (l) => (l.length && l.length !== d.tage.length ? `<p>Summe der gezeigten Tage: <strong>${dauerText(l.reduce((s, t) => s + t.netto_min, 0))} Std.</strong></p>` : ""),
|
||||
}));
|
||||
|
||||
const oeffne = async (t: Zeile | null) => {
|
||||
const huelle = document.getElementById("dialog-huelle")!;
|
||||
@@ -321,10 +330,6 @@ export async function stundenSeite(): Promise<void> {
|
||||
}
|
||||
});
|
||||
leiste.querySelector<HTMLSelectElement>("#person")!.onchange = (ev) => { person = (ev.target as HTMLSelectElement).value; void stundenSeite(); };
|
||||
tabelle.onclick = (ev) => {
|
||||
const tr = (ev.target as HTMLElement).closest<HTMLElement>("tr[data-i]");
|
||||
if (tr) void oeffne(d.tage[Number(tr.dataset.i)]);
|
||||
};
|
||||
}
|
||||
|
||||
/** Inhaber und Büro: zwischen eigenen Stunden und allen umschalten */
|
||||
|
||||
@@ -313,8 +313,6 @@ dl.werte dd { margin: 0; text-align: right; font-variant-numeric: tabular-nums;
|
||||
.g-trenner:hover, .g-trenner.zieht { background: var(--akzent-hell); border-color: var(--akzent); }
|
||||
|
||||
/* Zoom an der Zeitskala und Abschläge als Meilensteine (Henning, 20.10.2026) */
|
||||
.g-zoom { display: inline-flex; align-items: center; gap: 4px; }
|
||||
.g-zoom button { min-width: 32px; padding-inline: 8px; }
|
||||
.g-zeit { cursor: ew-resize; touch-action: none; user-select: none; }
|
||||
.zahlung-ms { position: absolute; top: 19px; width: 18px; height: 18px; pointer-events: auto; cursor: pointer; z-index: 2;
|
||||
clip-path: polygon(50% 0, 100% 50%, 50% 100%, 0 50%); display: grid; place-items: center; font-size: 11px; font-weight: 700;
|
||||
@@ -562,3 +560,73 @@ button.haupt.gross { padding: 14px 22px; font-size: 17px; flex: 1; }
|
||||
.last.leer { background: repeating-linear-gradient(135deg, rgb(120 130 150 / 0.18) 0 4px, transparent 4px 8px); color: var(--leise); border: 1px solid var(--linie); }
|
||||
.dialog .b-dauer { border-bottom: 1px solid var(--linie); padding-bottom: 10px; margin-bottom: 10px; }
|
||||
.dialog .b-dauer .schalter { margin-top: 8px; color: var(--text); }
|
||||
|
||||
/* Sortieren und Filtern wie in Excel (alle Tabellen) */
|
||||
.liste { margin-bottom: 8px; }
|
||||
.liste-leiste { display: flex; flex-wrap: wrap; gap: 6px; align-items: center; margin-bottom: 10px; }
|
||||
.liste-leiste .ansicht-knopf { padding: 6px 12px; font-size: 14px; }
|
||||
.liste-leiste .ansicht-knopf i { font-style: normal; color: var(--holz); font-size: 12px; }
|
||||
.liste-leiste .nur-schmal { padding: 6px 12px; font-size: 14px; }
|
||||
.chip { display: inline-flex; align-items: center; gap: 2px; background: var(--akzent-hell); color: var(--akzent); border-radius: 999px; font-size: 13px; padding: 2px 4px 2px 10px; max-width: 100%; }
|
||||
.chip.sort { background: var(--bg); color: var(--text); border: 1px solid var(--linie); }
|
||||
.chip > span, .chip-text { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
|
||||
.chip button { background: none; border: 0; color: inherit; font: inherit; cursor: pointer; padding: 3px 6px; border-radius: 999px; }
|
||||
.chip button:hover { background: rgb(0 0 0 / 0.06); }
|
||||
.chip-text { display: inline-flex; align-items: center; gap: 5px; padding-left: 0 !important; }
|
||||
.chip svg, .th-zeichen svg, .fm-zeile svg { width: 11px; height: 11px; flex: none; }
|
||||
th .th-knopf { all: unset; cursor: pointer; display: inline-flex; align-items: center; gap: 5px; font: inherit; color: inherit; border-radius: 4px; }
|
||||
th .th-knopf:focus-visible { outline: 2px solid var(--akzent); outline-offset: 2px; }
|
||||
th .th-zeichen { display: inline-flex; align-items: center; gap: 2px; color: var(--akzent); font-weight: 700; }
|
||||
th .th-zeichen i { font-style: normal; color: var(--leise); opacity: 0.45; font-weight: 400; font-size: 11px; }
|
||||
th:hover .th-zeichen i, th.aktiv .th-zeichen i { opacity: 1; }
|
||||
th.aktiv { color: var(--akzent); }
|
||||
th.zahl .th-knopf { flex-direction: row-reverse; }
|
||||
td.auge-spalte, th.auge-spalte { width: 34px; padding-left: 0; padding-right: 8px; text-align: right; }
|
||||
button.auge { background: none; border: 0; padding: 4px; color: var(--leise); cursor: pointer; opacity: 0; border-radius: 6px; line-height: 0; }
|
||||
button.auge svg { width: 17px; height: 17px; }
|
||||
tr:hover button.auge, button.auge:focus-visible, tr.ausgeblendet button.auge { opacity: 1; }
|
||||
button.auge:hover { color: var(--akzent); background: var(--akzent-hell); }
|
||||
@media (hover: none) { button.auge { opacity: 0.5; } }
|
||||
tr.ausgeblendet td { opacity: 0.45; }
|
||||
tr.ausgeblendet td.auge-spalte { opacity: 1; }
|
||||
tr.leer td { color: var(--leise); text-align: center; padding: 22px; }
|
||||
.filter-menue { position: fixed; z-index: 30; background: var(--fl); color: var(--text); border: 1px solid var(--linie); border-radius: 10px; box-shadow: 0 10px 30px rgb(0 0 0 / 0.2); width: 290px; padding: 6px; font-size: 14px; }
|
||||
.filter-menue.ansichten-menue { width: 320px; }
|
||||
.filter-menue.blatt { left: 0; right: 0; bottom: 0; width: auto; border-radius: 14px 14px 0 0; max-height: 85vh; overflow: auto; padding: 8px max(10px, env(safe-area-inset-right, 0px)) calc(10px + env(safe-area-inset-bottom, 0px)) max(10px, env(safe-area-inset-left, 0px)); }
|
||||
.filter-menue hr { border: 0; border-top: 1px solid var(--linie); margin: 4px 0; }
|
||||
.fm-kopf { display: flex; align-items: center; justify-content: space-between; padding: 4px 6px 6px; }
|
||||
.fm-zu { background: none; border: 0; color: var(--leise); cursor: pointer; font-size: 15px; padding: 4px 6px; }
|
||||
.fm-zeile { display: flex; gap: 8px; align-items: center; width: 100%; text-align: left; background: none; border: 0; color: inherit; font: inherit; padding: 7px 8px; border-radius: 6px; cursor: pointer; }
|
||||
.fm-zeile > span { width: 16px; display: inline-flex; justify-content: center; color: var(--leise); flex: none; }
|
||||
.fm-zeile:hover:not(:disabled) { background: var(--bg); }
|
||||
.fm-zeile.an { color: var(--akzent); font-weight: 600; }
|
||||
.fm-zeile:disabled { color: var(--leise); opacity: 0.6; cursor: default; }
|
||||
.fm-weitere { display: flex; align-items: center; gap: 6px; padding: 4px 8px 4px 32px; color: var(--leise); }
|
||||
.fm-weitere span { flex: 1; }
|
||||
.fm-weitere button.neben { padding: 2px 10px; }
|
||||
.fm-zeit { display: flex; align-items: center; gap: 8px; padding: 6px 8px; color: var(--leise); }
|
||||
.fm-zeit select { flex: 1; padding: 6px; border: 1px solid var(--linie); border-radius: 6px; background: var(--fl); color: var(--text); font: inherit; }
|
||||
.fm-suche { width: 100%; margin: 6px 0; padding: 7px 9px; border: 1px solid var(--linie); border-radius: 6px; background: var(--fl); color: var(--text); font: inherit; }
|
||||
.fm-werte { border: 1px solid var(--linie); border-radius: 6px; max-height: 240px; overflow: auto; padding: 4px 0; }
|
||||
.blatt .fm-werte { max-height: 38vh; }
|
||||
.fm-werte label { display: flex; align-items: center; gap: 8px; padding: 5px 8px; cursor: pointer; }
|
||||
.fm-werte label:hover { background: var(--bg); }
|
||||
.fm-werte label span { flex: 1; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
|
||||
.fm-werte label small { color: var(--leise); }
|
||||
.fm-werte .hinweis { padding: 4px 8px; margin: 0; }
|
||||
.filter-menue .knoepfe { display: flex; justify-content: flex-end; gap: 8px; padding: 8px 2px 2px; }
|
||||
.filter-menue .knoepfe button:disabled { opacity: 0.5; cursor: default; }
|
||||
.filter-menue > .hinweis { font-size: 12px; padding: 4px 8px; margin: 0; }
|
||||
.g-links .auge-g { background: none; border: 0; color: var(--leise); cursor: pointer; padding: 0; width: 22px; height: 22px; border-radius: 5px; display: inline-flex; align-items: center; justify-content: center; flex: none; }
|
||||
.g-links .auge-g svg { width: 15px; height: 15px; }
|
||||
.g-links .auge-g:hover { background: var(--akzent-hell); color: var(--akzent); }
|
||||
.g-zeile.ausgeblendet .g-links > *:not(.name), .g-zeile.ausgeblendet .name .text { opacity: 0.45; }
|
||||
.g-zeile.ausgeblendet .aktionen { opacity: 1; }
|
||||
.leiste .g-aus { font-size: 14px; color: var(--leise); }
|
||||
.leiste .chip button { padding: 5px 6px; }
|
||||
td .unter.nur-schmal, .liste-leiste .nur-schmal { display: none; }
|
||||
@media (max-width: 800px) {
|
||||
td .unter.nur-schmal { display: block; }
|
||||
.liste-leiste .nur-schmal { display: inline-block; }
|
||||
td.auge-spalte, th.auge-spalte { width: 28px; padding-right: 4px; }
|
||||
}
|
||||
|
||||
@@ -186,17 +186,6 @@ export async function bearbeiten(pfad: string, titel: string, felder: Feld[], ze
|
||||
/** Hinweis, der nach dem nächsten Neuaufbau der Seite oben steht */
|
||||
export const hinweis = { text: "" };
|
||||
|
||||
export function tabelle(spalten: { titel: string; wert: (z: Zeile) => string; klasse?: string }[], zeilen: Zeile[], klick?: (z: Zeile) => void): HTMLTableElement {
|
||||
const t = document.createElement("table");
|
||||
t.innerHTML = `<thead><tr>${spalten.map((s) => `<th class="${s.klasse ?? ""}">${esc(s.titel)}</th>`).join("")}</tr></thead>
|
||||
<tbody>${zeilen.map((z, i) => `<tr data-i="${i}" class="${klick ? "klickbar" : ""}">${spalten.map((s) => `<td class="${s.klasse ?? ""}">${s.wert(z)}</td>`).join("")}</tr>`).join("")}</tbody>`;
|
||||
if (klick) t.addEventListener("click", (ev) => {
|
||||
const tr = (ev.target as HTMLElement).closest("tr[data-i]") as HTMLElement | null;
|
||||
if (tr) klick(zeilen[Number(tr.dataset.i)]!);
|
||||
});
|
||||
return t;
|
||||
}
|
||||
|
||||
// Kopf wie bei Plancraft: Titel links, Hauptknopf rechts; darunter eine Leiste für Filter
|
||||
export function seite(titel: string, knopf?: { text: string; aktion: () => void }): HTMLElement {
|
||||
inhalt.innerHTML = `<div class="kopf"><h1>${esc(titel)}</h1></div>${hinweis.text ? `<div class="warnung">${esc(hinweis.text)}</div>` : ""}`;
|
||||
|
||||
Reference in New Issue
Block a user