diff --git a/CHANGELOG.md b/CHANGELOG.md
index af84655..7a6a9d9 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,16 @@
Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen.
+## 0.15.0
+
+- Personal hat Reiter wie die Projektseite: Mitarbeiter, Kolonnen, Subunternehmer, Urlaub, Zeiten. Die Mitarbeiterliste zeigt Rolle (Planer, Geselle, Helfer), Kolonne, Arbeitszeit, Resturlaub, Auslastung der nächsten 4 Wochen und Status (aktiv, geplant, ausgeschieden). Die Rolle steht in den Stammdaten.
+- Kolonnen: Name, Leitung und Mitglieder (Mitarbeiter und Subunternehmer, jeder auch in mehreren Kolonnen), Kapazität in Stunden pro Tag. Im Terminplan unter „+ Personal“ lässt sich eine Kolonne als eine Ressource einplanen; Dauer aus Stunden, Auslastung, Überschneidungen und „Meine Einsätze“ rechnen mit jedem Mitglied. Eine Kolonne mit Subunternehmer zählt erst nach deiner Freigabe.
+- Subunternehmer: eigene Seite mit Gewerk, Stundensatz (und Satz je weiterer Person) oder Pauschale, Zahlungsziel, Skonto, Sicherheitseinbehalt, Kolonnengröße und Freistellungsbescheinigung § 48b. Reiter Einsätze und Kosten, Rechnungen, Dokumente, Ausschreibungen.
+- Ein freigegebener Subunternehmer mit Stundensatz wird von selbst zur Ausgabe am Projekt: Tage × Stunden × Satz, abzüglich Skonto, fällig nach Skontofrist oder Zahlungsziel. Sie hängt am Ende des Vorgangs, wandert mit ihm und steht im Terminplan, in der Liquidität und in der Nachkalkulation. Der Einbehalt wird erst nach 5 Jahren Gewährleistung fällig. Wer den Betrag von Hand ändert, hält ihn fest.
+- Übersicht: Warnung, wenn eine Freistellungsbescheinigung in 30 Tagen abläuft, abgelaufen ist oder bei einem eingeplanten Subunternehmer fehlt.
+- Terminplan: neue Spalte „% erl.“. Klick in die Spalte oder Rechtsklick auf den Balken: 0, 25, 50, 75, 100 % oder eine eigene Zahl. Der Balken füllt sich, fertig ist er grün mit Haken. Liegt ein Vorgang eines beauftragten Projekts 10 Punkte hinter dem Kalender oder ist er über sein Ende hinaus nicht fertig, steht er rot mit „im Verzug“. Projekt und Abschnitt zeigen den Stand nach Stunden gewichtet; ein Klick dort setzt alles, was vor heute endet, auf 100 %.
+- Zahlungsplan: Abarbeitungsstand laut Terminplan in % und €, dazu was davon schon gestellt ist und was nach Abarbeitungsstand abrechenbar wäre (E24).
+
## 0.14.1
- Terminplan: Die Raten stehen wieder wie in 0.13 als €-Zeichen in der Projektzeile, ohne eigene Zeilen „Zahlungen“ und „Einnahmen“. Ein €-Zeichen ziehen verschiebt die Rate (gestellte und bezahlte stehen fest), ein Klick öffnet den Zahlungsplan. Die Ausgaben behalten ihre Zeilen.
diff --git a/demo/kern.ts b/demo/kern.ts
index 410a225..cefd1d1 100644
--- a/demo/kern.ts
+++ b/demo/kern.ts
@@ -14,6 +14,7 @@ import m009 from "../src/server/migrations/009_zeiterfassung.sql";
import m010 from "../src/server/migrations/010_dauer_aus_besetzung.sql";
import m011 from "../src/server/migrations/011_ansichten.sql";
import m012 from "../src/server/migrations/012_zahlungen_aufgaben_im_terminplan.sql";
+import m013 from "../src/server/migrations/013_kolonnen_subunternehmer.sql";
const MIGRATIONEN: [string, string][] = [
["001_grundlage.sql", m001], ["002_v70_uebernahme.sql", m002], ["003_vorgangsnummer.sql", m003], ["004_besetzung.sql", m004],
@@ -23,6 +24,7 @@ const MIGRATIONEN: [string, string][] = [
["010_dauer_aus_besetzung.sql", m010],
["011_ansichten.sql", m011],
["012_zahlungen_aufgaben_im_terminplan.sql", m012],
+ ["013_kolonnen_subunternehmer.sql", m013],
];
export async function starte(db: PGlite, v70?: unknown) {
diff --git a/package.json b/package.json
index 32a723e..43f50c3 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
{
"name": "betrieb",
- "version": "0.14.1",
+ "version": "0.15.0",
"private": true,
"description": "Betriebsführungsprogramm Schaarschmidt Holzbau",
"type": "module",
diff --git a/src/domain/einsatz.ts b/src/domain/einsatz.ts
index 0367709..ea88716 100644
--- a/src/domain/einsatz.ts
+++ b/src/domain/einsatz.ts
@@ -13,6 +13,8 @@ export interface Besetzung {
vorgang_id: string;
kontakt_id?: string | null;
platzhalter?: string | null;
+ /** 0.15: eine ganze Kolonne als eine Ressource */
+ kolonne_id?: string | null;
personen: number;
freigegeben: boolean;
}
@@ -26,9 +28,10 @@ export interface Ueberschneidung {
ab: Datum;
}
-/** Schlüssel einer Besetzung: der Kontakt oder der Platzhalter (ohne Groß/klein). „N.N.“ zählt nicht. */
-export function wer(b: Pick): string | undefined {
+/** Schlüssel einer Besetzung: der Kontakt, die Kolonne oder der Platzhalter (ohne Groß/klein). „N.N.“ zählt nicht. */
+export function wer(b: Pick & { kolonne_id?: string | null }): string | undefined {
if (b.kontakt_id) return b.kontakt_id;
+ if (b.kolonne_id) return `kolonne:${b.kolonne_id}`;
const p = b.platzhalter?.trim().toLowerCase();
return p && !/^n\.?\s*n\.?$/.test(p) ? `platzhalter:${p}` : undefined;
}
diff --git a/src/domain/fortschritt.ts b/src/domain/fortschritt.ts
new file mode 100644
index 0000000..947be70
--- /dev/null
+++ b/src/domain/fortschritt.ts
@@ -0,0 +1,45 @@
+// Abarbeitungsgrad im Terminplan (Henning, 20.10.2026): je Vorgang „% erledigt“, daraus der Stand von Abschnitt
+// und Projekt (gewichtet nach Stunden) und die Warnung „im Verzug“, wenn weniger erledigt ist als nach dem Kalender
+// zu erwarten. Grundlage auch für Abschläge nach Abarbeitungsstand (E24).
+import { type Datum, plusTage } from "./datum.js";
+import { type Arbeitswoche, arbeitstageZwischen } from "./kalender.js";
+
+/** Ab so vielen Prozentpunkten Rückstand gilt ein Vorgang als im Verzug */
+export const VERZUG_AB = 10;
+
+interface FVorgang {
+ anfang: Datum;
+ ende: Datum;
+ dauer: number;
+ stunden?: number | null;
+ fortschritt?: number | null;
+}
+
+/** Wie viel Prozent bis gestern geschafft sein sollten (gleichmäßig über die Arbeitstage verteilt) */
+export function sollFortschritt(v: FVorgang, heute: Datum, woche: Arbeitswoche): number {
+ if (v.anfang >= heute) return 0;
+ if (v.ende < heute) return 100;
+ const gesamt = arbeitstageZwischen(v.anfang, v.ende, woche);
+ if (gesamt <= 0) return 100;
+ return Math.round((arbeitstageZwischen(v.anfang, plusTage(heute, -1), woche) / gesamt) * 100);
+}
+
+/** Im Verzug: Ende überschritten und nicht fertig, oder deutlich weniger erledigt als erwartet */
+export function imVerzug(v: FVorgang, heute: Datum, woche: Arbeitswoche): boolean {
+ const ist = v.fortschritt ?? 0;
+ if (ist >= 100) return false;
+ if (v.ende < heute) return true;
+ return sollFortschritt(v, heute, woche) - ist >= VERZUG_AB;
+}
+
+/**
+ * Stand mehrerer Vorgänge (Abschnitt, Projekt): nach Stunden gewichtet, ohne Stunden nach Dauer;
+ * nur Meilensteine zählen gleich. Ohne Vorgänge null.
+ */
+export function gesamtFortschritt(vs: FVorgang[]): number | null {
+ if (!vs.length) return null;
+ const gewicht = (v: FVorgang) => (Number(v.stunden) > 0 ? Number(v.stunden) : v.dauer > 0 ? v.dauer : 0);
+ const summe = vs.reduce((s, v) => s + gewicht(v), 0);
+ if (summe <= 0) return Math.round(vs.reduce((s, v) => s + (v.fortschritt ?? 0), 0) / vs.length);
+ return Math.round(vs.reduce((s, v) => s + gewicht(v) * (v.fortschritt ?? 0), 0) / summe);
+}
diff --git a/src/domain/uebersicht.ts b/src/domain/uebersicht.ts
index 83463ce..c4896d6 100644
--- a/src/domain/uebersicht.ts
+++ b/src/domain/uebersicht.ts
@@ -78,7 +78,7 @@ export function einsatzMatrix(vorgaenge: UeVorgang[], besetzungen: UeBesetzung[]
}
export interface Warnung {
- art: "ueberschneidung" | "unbesetzt" | "freigabe" | "aufgabe" | "kontostand" | "urlaub";
+ art: "ueberschneidung" | "unbesetzt" | "freigabe" | "aufgabe" | "kontostand" | "urlaub" | "freistellung";
text: string;
/** Sprungziel in der App, z. B. "terminplan" */
ziel: string;
diff --git a/src/server/app.ts b/src/server/app.ts
index b759c9e..b1ead4e 100644
--- a/src/server/app.ts
+++ b/src/server/app.ts
@@ -26,6 +26,7 @@ import { registriereZeiten } from "./zeiten.js";
import { registriereUrlaub, zeitraumText } from "./urlaub.js";
import { vorlageAnwenden } from "./vorlage.js";
import { type BezugArt, bezugsTage } from "../domain/bezug.js";
+import { formatDatum, plusTage } from "../domain/datum.js";
export interface Optionen {
pool: Pool;
@@ -152,7 +153,9 @@ export async function baueApp(o: Optionen): Promise {
// Änderungen an Vorgängen und Verknüpfungen planen die Nachfolger in derselben Transaktion neu
// T15: auch Besetzung, Abwesenheiten und Arbeitszeitmodelle ändern die Dauer berechneter Vorgänge
// Zahlungen, Kosten und Aufgaben können an Vorgängen hängen und wandern dann mit
- const PLAN = new Set(["vorgang", "vorgang_vorgaenger", "zahlung", "kosten", "aufgabe", "besetzung", "abwesenheit", "arbeitszeitmodell"]);
+ // 0.15: Kolonnen und Subunternehmer ändern Besetzung, Dauer und die Kosten eingeplanter Subunternehmer
+ const PLAN = new Set(["vorgang", "vorgang_vorgaenger", "zahlung", "kosten", "aufgabe", "besetzung", "abwesenheit", "arbeitszeitmodell",
+ "kolonne", "kolonne_mitglied", "subunternehmer"]);
// P12: Projektänderungen legen den Zahlungsplan an oder führen ihn nach; eine Rate von Hand ändern stellt ihn fest
async function geplant(c: Client, tabelle: string, fn: () => Promise, bewegt: string[] = [], zahlungVon?: string): Promise {
const e = await ladeEinstellungen();
@@ -234,6 +237,8 @@ export async function baueApp(o: Optionen): Promise {
if (verboten(req, t, daten)) return reply.status(403).send({ fehler: "Dafür fehlt dir die Berechtigung." });
// T15: wer die Dauer von Hand ändert, legt sie fest (wie beim Zahlungsplan)
if (t.name === "vorgang" && daten.dauer !== undefined && daten.dauer_fest === undefined) daten.dauer_fest = true;
+ // Kosten eines Subunternehmer-Einsatzes: wer den Betrag ändert, hält ihn fest
+ if (t.name === "kosten" && daten.netto !== undefined && daten.automatisch === undefined) daten.automatisch = false;
if (felder.every((f) => daten[f] === undefined)) return reply.status(400).send({ fehler: "Keine Änderung angegeben" });
const row = await transaktion(pool, benutzer(req), async (c) => {
await versatzAusDatum(c, t.name, daten, id);
@@ -335,6 +340,17 @@ export async function baueApp(o: Optionen): Promise {
const antraege = await pool.query(`select a.von, a.bis, a.kontakt_id, k.name from abwesenheit a join kontakt k on k.id = a.kontakt_id
where a.art = 'urlaub' and a.status = 'beantragt' order by a.von`);
u.warnungen.unshift(...antraege.rows.map((a) => ({ art: "urlaub" as const, ziel: `mitarbeiter-${a.kontakt_id}`, text: `Urlaubsantrag von ${a.name}: ${zeitraumText(a.von, a.bis)}` })));
+ // § 48b EStG: ohne gültige Freistellungsbescheinigung müssen 15 % Bauabzugsteuer einbehalten werden
+ const eingeplant = new Set(tp.besetzungen.filter((b) => b.kontakt_id && (tp.vorgaenge.find((v) => v.id === b.vorgang_id)?.ende ?? "") >= heute).map((b) => b.kontakt_id as string));
+ const subs = await pool.query(`select k.id, coalesce(nullif(trim(k.firma), ''), k.name) as name, s.freistellung_bis from kontakt k
+ left join subunternehmer s on s.kontakt_id = k.id where k.rolle = 'subunternehmer' order by 2`);
+ for (const s of subs.rows) {
+ const bis = s.freistellung_bis as string | null;
+ const text = bis && bis < heute ? `Freistellungsbescheinigung von ${s.name} ist seit ${formatDatum(bis)} abgelaufen`
+ : bis && bis <= plusTage(heute, 30) ? `Freistellungsbescheinigung von ${s.name} läuft am ${formatDatum(bis)} ab`
+ : !bis && eingeplant.has(s.id) ? `${s.name} ist eingeplant, aber ohne Freistellungsbescheinigung (§ 48b)` : "";
+ if (text) u.warnungen.push({ art: "freistellung", ziel: `subunternehmer-${s.id}`, text });
+ }
return u;
});
diff --git a/src/server/ich.ts b/src/server/ich.ts
index 992dd74..5171b27 100644
--- a/src/server/ich.ts
+++ b/src/server/ich.ts
@@ -12,7 +12,7 @@ const Tag = z.string().regex(/^\d{4}-\d{2}-\d{2}$/);
/** Projekte, an denen ein Kontakt eingeteilt ist (für Ablage und Stunden) */
export async function istEingeteilt(pool: Pool, kontaktId: string | null, projektId: string): Promise {
if (!kontaktId) return false;
- const r = await pool.query(`select 1 from besetzung b join vorgang v on v.id = b.vorgang_id join abschnitt a on a.id = v.abschnitt_id
+ const r = await pool.query(`select 1 from besetzung_person b join vorgang v on v.id = b.vorgang_id join abschnitt a on a.id = v.abschnitt_id
where b.kontakt_id = $1 and a.projekt_id = $2 limit 1`, [kontaktId, projektId]);
return !!r.rowCount;
}
@@ -28,7 +28,7 @@ export function registriereIch(app: FastifyInstance, pool: Pool, einstellungen:
const woche = { tage: (await einstellungen()).arbeitstage };
const r = await pool.query(
`select v.id, v.name, v.start, v.dauer, p.id as projekt_id, p.nummer, p.bezeichnung, p.baustelle_strasse, p.baustelle_plz, p.baustelle_ort
- from besetzung b join vorgang v on v.id = b.vorgang_id join abschnitt a on a.id = v.abschnitt_id join projekt p on p.id = a.projekt_id
+ from besetzung_person b join vorgang v on v.id = b.vorgang_id join abschnitt a on a.id = v.abschnitt_id join projekt p on p.id = a.projekt_id
where b.kontakt_id = $1 and b.freigegeben order by v.start, p.nummer`, [kontakt]);
const einsaetze = r.rows
.map((v) => ({ ...v, dauer: Number(v.dauer), anfang: anfang({ ...v, dauer: Number(v.dauer) }, woche), ende: ende({ ...v, dauer: Number(v.dauer) }, woche) }))
diff --git a/src/server/migrations/013_kolonnen_subunternehmer.sql b/src/server/migrations/013_kolonnen_subunternehmer.sql
new file mode 100644
index 0000000..69d663f
--- /dev/null
+++ b/src/server/migrations/013_kolonnen_subunternehmer.sql
@@ -0,0 +1,97 @@
+-- 0.15 (Henning, 20.10.2026): Kolonnen, Subunternehmer mit Sätzen und Zahlungsbedingungen, Rolle der Mitarbeiter.
+
+-- Rolle im Betrieb, wie bei den Lohnarten der Kalkulation
+alter table mitarbeiter add column funktion text check (funktion in ('planer', 'geselle', 'helfer'));
+
+-- Kolonne: feste Gruppe aus Mitarbeitern und Subunternehmern, im Terminplan als eine Ressource einplanbar.
+-- Ein Mitarbeiter kann in mehreren Kolonnen sein.
+create table kolonne (
+ id uuid primary key default gen_random_uuid(),
+ name text not null,
+ leitung_kontakt_id uuid references kontakt (id) on delete set null,
+ aktiv boolean not null default true,
+ notiz text,
+ angelegt_am timestamptz not null default now(),
+ geaendert_am timestamptz not null default now(),
+ geaendert_von text not null default 'system'
+);
+create trigger kolonne_protokoll before insert or update or delete on kolonne
+ for each row execute function stempel_und_protokoll();
+
+create table kolonne_mitglied (
+ id uuid primary key default gen_random_uuid(),
+ kolonne_id uuid not null references kolonne (id) on delete cascade,
+ kontakt_id uuid not null references kontakt (id) on delete cascade,
+ angelegt_am timestamptz not null default now(),
+ geaendert_am timestamptz not null default now(),
+ geaendert_von text not null default 'system',
+ unique (kolonne_id, kontakt_id)
+);
+create trigger kolonne_mitglied_protokoll before insert or update or delete on kolonne_mitglied
+ for each row execute function stempel_und_protokoll();
+
+-- Subunternehmer: Stammdaten zum Kontakt (Rolle subunternehmer)
+create table subunternehmer (
+ id uuid primary key default gen_random_uuid(),
+ kontakt_id uuid not null unique references kontakt (id) on delete cascade,
+ abrechnung text not null default 'stunden' check (abrechnung in ('stunden', 'pauschale')),
+ -- Cent je Stunde: erste Person (Geselle) und jede weitere (Helfer)
+ stundensatz bigint check (stundensatz >= 0),
+ helfersatz bigint check (helfersatz >= 0),
+ zahlungsziel_tage int check (zahlungsziel_tage >= 0),
+ skonto_prozent numeric(5, 2) check (skonto_prozent >= 0 and skonto_prozent < 100),
+ skonto_tage int check (skonto_tage >= 0),
+ -- Sicherheitseinbehalt bis zum Ende der Gewährleistung
+ einbehalt_prozent numeric(5, 2) check (einbehalt_prozent >= 0 and einbehalt_prozent < 100),
+ -- übliche Größe der Kolonne, mit der der Subunternehmer kommt
+ kolonnengroesse numeric(4, 1) check (kolonnengroesse > 0),
+ -- Freistellungsbescheinigung nach § 48b EStG
+ freistellung_nr text,
+ freistellung_bis date,
+ notiz text,
+ angelegt_am timestamptz not null default now(),
+ geaendert_am timestamptz not null default now(),
+ geaendert_von text not null default 'system'
+);
+create trigger subunternehmer_protokoll before insert or update or delete on subunternehmer
+ for each row execute function stempel_und_protokoll();
+
+-- Besetzung: Person, Platzhalter oder Kolonne
+alter table besetzung add column kolonne_id uuid references kolonne (id) on delete cascade;
+alter table besetzung drop constraint besetzung_check;
+alter table besetzung add constraint besetzung_wer check (num_nonnulls(kontakt_id, nullif(trim(platzhalter), ''), kolonne_id) = 1);
+create index besetzung_kolonne on besetzung (kolonne_id);
+
+-- Mitarbeiter gelten sofort, Subunternehmer und Platzhalter erst nach Freigabe (E23).
+-- Eine Kolonne nur aus Mitarbeitern gilt sofort, mit Subunternehmern erst nach Freigabe.
+create or replace function besetzung_freigabe() returns trigger language plpgsql as $$
+begin
+ if new.freigegeben is null then
+ if new.kolonne_id is not null then
+ new.freigegeben := not exists (select 1 from kolonne_mitglied m join kontakt k on k.id = m.kontakt_id
+ where m.kolonne_id = new.kolonne_id and k.rolle <> 'mitarbeiter');
+ else
+ new.freigegeben := exists (select 1 from kontakt k where k.id = new.kontakt_id and k.rolle = 'mitarbeiter');
+ end if;
+ end if;
+ return new;
+end $$;
+
+-- Besetzung je Person: eine Kolonne zählt mit jedem Mitglied (Subunternehmer mit seiner Kolonnengröße).
+-- Mitarbeiter einer Kolonne gelten immer, Subunternehmer erst mit der Freigabe der Besetzung.
+create view besetzung_person as
+ select b.id, b.vorgang_id, b.kontakt_id, b.platzhalter, b.personen, b.freigegeben, null::uuid as kolonne_id
+ from besetzung b where b.kolonne_id is null
+ union all
+ select b.id, b.vorgang_id, m.kontakt_id, null::text, coalesce(s.kolonnengroesse, 1)::numeric(4, 1),
+ b.freigegeben or k.rolle = 'mitarbeiter', b.kolonne_id
+ from besetzung b
+ join kolonne_mitglied m on m.kolonne_id = b.kolonne_id
+ join kontakt k on k.id = m.kontakt_id
+ left join subunternehmer s on s.kontakt_id = m.kontakt_id and k.rolle = 'subunternehmer';
+
+-- Kosten aus dem Einsatz eines Subunternehmers: entstehen und ändern sich von selbst, solange sie geplant sind
+alter table kosten add column besetzung_id uuid references besetzung (id) on delete set null;
+alter table kosten add column besetzung_teil text check (besetzung_teil in ('leistung', 'einbehalt'));
+alter table kosten add column automatisch boolean not null default false;
+create unique index kosten_besetzung on kosten (besetzung_id, kontakt_id, besetzung_teil) where besetzung_id is not null;
diff --git a/src/server/subunternehmer.ts b/src/server/subunternehmer.ts
new file mode 100644
index 0000000..35671d2
--- /dev/null
+++ b/src/server/subunternehmer.ts
@@ -0,0 +1,116 @@
+// Subunternehmer als Ressource und Kosten (Henning, 20.10.2026): ist ein Subunternehmer mit Stundensatz
+// freigegeben eingeplant, entsteht daraus eine Ausgabe am Projekt. Sie hängt am Ende des Vorgangs, wandert mit
+// ihm, ist nach dem Zahlungsziel (mit Skonto nach der Skontofrist) fällig und steht so im Terminplan, in der
+// Liquidität und in der Nachkalkulation. Ein Sicherheitseinbehalt wird erst nach der Gewährleistung fällig.
+// Solange die Ausgabe geplant ist, rechnet sie sich bei jeder Änderung neu; wer den Betrag von Hand ändert,
+// bestellt oder bezahlt, hält sie fest.
+import type { Client } from "./db.js";
+import { ende } from "../domain/terminplan.js";
+import type { Datum } from "../domain/datum.js";
+import type { Arbeitswoche } from "../domain/kalender.js";
+
+/** Gewährleistung am Bau (§ 634a BGB): fünf Jahre */
+const GEWAEHRLEISTUNG_JAHRE = 5;
+
+interface Einsatz {
+ besetzung_id: string;
+ kontakt_id: string;
+ personen: string;
+ vorgang_id: string;
+ vorgang: string;
+ start: Datum;
+ dauer: string;
+ projekt_id: string;
+ wer: string;
+ stundensatz: string;
+ helfersatz: string | null;
+ zahlungsziel_tage: number | null;
+ skonto_prozent: string | null;
+ skonto_tage: number | null;
+ einbehalt_prozent: string | null;
+}
+
+interface Soll {
+ projekt_id: string;
+ besetzung_id: string;
+ kontakt_id: string;
+ teil: "leistung" | "einbehalt";
+ bezeichnung: string;
+ netto: number;
+ termin: Datum;
+ vorgang_id: string | null;
+ zahlungsziel_tage: number | null;
+}
+
+const zahl = (n: number) => String(Math.round(n * 10) / 10).replace(".", ",");
+
+/** Was ein Einsatz kostet: Arbeitstage × Stunden pro Tag × (Satz der ersten Person + Helfersatz je weiterer) */
+export function einsatzKosten(e: { dauer: number; personen: number; stundensatz: number; helfersatz?: number | null; skonto_prozent?: number | null; einbehalt_prozent?: number | null }, stundenProTag: number) {
+ const stunden = e.dauer * stundenProTag;
+ const leistung = Math.round(stunden * (e.stundensatz + Math.max(0, e.personen - 1) * (e.helfersatz ?? e.stundensatz)));
+ const nachSkonto = Math.round(leistung * (1 - (e.skonto_prozent ?? 0) / 100));
+ const einbehalt = Math.round(nachSkonto * (e.einbehalt_prozent ?? 0) / 100);
+ return { stunden: stunden * e.personen, leistung, zahlen: nachSkonto - einbehalt, einbehalt };
+}
+
+export async function subKostenNachziehen(c: Client, woche: Arbeitswoche, stundenProTag: number): Promise {
+ const einsaetze = (await c.query(
+ `select bp.id as besetzung_id, bp.kontakt_id, bp.personen, v.id as vorgang_id, v.name as vorgang, v.start, v.dauer, a.projekt_id,
+ coalesce(nullif(trim(k.firma), ''), k.name) as wer, s.stundensatz, s.helfersatz, s.zahlungsziel_tage, s.skonto_prozent, s.skonto_tage, s.einbehalt_prozent
+ from besetzung_person bp
+ join kontakt k on k.id = bp.kontakt_id and k.rolle = 'subunternehmer'
+ join subunternehmer s on s.kontakt_id = k.id and s.abrechnung = 'stunden' and s.stundensatz > 0
+ join vorgang v on v.id = bp.vorgang_id join abschnitt a on a.id = v.abschnitt_id
+ where bp.freigegeben and v.dauer > 0`)).rows;
+
+ const soll = new Map();
+ for (const e of einsaetze) {
+ const personen = Number(e.personen) > 0 ? Number(e.personen) : 1;
+ const skonto = Number(e.skonto_prozent ?? 0);
+ const k = einsatzKosten({ dauer: Number(e.dauer), personen, stundensatz: Number(e.stundensatz), helfersatz: e.helfersatz == null ? null : Number(e.helfersatz),
+ skonto_prozent: skonto, einbehalt_prozent: Number(e.einbehalt_prozent ?? 0) }, stundenProTag);
+ const fertig = ende({ id: e.vorgang_id, start: e.start, dauer: Number(e.dauer) }, woche);
+ const basis = { projekt_id: e.projekt_id, besetzung_id: e.besetzung_id, kontakt_id: e.kontakt_id };
+ soll.set(`${e.besetzung_id}/${e.kontakt_id}/leistung`, {
+ ...basis, teil: "leistung",
+ bezeichnung: `${e.wer}: ${e.vorgang} (${zahl(k.stunden)} h${skonto ? `, ${zahl(skonto)} % Skonto` : ""})`,
+ netto: k.zahlen, termin: fertig, vorgang_id: e.vorgang_id,
+ zahlungsziel_tage: skonto && e.skonto_tage != null ? e.skonto_tage : e.zahlungsziel_tage,
+ });
+ if (k.einbehalt > 0) {
+ soll.set(`${e.besetzung_id}/${e.kontakt_id}/einbehalt`, {
+ ...basis, teil: "einbehalt", bezeichnung: `${e.wer}: Sicherheitseinbehalt ${e.vorgang}`,
+ netto: k.einbehalt, termin: `${Number(fertig.slice(0, 4)) + GEWAEHRLEISTUNG_JAHRE}${fertig.slice(4)}`, vorgang_id: null, zahlungsziel_tage: 0,
+ });
+ }
+ }
+
+ const ist = (await c.query<{ id: string; besetzung_id: string | null; kontakt_id: string | null; besetzung_teil: string; netto: string; bezeichnung: string;
+ termin: Datum; zahlungsziel_tage: number | null; status: string; automatisch: boolean }>(
+ "select id, besetzung_id, kontakt_id, besetzung_teil, netto, bezeichnung, termin, zahlungsziel_tage, status, automatisch from kosten where besetzung_teil is not null")).rows;
+ for (const k of ist) {
+ const schluessel = `${k.besetzung_id}/${k.kontakt_id}/${k.besetzung_teil}`;
+ const s = soll.get(schluessel);
+ soll.delete(schluessel);
+ const offen = k.automatisch && k.status === "geplant";
+ if (!s) {
+ // Einsatz entfernt oder nicht mehr freigegeben: nur Geplantes verschwindet
+ if (offen) await c.query("delete from kosten where id = $1", [k.id]);
+ continue;
+ }
+ if (!offen) continue;
+ // der Termin der Leistung folgt dem Vorgang über den Bezug (auch wenn die Raute gezogen wurde)
+ const termin = s.teil === "einbehalt" ? s.termin : k.termin;
+ if (Number(k.netto) !== s.netto || k.bezeichnung !== s.bezeichnung || k.zahlungsziel_tage !== s.zahlungsziel_tage || k.termin !== termin) {
+ await c.query("update kosten set netto = $2, bezeichnung = $3, zahlungsziel_tage = $4, termin = $5 where id = $1",
+ [k.id, s.netto, s.bezeichnung, s.zahlungsziel_tage, termin]);
+ }
+ }
+ for (const s of soll.values()) {
+ await c.query(
+ `insert into kosten (projekt_id, art, bezeichnung, netto, termin, kontakt_id, status, zahlungsziel_tage, vorgang_id, bezug_art, bezug_tage,
+ besetzung_id, besetzung_teil, automatisch)
+ values ($1, 'fremd', $2, $3, $4, $5, 'geplant', $6, $7, 'EE', 0, $8, $9, true)`,
+ [s.projekt_id, s.bezeichnung, s.netto, s.termin, s.kontakt_id, s.zahlungsziel_tage, s.vorgang_id, s.besetzung_id, s.teil]);
+ }
+}
diff --git a/src/server/tabellen.ts b/src/server/tabellen.ts
index 1a209ef..dfcea6c 100644
--- a/src/server/tabellen.ts
+++ b/src/server/tabellen.ts
@@ -31,6 +31,46 @@ export const TABELLEN: Tabelle[] = [
notiz: optText,
}),
},
+ // 0.15: Kolonnen und Subunternehmer (Henning, 20.10.2026)
+ {
+ name: "kolonne",
+ pfad: "kolonnen",
+ sortierung: "name",
+ schema: z.object({
+ name: text,
+ leitung_kontakt_id: id.nullable().optional(),
+ aktiv: z.boolean().optional(),
+ notiz: optText,
+ }),
+ },
+ {
+ name: "kolonne_mitglied",
+ pfad: "kolonnen-mitglieder",
+ sortierung: "kolonne_id, angelegt_am",
+ schema: z.object({
+ kolonne_id: id,
+ kontakt_id: id,
+ }),
+ },
+ {
+ name: "subunternehmer",
+ pfad: "subunternehmer",
+ sortierung: "angelegt_am",
+ schema: z.object({
+ kontakt_id: id,
+ abrechnung: z.enum(["stunden", "pauschale"]).optional(),
+ stundensatz: cent.min(0).nullable().optional(),
+ helfersatz: cent.min(0).nullable().optional(),
+ zahlungsziel_tage: z.number().int().min(0).max(365).nullable().optional(),
+ skonto_prozent: z.number().min(0).max(99).nullable().optional(),
+ skonto_tage: z.number().int().min(0).max(365).nullable().optional(),
+ einbehalt_prozent: z.number().min(0).max(99).nullable().optional(),
+ kolonnengroesse: z.number().positive().max(99).nullable().optional(),
+ freistellung_nr: optText,
+ freistellung_bis: datum.nullable().optional(),
+ notiz: optText,
+ }),
+ },
{
name: "projekt",
pfad: "projekte",
@@ -108,6 +148,7 @@ export const TABELLEN: Tabelle[] = [
vorgang_id: id,
kontakt_id: id.nullable().optional(),
platzhalter: optText,
+ kolonne_id: id.nullable().optional(),
personen: z.number().positive().optional(),
freigegeben: z.boolean().optional(),
}),
@@ -150,6 +191,8 @@ export const TABELLEN: Tabelle[] = [
vorgang_id: id.nullable().optional(),
bezug_art: z.enum(["AA", "EE"]).optional(),
bezug_tage: z.number().int().min(-500).max(500).optional(),
+ // aus dem Einsatz eines Subunternehmers; false = von Hand geändert, rechnet sich nicht mehr neu
+ automatisch: z.boolean().optional(),
}),
},
{
@@ -206,6 +249,7 @@ export const TABELLEN: Tabelle[] = [
angestellt: z.boolean().optional(),
lohn_cent: cent.min(0).nullable().optional(),
urlaubstage: z.number().min(0).max(60).optional(),
+ funktion: z.enum(["planer", "geselle", "helfer"]).nullable().optional(),
}),
},
{
diff --git a/src/server/terminplan.ts b/src/server/terminplan.ts
index fce6c57..5816a86 100644
--- a/src/server/terminplan.ts
+++ b/src/server/terminplan.ts
@@ -3,7 +3,7 @@
import { restNachziehen, zahlungsplaeneAutomatisch } from "./zahlungsplan.js";
import type { Client, Pool } from "./db.js";
import type { Arbeitswoche } from "../domain/kalender.js";
-import { kuerzel, ueberschneidungen } from "../domain/einsatz.js";
+import { kuerzel, ueberschneidungen, wer } from "../domain/einsatz.js";
import { type PlanVorgang, type Verknuepfung, anfang, bildetKreis, ende, engeVorgaenge, planeNeu } from "../domain/terminplan.js";
import { type KapBesetzung, type Personaldaten, auslastung, dauerNachBesetzung, reduzierteTage } from "../domain/kapazitaet.js";
import { ladePersonal } from "./personal.js";
@@ -11,6 +11,7 @@ import { plusTage } from "../domain/datum.js";
import { type BezugArt, bezugsTermin } from "../domain/bezug.js";
import type { VorlageEintrag } from "./einstellungen.js";
import { vorlageAnwenden } from "./vorlage.js";
+import { subKostenNachziehen } from "./subunternehmer.js";
export class PlanFehler extends Error {
statusCode = 409;
@@ -29,7 +30,8 @@ async function ladeStand(c: Client | Pool): Promise<{ vorgaenge: StandVorgang[];
/** Besetzungen und Personaldaten für T15/T16 */
async function ladeKapazitaet(c: Client | Pool, stundenProTag: number): Promise<{ besetzungen: KapBesetzung[]; personal: Personaldaten }> {
const [b, st] = await Promise.all([
- c.query("select vorgang_id, kontakt_id, platzhalter, personen from besetzung"),
+ // eine Kolonne zählt mit jedem ihrer Mitglieder
+ c.query("select vorgang_id, kontakt_id, platzhalter, personen from besetzung_person"),
ladePersonal(c),
]);
return { besetzungen: b.rows.map((x) => ({ ...x, personen: Number(x.personen) })), personal: { modelle: st.modelle, abwesenheiten: st.abwesenheiten, stundenProTag } };
@@ -61,6 +63,7 @@ export async function mitNeuplanung(
}
for (const [id, start] of starts) await c.query("update vorgang set start = $2 where id = $1", [id, start]);
for (const [id, dauer] of dauern) await c.query("update vorgang set dauer = $2 where id = $1", [id, dauer]);
+ await subKostenNachziehen(c, woche, stundenProTag);
await bezuegeNachziehen(c, woche);
await zahlungsplaeneAutomatisch(c, woche);
await restNachziehen(c);
@@ -99,21 +102,26 @@ export async function pruefeVerknuepfung(c: Client, neu: { vorgang_id: string; v
/** Alles, was das Gantt braucht, mit berechnetem Anfang und Ende je Vorgang. */
export async function terminplan(pool: Pool, woche: Arbeitswoche, stundenProTag = 8) {
- const [projekte, abschnitte, vorgaenge, links, besetzungen, leute, zahlungen, kosten, aufgaben] = await Promise.all([
+ const [projekte, abschnitte, vorgaenge, links, besetzungen, leute, zahlungen, kosten, aufgaben, kolonnen] = await Promise.all([
pool.query(`select p.id, p.nummer, p.bezeichnung, p.status, p.farbe, p.reihenfolge, p.umsatz_netto, p.zahlungsplan, k.name as bauherr
from projekt p left join kontakt k on k.id = p.bauherr_id order by p.reihenfolge, p.nummer`),
pool.query("select id, projekt_id, name, ist_meilenstein, reihenfolge from abschnitt order by reihenfolge, name"),
pool.query("select id, abschnitt_id, nummer, name, start, dauer, dauer_fest, stunden, personen, kontakt_id, fortschritt, reihenfolge from vorgang order by reihenfolge, nummer"),
pool.query("select id, vorgang_id, vorgaenger_id, art, verzoegerung from vorgang_vorgaenger"),
- pool.query(`select b.id, b.vorgang_id, b.kontakt_id, b.platzhalter, b.personen, b.freigegeben, k.name, k.firma, k.rolle
- from besetzung b left join kontakt k on k.id = b.kontakt_id order by b.angelegt_am`),
- pool.query("select id, name, firma, rolle from kontakt where rolle in ('mitarbeiter', 'subunternehmer') order by rolle, name"),
+ pool.query(`select b.id, b.vorgang_id, b.kontakt_id, b.platzhalter, b.kolonne_id, b.personen, b.freigegeben, coalesce(k.name, ko.name) as name, k.firma, k.rolle
+ from besetzung b left join kontakt k on k.id = b.kontakt_id left join kolonne ko on ko.id = b.kolonne_id order by b.angelegt_am`),
+ pool.query(`select k.id, k.name, k.firma, k.rolle, s.kolonnengroesse from kontakt k left join subunternehmer s on s.kontakt_id = k.id
+ where k.rolle in ('mitarbeiter', 'subunternehmer') order by k.rolle, k.name`),
pool.query("select id, projekt_id, vorgang_id, bezug_art, bezug_tage, art, bezeichnung, netto, termin, status, rest, reihenfolge from zahlung order by reihenfolge, termin"),
- pool.query("select id, projekt_id, vorgang_id, bezug_art, bezug_tage, art, bezeichnung, netto, termin, status from kosten order by termin, bezeichnung"),
+ // Sicherheitseinbehalte werden erst nach der Gewährleistung fällig und gehören nicht in den Bauablauf
+ pool.query(`select id, projekt_id, vorgang_id, bezug_art, bezug_tage, art, bezeichnung, netto, termin, status, automatisch from kosten
+ where besetzung_teil is distinct from 'einbehalt' order by termin, bezeichnung`),
// Aufgaben eines Projekts stehen im Terminplan in dessen Abschnitt „Aufgaben“
pool.query(`select a.id, a.projekt_id, a.vorgang_id, a.bezug_art, a.bezug_tage, a.text, a.faellig_am, a.erledigt_am, a.kategorie_id, g.name as kategorie
from aufgabe a left join aufgabe_kategorie g on g.id = a.kategorie_id where a.projekt_id is not null
order by a.faellig_am nulls last, a.angelegt_am`),
+ pool.query(`select o.id, o.name, o.aktiv, o.leitung_kontakt_id, coalesce(array_agg(m.kontakt_id order by m.angelegt_am) filter (where m.kontakt_id is not null), '{}') as mitglieder
+ from kolonne o left join kolonne_mitglied m on m.kolonne_id = o.id group by o.id order by o.name`),
]);
const kap = await ladeKapazitaet(pool, stundenProTag);
const vs = vorgaenge.rows.map((v) => {
@@ -136,12 +144,18 @@ export async function terminplan(pool: Pool, woche: Arbeitswoche, stundenProTag
const bisSpaetestens = plusTage(heute, 365);
const letztes = vs.reduce((m, v) => (v.ende > m ? v.ende : m), plusTage(heute, 28));
const team_auslastung = team.length ? auslastung(ab, letztes < bisSpaetestens ? letztes : bisSpaetestens, team, vs, kap.besetzungen, kap.personal, woche) : [];
+ const mitgliederVon = new Map(kolonnen.rows.map((o) => [o.id as string, o.mitglieder as string[]]));
const bs = besetzungen.rows.map((b) => ({
...b,
- kurz: b.kontakt_id ? kuerzel(b.rolle === "subunternehmer" && b.firma ? b.firma : b.name, b.rolle) : b.platzhalter,
- anzeige: b.kontakt_id ? (b.firma && b.rolle === "subunternehmer" ? b.firma : b.name) : b.platzhalter,
+ kurz: b.kontakt_id ? kuerzel(b.rolle === "subunternehmer" && b.firma ? b.firma : b.name, b.rolle) : b.kolonne_id ? b.name : b.platzhalter,
+ anzeige: b.kontakt_id ? (b.firma && b.rolle === "subunternehmer" ? b.firma : b.name) : b.kolonne_id ? b.name : b.platzhalter,
+ // eine Kolonne: wer dazugehört (Personenfilter, Überschneidungen)
+ ...(b.kolonne_id ? { mitglieder: mitgliederVon.get(b.kolonne_id) ?? [] } : {}),
}));
- const anzeige = new Map(bs.map((b) => [b.kontakt_id ?? `platzhalter:${String(b.platzhalter).trim().toLowerCase()}`, b.anzeige]));
+ const anzeige = new Map(leute.rows.map((k) => [k.id, k.rolle === "subunternehmer" && k.firma ? k.firma : k.name]));
+ for (const b of bs) { const w = wer(b); if (w && !anzeige.has(w)) anzeige.set(w, b.anzeige); }
+ // Überschneidungen je Person: auch wer über eine Kolonne eingeteilt ist
+ const jePerson = [...bs, ...kap.besetzungen.filter((b) => b.kontakt_id).map((b) => ({ ...b, freigegeben: true }))];
return {
projekte: projekte.rows,
abschnitte: abschnitte.rows,
@@ -152,7 +166,8 @@ export async function terminplan(pool: Pool, woche: Arbeitswoche, stundenProTag
zahlungen: zahlungen.rows,
kosten: kosten.rows,
aufgaben: aufgaben.rows,
- ueberschneidungen: ueberschneidungen(vs, bs).map((u) => ({ ...u, name: anzeige.get(u.wer) ?? u.wer })),
+ ueberschneidungen: ueberschneidungen(vs, jePerson).map((u) => ({ ...u, name: anzeige.get(u.wer) ?? u.wer })),
+ kolonnen: kolonnen.rows,
arbeitstage: woche.tage,
team,
auslastung: team_auslastung,
diff --git a/src/server/urlaub.ts b/src/server/urlaub.ts
index 28f69ec..a258e39 100644
--- a/src/server/urlaub.ts
+++ b/src/server/urlaub.ts
@@ -27,7 +27,7 @@ export function zeitraumText(von: string, bis: string): string {
/** Vorgänge, für die jemand im Zeitraum eingeteilt ist; Mitarbeiter sehen nur freigegebene (E27) */
async function einsaetzeIm(c: Abfrage, kontaktId: string, von: string, bis: string, woche: { tage: number[] }, nurFreigegeben: boolean) {
- const r = await c.query(`select v.id, v.name, v.start, v.dauer, p.nummer, p.bezeichnung from besetzung b join vorgang v on v.id = b.vorgang_id
+ const r = await c.query(`select v.id, v.name, v.start, v.dauer, p.nummer, p.bezeichnung from besetzung_person b join vorgang v on v.id = b.vorgang_id
join abschnitt a on a.id = v.abschnitt_id join projekt p on p.id = a.projekt_id
where b.kontakt_id = $1 and ($2 or b.freigegeben) and p.status in ('auftrag', 'ausfuehrung') and v.dauer > 0`, [kontaktId, !nurFreigegeben]);
return r.rows
diff --git a/src/server/zeiten.ts b/src/server/zeiten.ts
index 8917585..2f2b8f5 100644
--- a/src/server/zeiten.ts
+++ b/src/server/zeiten.ts
@@ -129,7 +129,7 @@ export function registriereZeiten(app: FastifyInstance, pool: Pool, einstellunge
ladeTage(pool, von, bis, kontakt),
istAngestellt(pool, kontakt),
ladePersonal(pool, kontakt),
- pool.query(`select v.id, v.name, v.start, v.dauer, a.projekt_id from besetzung b join vorgang v on v.id = b.vorgang_id
+ pool.query(`select v.id, v.name, v.start, v.dauer, a.projekt_id from besetzung_person b join vorgang v on v.id = b.vorgang_id
join abschnitt a on a.id = v.abschnitt_id where b.kontakt_id = $1 and b.freigegeben`, [kontakt]),
// Baustellen zur Auswahl: laufende Aufträge mit ihren Vorgängen, nur Namen (E27)
pool.query(`select p.id, p.nummer, p.bezeichnung, coalesce(json_agg(json_build_object('id', v.id, 'name', v.name) order by a.reihenfolge, v.reihenfolge, v.nummer)
diff --git a/src/web/app.ts b/src/web/app.ts
index 4ebeda5..b73a23d 100644
--- a/src/web/app.ts
+++ b/src/web/app.ts
@@ -7,7 +7,8 @@ import { type Sitzung, anmeldeSeite, benutzerSeite, werLeiste } from "./anmeldun
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 { gesamtFortschritt } from "../domain/fortschritt.js";
+import { kolonneSeite, mitarbeiterSeite, personalSeite, subunternehmerSeite } from "./personal.js";
import { meineStunden, stundenSeite } from "./stunden.js";
@@ -326,6 +327,14 @@ async function projektSeite(id: string): Promise {
? "Automatisch angelegt: Die Raten folgen dem Auftragswert und den Terminen, bis du eine davon von Hand änderst."
: "Fest: Geplante Raten, die an einem Vorgang hängen, wandern mit dessen Ende; Beträge ändern sich nur von Hand."}
`;
}
+ // E24: Abschläge nach Abarbeitungsstand; der Stand kommt aus „% erledigt“ im Terminplan (nach Stunden gewichtet)
+ const stand = gesamtFortschritt(vorgaenge.map((v: Zeile) => ({ anfang: v.anfang, ende: v.ende, dauer: Number(v.dauer), stunden: v.stunden == null ? null : Number(v.stunden), fortschritt: Number(v.fortschritt) || 0 })));
+ if (umsatz && stand) {
+ const verdient = Math.round((umsatz * stand) / 100);
+ const abgerechnet = eigeneZahlungen.filter((z) => z.status !== "geplant").reduce((s, z) => s + z.netto, 0);
+ info.insertAdjacentHTML("beforeend", `
Abarbeitungsstand ${stand} % laut Terminplan = ${euro(verdient)} von ${euro(umsatz)} netto.
+ Gestellt oder bezahlt: ${euro(abgerechnet)}.${verdient > abgerechnet ? ` Nach Abarbeitungsstand abrechenbar: ${euro(verdient - abgerechnet)}.` : ""}
Subunternehmer und Platzhalter sind vorgemerkt, bis du sie freigibst. Mitarbeiter und Subunternehmer legst du unter Kontakte an.
+
Subunternehmer, Platzhalter und Kolonnen mit Subunternehmern sind vorgemerkt, bis du sie freigibst. Kolonnen und Subunternehmer legst du unter Personal an.
`;
huelle.hidden = false;
const wahl = huelle.querySelector("#b-wer")!;
- wahl.onchange = () => (huelle.querySelector("#b-platzhalter")!.hidden = wahl.value !== "platzhalter");
+ wahl.onchange = () => {
+ huelle.querySelector("#b-platzhalter")!.hidden = wahl.value !== "platzhalter";
+ // Kolonne: zählt mit ihren Mitgliedern; Subunternehmer kommt mit seiner üblichen Kolonnengröße
+ const pers = huelle.querySelector("#b-personen")!;
+ pers.disabled = wahl.value.startsWith("kolonne:");
+ const k = plan.leute.find((x) => x.id === wahl.value);
+ pers.value = k?.kolonnengroesse ? String(Number(k.kolonnengroesse)).replace(".", ",") : "1";
+ };
};
const neu = async () => { Object.assign(plan, await api("terminplan")); zeichne(); };
zeichne();
@@ -910,7 +1014,7 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise("#b-personen")!.value.replace(",", "."));
if (!w || (w === "platzhalter" && !platzhalter)) throw new Error("Bitte eine Person oder einen Platzhalter wählen.");
if (!(personen > 0)) throw new Error("Personen muss größer als 0 sein.");
- await api("besetzungen", "POST", { vorgang_id: v.id, personen, ...(w === "platzhalter" ? { platzhalter } : { kontakt_id: w }) });
+ await api("besetzungen", "POST", { vorgang_id: v.id, ...(w === "platzhalter" ? { platzhalter, personen } : w.startsWith("kolonne:") ? { kolonne_id: w.slice(8) } : { kontakt_id: w, personen }) });
return neu();
}
} catch (e) {
diff --git a/src/web/personal.ts b/src/web/personal.ts
index 374ab4e..6214684 100644
--- a/src/web/personal.ts
+++ b/src/web/personal.ts
@@ -2,6 +2,7 @@
// Inhaber und Büro; den Stundenlohn sieht nur der Inhaber (U2).
import { formatEuro } from "../domain/geld.js";
+import { montagDerWoche } from "../domain/datum.js";
import { ABWESENHEIT_TEXT, modellText, type AbwesenheitArt } from "../domain/personal.js";
import { type Feld, type Zeile, api, dat, dialog, esc, heute, inhalt, seite } from "./ui.js";
import { liste as tabelle } from "./liste.js";
@@ -25,23 +26,452 @@ function heuteText(t: Zeile | undefined): string {
return `${zahl(t.soll)} Std.`;
}
-export async function personalSeite(): Promise {
- const liste = await api(`personal?heute=${heute()}`);
+const FUNKTION: Record = { planer: "Planer", geselle: "Geselle", helfer: "Helfer" };
+const FUNKTIONEN = Object.entries(FUNKTION) as [string, string][];
+// Personal mit Reitern wie die Projektseite (Henning, 20.10.2026)
+const TEILE: [string, string][] = [["mitarbeiter", "Mitarbeiter"], ["kolonnen", "Kolonnen"], ["subunternehmer", "Subunternehmer"], ["urlaub", "Urlaub"], ["zeiten", "Zeiten"]];
+const subName = (k: Zeile) => (k.firma?.trim() ? k.firma : k.name) as string;
+const prozent = (n: number | null | undefined) => (n == null ? "" : `${String(Number(n)).replace(".", ",")} %`);
+/** Stunden pro Arbeitstag Mo–Do aus dem Arbeitszeitmodell (Woche Mo … So) */
+const tagesStunden = (stunden: number[] | undefined, vorgabe: number) => (stunden ? stunden.slice(0, 4).reduce((s, h) => s + Number(h), 0) / 4 : vorgabe);
+
+function teileLeiste(aktiv: string): void {
+ const kopf = document.createElement("div");
+ kopf.className = "teile-kopf personal-teile";
+ kopf.innerHTML = ``;
+ kopf.addEventListener("click", (ev) => {
+ const t = (ev.target as HTMLElement).closest("[data-teil]")?.dataset.teil;
+ if (t) location.hash = t === "mitarbeiter" ? "personal" : `personal-${t}`;
+ });
+ inhalt.querySelector(".kopf")!.after(kopf);
+}
+
+/** Status aus Eintritt und Austritt */
+function personStatus(s: Zeile | null): ["aktiv" | "geplant" | "ausgeschieden", string] {
+ if (s?.austritt && s.austritt < heute()) return ["ausgeschieden", "grau"];
+ if (s?.eintritt && s.eintritt > heute()) return ["geplant", "offen"];
+ return ["aktiv", "gut"];
+}
+
+export async function personalSeite(teil = "mitarbeiter"): Promise {
+ if (teil === "kolonnen") return kolonnenTeil();
+ if (teil === "subunternehmer") return subunternehmerTeil();
+ if (teil === "urlaub") return urlaubTeil();
+ if (teil === "zeiten") return zeitenTeil();
+ const [liste, tp, kolonnen, mitglieder] = await Promise.all([
+ api(`personal?heute=${heute()}`), api("terminplan"), api("kolonnen"), api("kolonnen-mitglieder"),
+ ]);
seite("Personal", { text: "Neuer Mitarbeiter", aktion: neuerMitarbeiter });
+ teileLeiste("mitarbeiter");
if (!liste.length) {
inhalt.insertAdjacentHTML("beforeend", '