Personal mit Reitern, Kolonnen, Subunternehmer mit Kosten und § 48b, % erledigt im Terminplan (0.15.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:
10
CHANGELOG.md
10
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.
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "betrieb",
|
||||
"version": "0.14.1",
|
||||
"version": "0.15.0",
|
||||
"private": true,
|
||||
"description": "Betriebsführungsprogramm Schaarschmidt Holzbau",
|
||||
"type": "module",
|
||||
|
||||
@@ -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<Besetzung, "kontakt_id" | "platzhalter">): 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<Besetzung, "kontakt_id" | "platzhalter"> & { 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;
|
||||
}
|
||||
|
||||
45
src/domain/fortschritt.ts
Normal file
45
src/domain/fortschritt.ts
Normal file
@@ -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);
|
||||
}
|
||||
@@ -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;
|
||||
|
||||
@@ -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<FastifyInstance> {
|
||||
// Ä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<T>(c: Client, tabelle: string, fn: () => Promise<T>, bewegt: string[] = [], zahlungVon?: string): Promise<T> {
|
||||
const e = await ladeEinstellungen();
|
||||
@@ -234,6 +237,8 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
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<FastifyInstance> {
|
||||
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;
|
||||
});
|
||||
|
||||
|
||||
@@ -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<boolean> {
|
||||
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) }))
|
||||
|
||||
97
src/server/migrations/013_kolonnen_subunternehmer.sql
Normal file
97
src/server/migrations/013_kolonnen_subunternehmer.sql
Normal file
@@ -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;
|
||||
116
src/server/subunternehmer.ts
Normal file
116
src/server/subunternehmer.ts
Normal file
@@ -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<void> {
|
||||
const einsaetze = (await c.query<Einsatz>(
|
||||
`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<string, Soll>();
|
||||
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]);
|
||||
}
|
||||
}
|
||||
@@ -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(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
|
||||
@@ -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<KapBesetzung>("select vorgang_id, kontakt_id, platzhalter, personen from besetzung"),
|
||||
// eine Kolonne zählt mit jedem ihrer Mitglieder
|
||||
c.query<KapBesetzung>("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<T>(
|
||||
}
|
||||
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<string, string>(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,
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -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<void> {
|
||||
? "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."}</p>`;
|
||||
}
|
||||
// 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", `<p class="abarbeitung"><b>Abarbeitungsstand ${stand} %</b> laut Terminplan = ${euro(verdient)} von ${euro(umsatz)} netto.
|
||||
Gestellt oder bezahlt: ${euro(abgerechnet)}.${verdient > abgerechnet ? ` Nach Abarbeitungsstand abrechenbar: <b>${euro(verdient - abgerechnet)}</b>.` : ""}</p>`);
|
||||
}
|
||||
teil.append(info);
|
||||
if (eigeneZahlungen.length) {
|
||||
teil.append(liste({
|
||||
@@ -698,7 +707,7 @@ async function uebersicht(): Promise<void> {
|
||||
<small>${a.faellig_am ? `${WOCHENTAG[wtag(a.faellig_am)]} ${dat(a.faellig_am).slice(0, 6)}` : "ohne Datum"}${a.projekt_nummer ? ` · ${esc(a.projekt_nummer)}` : ""}${a.kontakt_name ? ` · ${esc(a.kontakt_name)}` : ""}</small>${a.kategorie ? `<span class="kategorie">${esc(a.kategorie)}</span>` : ""}</li>`;
|
||||
const gruppe = (titel: string, liste: Zeile[], leer: string, warn = false) => `<div class="gruppe${warn && liste.length ? " warn" : ""}">
|
||||
<h3>${titel} <b>${liste.length}</b></h3>${liste.length ? `<ul class="aufgaben">${liste.map(aufgabeLi).join("")}</ul>` : `<p class="hinweis">${leer}</p>`}</div>`;
|
||||
const SYMBOL: Record<string, string> = { ueberschneidung: "⚠", unbesetzt: "👤", freigabe: "✋", aufgabe: "⏰", kontostand: "€", urlaub: "☀" };
|
||||
const SYMBOL: Record<string, string> = { ueberschneidung: "⚠", unbesetzt: "👤", freigabe: "✋", aufgabe: "⏰", kontostand: "€", urlaub: "☀", freistellung: "§" };
|
||||
|
||||
const raster = document.createElement("div");
|
||||
raster.className = "start";
|
||||
@@ -924,7 +933,7 @@ function reiterFuer(s: Sitzung): Reiter[] {
|
||||
if (rolle === "mitarbeiter") return [["stunden", "Stunden", () => meineStunden()], ["meine-einsaetze", "Einsätze", meineEinsaetze], ["urlaub", "Urlaub", meinUrlaub]];
|
||||
const alle: Reiter[] = [
|
||||
["uebersicht", "Übersicht", uebersicht], ["aufgaben", "Aufgaben", aufgaben], ["projekte", "Projekte", projekte],
|
||||
["terminplan", "Terminplan", terminplan], ["personal", "Personal", personalSeite], ["stunden", "Stunden", stundenSeite], ["kontakte", "Kontakte", kontakte],
|
||||
["terminplan", "Terminplan", terminplan], ["personal", "Personal", () => personalSeite()], ["stunden", "Stunden", stundenSeite], ["kontakte", "Kontakte", kontakte],
|
||||
["liquiditaet", "Liquidität", () => liquiditaetSeite()], ["laufende-kosten", "Laufende Kosten", laufendeKosten],
|
||||
];
|
||||
if (rolle === "inhaber") alle.push(["benutzer", "Benutzer", () => benutzerSeite(s)], ["daten", "Daten", daten]);
|
||||
@@ -963,13 +972,21 @@ async function zeige(): Promise<void> {
|
||||
const treffer = /^projekt-([0-9a-f-]{36})(?:-(dokumente|berichte|ablage|zahlungen))?$/.exec(id);
|
||||
const ablage = /^ablage-([0-9a-f-]{36})$/.exec(id)?.[1];
|
||||
const mitarbeiter = /^mitarbeiter-([0-9a-f-]{36})$/.exec(id)?.[1];
|
||||
// Personal mit Reitern, Kolonne und Subunternehmer (0.15)
|
||||
const personalTeil = /^personal-(kolonnen|subunternehmer|urlaub|zeiten)$/.exec(id)?.[1];
|
||||
const kolonne = /^kolonne-([0-9a-f-]{36})$/.exec(id)?.[1];
|
||||
const sub = /^subunternehmer-([0-9a-f-]{36})$/.exec(id)?.[1];
|
||||
const zuPersonal = mitarbeiter || personalTeil || kolonne || sub;
|
||||
const projekt = treffer?.[1];
|
||||
if (treffer?.[2]) projektTeil = treffer[2];
|
||||
const reiter = REITER.find(([r]) => r === (projekt ? "projekte" : mitarbeiter ? "personal" : id)) ?? REITER[0]!;
|
||||
const reiter = REITER.find(([r]) => r === (projekt ? "projekte" : zuPersonal ? "personal" : id)) ?? REITER[0]!;
|
||||
nav.querySelectorAll("button").forEach((b) => b.classList.toggle("aktiv", b.dataset.r === reiter[0]));
|
||||
try {
|
||||
await (ablage ? ablageSeite(ablage)
|
||||
: mitarbeiter && reiter[0] === "personal" ? mitarbeiterSeite(mitarbeiter, sitzung?.benutzer?.rolle === "inhaber")
|
||||
: kolonne && reiter[0] === "personal" ? kolonneSeite(kolonne)
|
||||
: sub && reiter[0] === "personal" ? subunternehmerSeite(sub)
|
||||
: personalTeil && reiter[0] === "personal" ? personalSeite(personalTeil)
|
||||
: projekt && reiter[0] === "projekte" ? projektSeite(projekt) : reiter[2]());
|
||||
} catch (e) {
|
||||
inhalt.insertAdjacentHTML("beforeend", `<p class="fehler">${esc((e as Error).message)}</p>`);
|
||||
|
||||
148
src/web/gantt.ts
148
src/web/gantt.ts
@@ -8,6 +8,7 @@ import { formatEuro, parseEuro } from "../domain/geld.js";
|
||||
import { bezugText, leseBezug } from "../domain/bezug.js";
|
||||
import { type Datum, formatDatum, plusTage, tageZwischen, wochentag, montagDerWoche } from "../domain/datum.js";
|
||||
import { wer } from "../domain/einsatz.js";
|
||||
import { gesamtFortschritt, imVerzug, sollFortschritt } from "../domain/fortschritt.js";
|
||||
import { type Arbeitswoche, arbeitstageZwischen, feiertag, istArbeitstag, naechsterArbeitstag } from "../domain/kalender.js";
|
||||
|
||||
type Zeile = Record<string, any>;
|
||||
@@ -27,6 +28,8 @@ export interface Hilfen {
|
||||
}
|
||||
interface FilterWert { wert: string; text: string; anzahl: number }
|
||||
interface GanttAnsicht { sort: [string, "auf" | "ab"][]; filter: Record<string, string[]>; zeit: Record<string, string>; aus: string[] }
|
||||
/** Nur beauftragte und laufende Projekte zeigen „im Verzug“ */
|
||||
const LAUFEND = new Set(["auftrag", "ausfuehrung"]);
|
||||
/** Ausgeblendete Zeilen gerade zeigen (bis zum Neuladen der Seite) */
|
||||
let ausZeigen = false;
|
||||
const OHNE = "(ohne Besetzung)";
|
||||
@@ -44,6 +47,8 @@ interface Plan {
|
||||
kosten?: Zeile[];
|
||||
aufgaben?: Zeile[];
|
||||
arbeitstage: number[];
|
||||
/** 0.15: Kolonnen mit ihren Mitgliedern (Kontakt-IDs) */
|
||||
kolonnen?: Zeile[];
|
||||
team?: string[];
|
||||
auslastung?: { ab: Datum; geplant: number; verfuegbar: number; personen: { kontakt_id: string; geplant: number; verfuegbar: number }[] }[];
|
||||
}
|
||||
@@ -59,10 +64,10 @@ const ZEILE = 42;
|
||||
const BALKEN_MITTE = 28;
|
||||
const LINKS_MIN = 60;
|
||||
// Spaltenbreiten links, am Spaltenkopf ziehbar und gemerkt (Henning, 20.10.2026); auf kleineren Bildschirmen schmaler
|
||||
const SPALTEN = ["nr", "name", "dauer", "vg", "anfang", "ende", "res"] as const;
|
||||
const SPALTEN = ["nr", "name", "dauer", "vg", "anfang", "ende", "erl", "res"] as const;
|
||||
type Spalte = (typeof SPALTEN)[number];
|
||||
const BREITE_GROSS: Record<Spalte, number> = { nr: 40, name: 260, dauer: 70, vg: 70, anfang: 96, ende: 96, res: 140 };
|
||||
const BREITE_KLEIN: Record<Spalte, number> = { nr: 32, name: 170, dauer: 56, vg: 48, anfang: 84, ende: 84, res: 100 };
|
||||
const BREITE_GROSS: Record<Spalte, number> = { nr: 40, name: 260, dauer: 70, vg: 70, anfang: 96, ende: 96, erl: 58, res: 140 };
|
||||
const BREITE_KLEIN: Record<Spalte, number> = { nr: 32, name: 170, dauer: 56, vg: 48, anfang: 84, ende: 84, erl: 50, res: 100 };
|
||||
const SPALTE_MIN = 16;
|
||||
const WOCHENTAGE = ["Son", "Mon", "Die", "Mit", "Don", "Fre", "Sam"];
|
||||
const FARBEN = ["#1d5fa8", "#2f6b5a", "#b7791f", "#a26e3a", "#805ad5", "#c53030", "#2c7a7b", "#97266d", "#4a5568", "#6b8e23"];
|
||||
@@ -101,7 +106,7 @@ export const dauerText = (n: number) => `${n} ${n === 1 ? "Tag" : "Tage"}`;
|
||||
let weiter: { id: string; feld: string } | null = null;
|
||||
/** In welcher Spalte ein Feld steht; Enter springt in dieselbe Spalte der nächsten Zeile */
|
||||
const SPALTE_VON: Record<string, Spalte> = {
|
||||
name: "name", dauer: "dauer", vg: "vg", start: "anfang", ende: "ende",
|
||||
name: "name", dauer: "dauer", vg: "vg", start: "anfang", ende: "ende", erl: "erl",
|
||||
"t-text": "name", "t-vg": "vg", "t-datum": "anfang",
|
||||
"z-name": "name", "z-vg": "vg", "z-datum": "anfang", "z-betrag": "res",
|
||||
"k-name": "name", "k-vg": "vg", "k-datum": "anfang", "k-betrag": "res",
|
||||
@@ -167,6 +172,8 @@ 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); }
|
||||
// eine Kolonne zählt im Filter auch für jedes ihrer Mitglieder
|
||||
const werAlle = (b: Zeile): (string | undefined)[] => [wer(b), ...((b.mitglieder as string[] | undefined) ?? [])];
|
||||
// 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 ?? [];
|
||||
@@ -174,14 +181,14 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
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);
|
||||
const leute = plan.besetzungen.filter((b) => b.vorgang_id === v.id).flatMap(werAlle);
|
||||
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 })),
|
||||
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) => werAlle(b).includes(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 };
|
||||
@@ -347,6 +354,18 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
+ (a ? `<span class="b-von" style="left:${links - 4}px">${balkenDatum(a)}</span>` : "")
|
||||
+ (e ? `<span class="b-bis" style="left:${rechts + 4}px">${balkenDatum(e)}${nachEnde}</span>` : "");
|
||||
|
||||
const fv = (v: Zeile) => ({ anfang: v.anfang as Datum, ende: v.ende as Datum, dauer: Number(v.dauer), stunden: v.stunden == null ? null : Number(v.stunden), fortschritt: Number(v.fortschritt) || 0 });
|
||||
// Stand von Projekt und Abschnitt: nach Stunden gewichtet (ohne Stunden nach Dauer)
|
||||
const vorgaengeVon = (r: Reihe) => (r.art === "p" ? plan.vorgaenge.filter((v) => plan.abschnitte.some((a) => a.id === v.abschnitt_id && a.projekt_id === r.obj.id))
|
||||
: plan.vorgaenge.filter((v) => v.abschnitt_id === r.obj.id)).map(fv);
|
||||
const standZelle = (r: Reihe) => {
|
||||
const vs = vorgaengeVon(r);
|
||||
const g = gesamtFortschritt(vs);
|
||||
if (g === null) return "<span></span>";
|
||||
const verzug = LAUFEND.has(r.projekt.status) && vs.some((v) => imVerzug(v, heute, woche));
|
||||
return `<span class="zahl erl summe${g >= 100 ? " fertig" : verzug ? " verzug" : ""}" data-erl-summe="${r.art}:${r.obj.id}" title="${g} % erledigt, nach Stunden gewichtet${verzug ? " · mindestens ein Vorgang im Verzug" : ""} · klicken: alles bis heute als erledigt markieren">${g >= 100 ? "✓ " : ""}${g} %</span>`;
|
||||
};
|
||||
|
||||
// Tabelle links und Balken je Zeile
|
||||
const zeilenHtml = reihen.map((r, i) => {
|
||||
const o = r.obj;
|
||||
@@ -361,7 +380,7 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
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><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)}
|
||||
${dauerZelle()}<span></span>${datumZelle(r.von)}${datumZelle(r.bis)}${standZelle(r)}
|
||||
<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"
|
||||
? `<button class="verweis g-raten" data-zahlungsplan="${o.id}" title="Standard-Zahlungsplan 30/40/20/10 als Meilensteine anlegen">€ Plan anlegen</button>`
|
||||
@@ -372,7 +391,7 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
} 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="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>`;
|
||||
${dauerZelle()}<span></span>${datumZelle(r.von)}${datumZelle(r.bis)}${standZelle(r)}<span></span>`;
|
||||
if (r.von) balken = sammel() + beschriftung(x(r.von), x(r.bis!) + W, esc(o.name), r.von, r.bis);
|
||||
} else if (r.art === "g") {
|
||||
// Abschnitte „Aufgaben“ und „Ausgaben“
|
||||
@@ -386,7 +405,7 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
: !l.length ? "" : g === "ein" ? `<span class="betrag ein">+${formatEuro(ein)}</span>` : `<span class="betrag aus">−${formatEuro(aus)}</span>`;
|
||||
links = `${nr}<span class="name ebene1">${klapp}<span class="text">${esc(o.name)}</span>
|
||||
<span class="aktionen">${neu ? `<button class="plus" data-neu-posten="${neu}:${r.projekt.id}" title="${titelNeu}">+</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>
|
||||
<span></span><span></span>${datumZelle(r.von)}${datumZelle(r.bis)}<span class="res-betrag">${res}</span>`;
|
||||
<span></span><span></span>${datumZelle(r.von)}${datumZelle(r.bis)}<span></span><span class="res-betrag">${res}</span>`;
|
||||
} else if (r.art === "t" || r.art === "z" || r.art === "k") {
|
||||
const art = r.art;
|
||||
const zelle = (feld: string, klasse: string, inhaltHtml: string, titel: string) =>
|
||||
@@ -400,14 +419,14 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
if (art === "t") {
|
||||
links = `${nr}<span class="name ebene2"><input type="checkbox" class="t-haken" data-erledigt="${o.id}"${fertig ? " checked" : ""} aria-label="Erledigt">${zelle("t-text", `text${fertig ? " erledigt" : ""}`, esc(o.text), "Aufgabe")}
|
||||
<span class="aktionen">${auge}${weg}</span></span>
|
||||
<span></span>${zelle("t-vg", "vg", esc(bezugText(o, zeilenNr)), vgTitel)}${zelle("t-datum", "zahl", d ? tabellenDatum(d) : '<span class="leer">Datum</span>', "Fällig am")}<span></span>
|
||||
<span></span>${zelle("t-vg", "vg", esc(bezugText(o, zeilenNr)), vgTitel)}${zelle("t-datum", "zahl", d ? tabellenDatum(d) : '<span class="leer">Datum</span>', "Fällig am")}<span></span><span></span>
|
||||
<span class="leise-text" title="Kategorie">${esc(o.kategorie ?? "")}</span>`;
|
||||
} else {
|
||||
const statusText = art === "z" ? ({ geplant: "geplant", gestellt: "Rechnung gestellt", bezahlt: "bezahlt" } as Record<string, string>)[o.status] ?? o.status
|
||||
: ({ geplant: "geplant", bestellt: "bestellt", bezahlt: "bezahlt" } as Record<string, string>)[o.status] ?? o.status;
|
||||
links = `${nr}<span class="name ebene2">${zelle(`${art}-name`, "text", `${esc(o.bezeichnung)} <small>${esc(statusText)}${o.rest ? " · Rest" : ""}</small>`, "Bezeichnung")}
|
||||
<span class="aktionen">${auge}${weg}</span></span>
|
||||
<span></span>${zelle(`${art}-vg`, "vg", esc(bezugText(o, zeilenNr)), vgTitel)}${zelle(`${art}-datum`, "zahl", d ? tabellenDatum(d) : "", art === "z" ? "Fällig am" : "Termin")}<span></span>
|
||||
<span></span>${zelle(`${art}-vg`, "vg", esc(bezugText(o, zeilenNr)), vgTitel)}${zelle(`${art}-datum`, "zahl", d ? tabellenDatum(d) : "", art === "z" ? "Fällig am" : "Termin")}<span></span><span></span>
|
||||
${zelle(`${art}-betrag`, `betrag ${art === "z" ? "ein" : "aus"}`, betrag, art === "z" && o.art === "schluss" ? "Betrag netto; leer lassen = Rest aus Auftragswert und den anderen Raten" : "Betrag netto")}`;
|
||||
}
|
||||
if (d) {
|
||||
@@ -421,6 +440,11 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
}
|
||||
} else {
|
||||
const ms = Number(o.dauer) === 0;
|
||||
// Abarbeitungsgrad: Balken füllt sich, fertig grün mit Haken, im Verzug rot
|
||||
const ist = Number(o.fortschritt) || 0;
|
||||
const verzug = LAUFEND.has(r.projekt.status) && imVerzug(fv(o), heute, woche);
|
||||
const soll = sollFortschritt(fv(o), heute, woche);
|
||||
const standTitel = `${ist} % erledigt${verzug ? ` · im Verzug: nach dem Kalender etwa ${soll} %` : ""} · klicken zum Ändern (0, 25, 50, 75, 100 %)`;
|
||||
const zelle = (feld: string, klasse: string, inhaltHtml: string, titel: string) =>
|
||||
`<span class="${klasse} zelle" data-id="${o.id}" data-feld="${feld}" data-spalte="${SPALTE_VON[feld]}" title="${titel}">${inhaltHtml}</span>`;
|
||||
links = `${nr}<span class="name ebene2">${zelle("name", "text", esc(o.name), "Bezeichnung")}
|
||||
@@ -428,14 +452,15 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
${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")}
|
||||
<span class="zahl erl${verzug ? " verzug" : ist >= 100 ? " fertig" : ""}" data-erl="${o.id}" title="${esc(standTitel)}">${ist >= 100 ? "✓ " : ""}${ist} %</span>
|
||||
<span class="leute" data-besetzung="${o.id}" title="Besetzung bearbeiten">${leuteHtml(o.id) || '<span class="leer">+ Personal</span>'}</span>`;
|
||||
const links0 = x(o.anfang), breite = (tageZwischen(o.anfang, o.ende) + 1) * W;
|
||||
const leute = leuteHtml(o.id) ? ` <span class="b-leute">${leuteHtml(o.id)}</span>` : "";
|
||||
balken = ms
|
||||
? `<div class="balken meilenstein" data-bar="${o.id}" style="left:${links0 + W / 2 - 6}px" title="${esc(o.name)} · ${formatDatum(o.anfang)}"></div>`
|
||||
? `<div class="balken meilenstein${ist >= 100 ? " fertig" : verzug ? " verzug" : ""}" data-bar="${o.id}" style="left:${links0 + W / 2 - 6}px" title="${esc(o.name)} · ${formatDatum(o.anfang)} · ${esc(standTitel)}"></div>`
|
||||
+ beschriftung(links0 + W / 2, links0 + W / 2 + 6, esc(o.name), undefined, o.anfang, leute)
|
||||
: `<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);
|
||||
: `<div class="balken vorgang${imKonflikt.has(o.id) ? " konflikt" : ""}${ist >= 100 ? " fertig" : verzug ? " verzug" : ""}" 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))} · ${esc(standTitel)} · Rechtsklick: % erledigt">${ist > 0 && ist < 100 ? `<i class="erledigt" style="width:${ist}%"></i>` : ""}${reduziertHtml(o, links0)}<i class="griff-rechts" data-dauer="${o.id}"></i></div>`
|
||||
+ beschriftung(links0, links0 + breite, `${ist >= 100 ? "✓ " : ""}${esc(o.name)}${verzug ? ' <b class="b-verzug">im Verzug</b>' : ""}`, o.anfang, o.ende, leute);
|
||||
}
|
||||
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>`;
|
||||
@@ -492,7 +517,7 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
rahmen.className = "g-rahmen";
|
||||
for (const k of SPALTEN) rahmen.style.setProperty(`--sp-${k}`, `${breiten[k]}px`);
|
||||
rahmen.innerHTML = `<div class="gantt"><div class="g-inhalt" style="width:calc(var(--links) + ${tage * W}px)">
|
||||
<div class="g-kopf"><div class="g-links kopf">${([["nr", "", "nr"], ["name", "Vorgangsname", "name"], ["dauer", "Dauer", "zahl"], ["vg", "Vorgänger", ""], ["anfang", "Anfang", "zahl"], ["ende", "Ende", "zahl"], ["res", "Ressourcen / Betrag", ""]] as const)
|
||||
<div class="g-kopf"><div class="g-links kopf">${([["nr", "", "nr"], ["name", "Vorgangsname", "name"], ["dauer", "Dauer", "zahl"], ["vg", "Vorgänger", ""], ["anfang", "Anfang", "zahl"], ["ende", "Ende", "zahl"], ["erl", "% erl.", "zahl"], ["res", "Ressourcen / Betrag", ""]] as const)
|
||||
.map(([k, titel, klasse]) => `<span class="${klasse}" title="${titel}">${titel}<i class="sp-griff" data-spalte="${k}" title="Ziehen ändert die Spaltenbreite"></i></span>`).join("")}</div>
|
||||
<div class="g-zeit"><div class="reihe">${oben}</div><div class="reihe unten s-${stufe}">${unten}</div></div></div>
|
||||
<div class="g-koerper" style="height:${hoehe}px">
|
||||
@@ -695,6 +720,10 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
try { await api(t.dataset.weg, "DELETE"); } catch (e) { meldung.textContent = (e as Error).message; return; }
|
||||
return neuLaden();
|
||||
}
|
||||
const erl = t.closest<HTMLElement>("[data-erl]");
|
||||
if (erl) return standMenue(erl, erl.dataset.erl!);
|
||||
const summe = t.closest<HTMLElement>("[data-erl-summe]");
|
||||
if (summe) return summenMenue(summe);
|
||||
const besetzungId = t.closest<HTMLElement>("[data-besetzung]")?.dataset.besetzung;
|
||||
if (besetzungId) return besetzungDialog(plan.vorgaenge.find((v) => v.id === besetzungId)!);
|
||||
const zelle = t.closest<HTMLElement>(".zelle");
|
||||
@@ -863,8 +892,75 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
neuLaden();
|
||||
}
|
||||
|
||||
// % erledigt: Schnellwahl 0/25/50/75/100 oder eigene Zahl; per Klick in die Spalte oder Rechtsklick auf den Balken
|
||||
function standMenue(anker: HTMLElement, id: string, punkt?: { x: number; y: number }): void {
|
||||
document.querySelector(".erl-menue")?.remove();
|
||||
const v = plan.vorgaenge.find((x) => x.id === id);
|
||||
if (!v) return;
|
||||
const ist = Number(v.fortschritt) || 0;
|
||||
const m = document.createElement("div");
|
||||
m.className = "erl-menue";
|
||||
m.setAttribute("role", "menu");
|
||||
m.innerHTML = `<b>${esc(v.name)}: erledigt</b><div>${[0, 25, 50, 75, 100].map((n) => `<button class="neben${n === ist ? " an" : ""}" data-wert="${n}">${n === 100 ? "✓ 100" : n} %</button>`).join("")}</div>
|
||||
<label>Andere Zahl <input inputmode="numeric" value="${ist}" aria-label="Prozent erledigt"> %</label>`;
|
||||
document.body.appendChild(m);
|
||||
const r = anker.getBoundingClientRect();
|
||||
const x0 = punkt?.x ?? r.left, y0 = punkt?.y ?? r.bottom + 2;
|
||||
m.style.left = `${Math.max(8, Math.min(x0, window.innerWidth - m.offsetWidth - 8))}px`;
|
||||
m.style.top = `${Math.min(y0, window.innerHeight - m.offsetHeight - 8)}px`;
|
||||
const zu = () => { m.remove(); document.removeEventListener("pointerdown", aussen, true); };
|
||||
const aussen = (e: Event) => { if (!m.contains(e.target as Node)) zu(); };
|
||||
setTimeout(() => document.addEventListener("pointerdown", aussen, true));
|
||||
const setze = async (n: number) => {
|
||||
zu();
|
||||
if (!(n >= 0 && n <= 100)) { meldung.textContent = "Bitte eine Zahl von 0 bis 100 eingeben."; return; }
|
||||
try { await api(`vorgaenge/${id}`, "PATCH", { fortschritt: Math.round(n) }); meldung.textContent = ""; } catch (e) { meldung.textContent = (e as Error).message; }
|
||||
neuLaden();
|
||||
};
|
||||
m.addEventListener("click", (e) => { const w = (e.target as HTMLElement).closest<HTMLElement>("[data-wert]")?.dataset.wert; if (w) void setze(Number(w)); });
|
||||
const ein = m.querySelector("input")!;
|
||||
ein.addEventListener("keydown", (e) => {
|
||||
if (e.key === "Enter") void setze(Number(ein.value.replace(",", ".").replace("%", "").trim()));
|
||||
if (e.key === "Escape") zu();
|
||||
});
|
||||
m.querySelector<HTMLButtonElement>(".an")?.focus();
|
||||
}
|
||||
// Projekt oder Abschnitt: alles, was bis gestern geendet hat, auf 100 %
|
||||
function summenMenue(anker: HTMLElement): void {
|
||||
document.querySelector(".erl-menue")?.remove();
|
||||
const [art, id] = anker.dataset.erlSumme!.split(":");
|
||||
const vs = plan.vorgaenge.filter((v) => (art === "p" ? plan.abschnitte.some((a) => a.id === v.abschnitt_id && a.projekt_id === id) : v.abschnitt_id === id));
|
||||
const offen = vs.filter((v) => v.ende < heute && (Number(v.fortschritt) || 0) < 100);
|
||||
const m = document.createElement("div");
|
||||
m.className = "erl-menue";
|
||||
m.innerHTML = offen.length
|
||||
? `<b>${offen.length} ${offen.length === 1 ? "Vorgang ist" : "Vorgänge sind"} vor heute zu Ende, aber nicht auf 100 %</b><div><button class="haupt" data-alle>Alle als erledigt markieren</button><button class="neben" data-zu>Abbrechen</button></div>`
|
||||
: '<b>Alles, was vor heute endet, ist erledigt.</b><div><button class="neben" data-zu>OK</button></div>';
|
||||
document.body.appendChild(m);
|
||||
const r = anker.getBoundingClientRect();
|
||||
m.style.left = `${Math.max(8, Math.min(r.left, window.innerWidth - m.offsetWidth - 8))}px`;
|
||||
m.style.top = `${Math.min(r.bottom + 2, window.innerHeight - m.offsetHeight - 8)}px`;
|
||||
m.addEventListener("click", async (e) => {
|
||||
const b = e.target as HTMLElement;
|
||||
if (b.hasAttribute("data-zu")) m.remove();
|
||||
if (!b.hasAttribute("data-alle")) return;
|
||||
m.remove();
|
||||
try { for (const v of offen) await api(`vorgaenge/${v.id}`, "PATCH", { fortschritt: 100 }); } catch (err) { meldung.textContent = (err as Error).message; }
|
||||
neuLaden();
|
||||
});
|
||||
}
|
||||
box.addEventListener("contextmenu", (ev) => {
|
||||
const bar = (ev.target as HTMLElement).closest<HTMLElement>("[data-bar]");
|
||||
if (!bar) return;
|
||||
ev.preventDefault();
|
||||
standMenue(bar, bar.dataset.bar!, { x: ev.clientX, y: ev.clientY });
|
||||
});
|
||||
|
||||
// Besetzung bearbeiten: Liste mit Freigabe, darunter Person oder Platzhalter hinzufügen
|
||||
function besetzungDialog(v: Zeile): void {
|
||||
const leuteName = (id: string) => { const k = plan.leute.find((x) => x.id === id); return k ? (k.rolle === "subunternehmer" && k.firma ? k.firma : k.name) : "?"; };
|
||||
const mitgliederText = (ids: string[]) => (ids.length ? ids.map(leuteName).join(", ") : "noch ohne Mitglieder");
|
||||
const mitSub = (b: Zeile) => (b.mitglieder ?? []).some((id: string) => plan.leute.find((k) => k.id === id)?.rolle === "subunternehmer");
|
||||
const huelle = document.getElementById("dialog-huelle")!;
|
||||
const zeichne = () => {
|
||||
const liste = besetzungVon(v.id);
|
||||
@@ -879,22 +975,30 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
<div class="b-dauer"><label for="b-stunden">Arbeitsstunden für diesen Vorgang</label><input id="b-stunden" inputmode="decimal" value="${vv.stunden != null ? zahl(Number(vv.stunden)) : ""}" placeholder="z. B. 32">
|
||||
<label class="schalter"><input type="checkbox" id="b-auto"${vv.dauer_fest ? "" : " checked"}> Dauer aus Stunden und Besetzung berechnen</label>
|
||||
<p class="hinweis">${ergebnis} Urlaub, Teilzeit und Feiertage zählen mit, der Freitag nicht.</p></div>
|
||||
${liste.length ? `<table><tbody>${liste.map((b) => `<tr><td>${esc(b.anzeige)}${b.rolle ? ` <small class="hinweis">${b.rolle === "mitarbeiter" ? "Mitarbeiter" : "Subunternehmer"}</small>` : ""}</td>
|
||||
<td class="zahl">${String(b.personen).replace(".", ",")} P.</td>
|
||||
<td>${b.rolle === "mitarbeiter" ? "" : `<label class="schalter"><input type="checkbox" data-frei="${b.id}"${b.freigegeben ? " checked" : ""}> freigegeben</label>`}</td>
|
||||
${liste.length ? `<table><tbody>${liste.map((b) => `<tr><td>${esc(b.anzeige)}${b.rolle ? ` <small class="hinweis">${b.rolle === "mitarbeiter" ? "Mitarbeiter" : "Subunternehmer"}</small>` : ""}${b.kolonne_id ? ` <small class="hinweis">Kolonne: ${esc(mitgliederText(b.mitglieder ?? []))}</small>` : ""}</td>
|
||||
<td class="zahl">${b.kolonne_id ? `${(b.mitglieder ?? []).length} P.` : `${String(b.personen).replace(".", ",")} P.`}</td>
|
||||
<td>${b.rolle === "mitarbeiter" || (b.kolonne_id && !mitSub(b)) ? "" : `<label class="schalter"><input type="checkbox" data-frei="${b.id}"${b.freigegeben ? " checked" : ""}> freigegeben</label>`}</td>
|
||||
<td><button class="neben" data-weg="${b.id}" title="Entfernen">×</button></td></tr>`).join("")}</tbody></table>` : '<p class="hinweis">Noch niemand eingeteilt.</p>'}
|
||||
<label for="b-wer">Hinzufügen</label>
|
||||
<select id="b-wer"><option value="">– auswählen –</option>
|
||||
${plan.leute.map((k) => `<option value="${k.id}">${esc(k.rolle === "subunternehmer" && k.firma ? k.firma : k.name)} (${k.rolle === "mitarbeiter" ? "Mitarbeiter" : "Subunternehmer"})</option>`).join("")}
|
||||
<option value="platzhalter">Platzhalter, z. B. N.N. oder Kolonne 2 …</option></select>
|
||||
${(plan.kolonnen ?? []).filter((o) => o.aktiv).map((o) => `<option value="kolonne:${o.id}">${esc(o.name)} (Kolonne, ${o.mitglieder.length} ${o.mitglieder.length === 1 ? "Person" : "Personen"})</option>`).join("")}
|
||||
<option value="platzhalter">Platzhalter, z. B. N.N. …</option></select>
|
||||
<input id="b-platzhalter" placeholder="Name des Platzhalters" hidden>
|
||||
<label for="b-personen">Personen</label><input id="b-personen" value="1" inputmode="decimal">
|
||||
<p class="hinweis">Subunternehmer und Platzhalter sind vorgemerkt, bis du sie freigibst. Mitarbeiter und Subunternehmer legst du unter Kontakte an.</p>
|
||||
<p class="hinweis">Subunternehmer, Platzhalter und Kolonnen mit Subunternehmern sind vorgemerkt, bis du sie freigibst. Kolonnen und Subunternehmer legst du unter Personal an.</p>
|
||||
<p class="fehler" id="b-fehler"></p>
|
||||
<div class="knoepfe"><button class="neben" data-a="zu">Fertig</button><button class="haupt" data-a="dazu">Hinzufügen</button></div></div>`;
|
||||
huelle.hidden = false;
|
||||
const wahl = huelle.querySelector<HTMLSelectElement>("#b-wer")!;
|
||||
wahl.onchange = () => (huelle.querySelector<HTMLInputElement>("#b-platzhalter")!.hidden = wahl.value !== "platzhalter");
|
||||
wahl.onchange = () => {
|
||||
huelle.querySelector<HTMLInputElement>("#b-platzhalter")!.hidden = wahl.value !== "platzhalter";
|
||||
// Kolonne: zählt mit ihren Mitgliedern; Subunternehmer kommt mit seiner üblichen Kolonnengröße
|
||||
const pers = huelle.querySelector<HTMLInputElement>("#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<Plan>("terminplan")); zeichne(); };
|
||||
zeichne();
|
||||
@@ -910,7 +1014,7 @@ export async function terminplanSeite(h: Hilfen, vorhanden?: Plan): Promise<void
|
||||
const personen = Number(huelle.querySelector<HTMLInputElement>("#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) {
|
||||
|
||||
@@ -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<void> {
|
||||
const liste = await api<Zeile[]>(`personal?heute=${heute()}`);
|
||||
const FUNKTION: Record<string, string> = { 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 = `<nav class="teile">${TEILE.map(([t, titel]) => `<button data-teil="${t}" class="${t === aktiv ? "aktiv" : ""}">${titel}</button>`).join("")}</nav>`;
|
||||
kopf.addEventListener("click", (ev) => {
|
||||
const t = (ev.target as HTMLElement).closest<HTMLElement>("[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<void> {
|
||||
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<Zeile[]>(`personal?heute=${heute()}`), api<Zeile>("terminplan"), api<Zeile[]>("kolonnen"), api<Zeile[]>("kolonnen-mitglieder"),
|
||||
]);
|
||||
seite("Personal", { text: "Neuer Mitarbeiter", aktion: neuerMitarbeiter });
|
||||
teileLeiste("mitarbeiter");
|
||||
if (!liste.length) {
|
||||
inhalt.insertAdjacentHTML("beforeend", '<p class="hinweis leer">Noch keine Mitarbeiter. Lege einen an oder gib einem Kontakt die Rolle „Mitarbeiter“.</p>');
|
||||
return;
|
||||
}
|
||||
// T16: Auslastung der nächsten vier Wochen, eingeplant gegen verfügbar
|
||||
const wochen = (tp.auslastung ?? []).filter((w: Zeile) => w.ab >= montagDerWoche(heute())).slice(0, 4);
|
||||
const last = (id: string) => {
|
||||
const p = wochen.map((w: Zeile) => w.personen.find((x: Zeile) => x.kontakt_id === id)).filter(Boolean);
|
||||
const geplant = p.reduce((s: number, x: Zeile) => s + x.geplant, 0), verfuegbar = p.reduce((s: number, x: Zeile) => s + x.verfuegbar, 0);
|
||||
return { geplant, verfuegbar, anteil: verfuegbar > 0 ? Math.round((geplant / verfuegbar) * 100) : null };
|
||||
};
|
||||
const kolonnenVon = (id: string) => mitglieder.filter((m) => m.kontakt_id === id).map((m) => kolonnen.find((o) => o.id === m.kolonne_id)?.name).filter(Boolean) as string[];
|
||||
const zeilen = liste.map((z) => ({ ...z, last: last(z.id), kolonnen: kolonnenVon(z.id), status: personStatus(z.stammdaten) }));
|
||||
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: "rolle", titel: "Rolle", text: (z) => FUNKTION[z.stammdaten?.funktion] ?? "", wert: (z) => esc(FUNKTION[z.stammdaten?.funktion] ?? "–") },
|
||||
{ id: "kolonne", titel: "Kolonne", text: (z) => z.kolonnen.join(", "), wert: (z) => esc(z.kolonnen.join(", ") || "–"), klasse: "optional" },
|
||||
{ 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: "auslastung", titel: "Auslastung 4 Wochen", art: "zahl", sortWert: (z) => z.last.anteil ?? -1, text: (z) => (z.last.anteil == null ? "" : `${z.last.anteil} %`),
|
||||
wert: (z) => (z.last.anteil == null ? '<span class="hinweis">–</span>'
|
||||
: `<span class="last-anteil${z.last.anteil > 100 ? " ueber" : z.last.anteil < 50 ? " leer" : ""}" title="${zahl(z.last.geplant)} von ${zahl(z.last.verfuegbar)} Std. eingeplant"><i style="width:${Math.min(100, z.last.anteil)}%"></i></span> ${z.last.anteil} %`) },
|
||||
{ id: "status", titel: "Status", text: (z) => z.status[0], wert: (z) => `<span class="marke ${z.status[1]}">${z.status[0]}</span>` },
|
||||
{ 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}`; },
|
||||
zeilen, klick: (z) => { location.hash = `mitarbeiter-${z.id}`; },
|
||||
}));
|
||||
}
|
||||
|
||||
// ---------- Kolonnen ----------
|
||||
|
||||
async function kolonnenTeil(): Promise<void> {
|
||||
const [kolonnen, mitglieder, kontakte, liste, subs, tp, e] = await Promise.all([
|
||||
api<Zeile[]>("kolonnen"), api<Zeile[]>("kolonnen-mitglieder"), api<Zeile[]>("kontakte"), api<Zeile[]>(`personal?heute=${heute()}`),
|
||||
api<Zeile[]>("subunternehmer"), api<Zeile>("terminplan"), api<Zeile>("einstellungen"),
|
||||
]);
|
||||
seite("Personal", { text: "Neue Kolonne", aktion: () => void neueKolonne(kontakte) });
|
||||
teileLeiste("kolonnen");
|
||||
inhalt.insertAdjacentHTML("beforeend", '<p class="hinweis">Eine Kolonne fasst Mitarbeiter und Subunternehmer zusammen und lässt sich im Terminplan unter „+ Personal“ als eine Ressource einplanen. Jeder kann in mehreren Kolonnen sein.</p>');
|
||||
if (!kolonnen.length) { inhalt.insertAdjacentHTML("beforeend", '<p class="hinweis leer">Noch keine Kolonne. Oben rechts „Neue Kolonne“.</p>'); return; }
|
||||
const kName = (id: string) => { const k = kontakte.find((x) => x.id === id); return k ? (k.rolle === "subunternehmer" ? subName(k) : k.name) : "?"; };
|
||||
const zeilen = kolonnen.map((o) => {
|
||||
const ids = mitglieder.filter((m) => m.kolonne_id === o.id).map((m) => m.kontakt_id as string);
|
||||
const kap = kapazitaet(ids, kontakte, liste, subs, e.stundenProTag);
|
||||
const einsaetze = tp.besetzungen.filter((b: Zeile) => b.kolonne_id === o.id && (tp.vorgaenge.find((v: Zeile) => v.id === b.vorgang_id)?.ende ?? "") >= heute()).length;
|
||||
return { ...o, ids, kap, einsaetze, leitung: o.leitung_kontakt_id ? kName(o.leitung_kontakt_id) : "" };
|
||||
});
|
||||
inhalt.appendChild(tabelle({
|
||||
schluessel: "kolonnen", einheit: ["Kolonne", "Kolonnen"],
|
||||
spalten: [
|
||||
{ id: "name", titel: "Kolonne", wert: (z) => `<b>${esc(z.name)}</b>` },
|
||||
{ id: "leitung", titel: "Leitung", wert: (z) => esc(z.leitung || "–") },
|
||||
{ id: "mitglieder", titel: "Mitglieder", text: (z) => z.ids.map(kName).join(", "), wert: (z) => esc(z.ids.map(kName).join(", ") || "noch niemand") },
|
||||
{ id: "personen", titel: "Personen", art: "zahl", sortWert: (z) => z.kap.personen, wert: (z) => zahl(z.kap.personen), klasse: "zahl" },
|
||||
{ id: "kapazitaet", titel: "Kapazität", art: "zahl", sortWert: (z) => z.kap.stunden, wert: (z) => `${zahl(z.kap.stunden)} Std./Tag`, klasse: "zahl" },
|
||||
{ id: "einsaetze", titel: "Einsätze offen", art: "zahl", sortWert: (z) => z.einsaetze, wert: (z) => String(z.einsaetze), klasse: "zahl" },
|
||||
{ id: "status", titel: "Status", text: (z) => (z.aktiv ? "aktiv" : "ruht"), wert: (z) => `<span class="marke ${z.aktiv ? "gut" : "grau"}">${z.aktiv ? "aktiv" : "ruht"}</span>` },
|
||||
],
|
||||
zeilen, klick: (z) => { location.hash = `kolonne-${z.id}`; },
|
||||
}));
|
||||
}
|
||||
|
||||
/** Personen und Stunden pro Arbeitstag einer Kolonne: Mitarbeiter nach Arbeitszeitmodell, Subunternehmer mit ihrer Kolonnengröße */
|
||||
function kapazitaet(ids: string[], kontakte: Zeile[], liste: Zeile[], subs: Zeile[], stundenProTag: number) {
|
||||
let personen = 0, stunden = 0;
|
||||
for (const id of ids) {
|
||||
const k = kontakte.find((x) => x.id === id);
|
||||
if (k?.rolle === "subunternehmer") {
|
||||
const n = Number(subs.find((s) => s.kontakt_id === id)?.kolonnengroesse ?? 1);
|
||||
personen += n; stunden += n * stundenProTag;
|
||||
} else {
|
||||
personen += 1; stunden += tagesStunden(liste.find((p) => p.id === id)?.stunden, stundenProTag);
|
||||
}
|
||||
}
|
||||
return { personen, stunden };
|
||||
}
|
||||
|
||||
async function neueKolonne(kontakte: Zeile[]): Promise<void> {
|
||||
const leute = kontakte.filter((k) => k.rolle === "mitarbeiter").map((k): [string, string] => [k.id, k.name]);
|
||||
const r = await dialog("Neue Kolonne", [{ name: "name", titel: "Name", pflicht: true, hilfe: "z. B. Kolonne 1 oder Dachkolonne" },
|
||||
{ name: "leitung_kontakt_id", titel: "Leitung", art: "auswahl", optionen: [["", "– keine –"], ...leute] }], {}, false);
|
||||
if (r?.aktion !== "speichern") return;
|
||||
const o = await api<Zeile>("kolonnen", "POST", r.daten);
|
||||
if (r.daten.leitung_kontakt_id) await api("kolonnen-mitglieder", "POST", { kolonne_id: o.id, kontakt_id: r.daten.leitung_kontakt_id });
|
||||
location.hash = `kolonne-${o.id}`;
|
||||
}
|
||||
|
||||
export async function kolonneSeite(id: string): Promise<void> {
|
||||
const [o, mitglieder, kontakte, liste, subs, tp, e] = await Promise.all([
|
||||
api<Zeile>(`kolonnen/${id}`), api<Zeile[]>("kolonnen-mitglieder"), api<Zeile[]>("kontakte"), api<Zeile[]>(`personal?heute=${heute()}`),
|
||||
api<Zeile[]>("subunternehmer"), api<Zeile>("terminplan"), api<Zeile>("einstellungen"),
|
||||
]);
|
||||
const neuLaden = () => kolonneSeite(id);
|
||||
const eigene = mitglieder.filter((m) => m.kolonne_id === id);
|
||||
const ids = eigene.map((m) => m.kontakt_id as string);
|
||||
const kap = kapazitaet(ids, kontakte, liste, subs, e.stundenProTag);
|
||||
const leute = kontakte.filter((k) => k.rolle === "mitarbeiter" || k.rolle === "subunternehmer");
|
||||
const kName = (k: Zeile) => (k.rolle === "subunternehmer" ? subName(k) : k.name);
|
||||
seite(o.name);
|
||||
inhalt.querySelector(".kopf")!.insertAdjacentHTML("afterbegin", '<a class="neben zurueck" href="#personal-kolonnen">← Kolonnen</a>');
|
||||
const projektVon = (v: Zeile) => tp.projekte.find((p: Zeile) => tp.abschnitte.some((a: Zeile) => a.id === v.abschnitt_id && a.projekt_id === p.id));
|
||||
const einsaetze = tp.besetzungen.filter((b: Zeile) => b.kolonne_id === id).map((b: Zeile) => ({ ...b, v: tp.vorgaenge.find((v: Zeile) => v.id === b.vorgang_id) }))
|
||||
.filter((b: Zeile) => b.v && b.v.ende >= heute()).sort((a: Zeile, b: Zeile) => (a.v.anfang < b.v.anfang ? -1 : 1));
|
||||
const raster = document.createElement("div");
|
||||
raster.className = "personal-raster";
|
||||
raster.innerHTML = `
|
||||
<section class="karte"><div class="karte-kopf"><h2>Kolonne</h2><button class="neben" data-a="bearbeiten">Bearbeiten</button></div>
|
||||
<dl class="werte">
|
||||
<dt>Leitung</dt><dd>${esc(kontakte.find((k) => k.id === o.leitung_kontakt_id)?.name ?? "–")}</dd>
|
||||
<dt>Status</dt><dd>${o.aktiv ? "aktiv, im Terminplan wählbar" : "ruht, im Terminplan nicht wählbar"}</dd>
|
||||
<dt>Kapazität</dt><dd>${zahl(kap.personen)} ${kap.personen === 1 ? "Person" : "Personen"}, ${zahl(kap.stunden)} Std. pro Arbeitstag</dd>
|
||||
${o.notiz ? `<dt>Notiz</dt><dd>${esc(o.notiz)}</dd>` : ""}
|
||||
</dl></section>
|
||||
<section class="karte"><div class="karte-kopf"><h2>Mitglieder</h2></div>
|
||||
${eigene.length ? `<table class="einfach"><tbody>${eigene.map((m) => {
|
||||
const k = kontakte.find((x) => x.id === m.kontakt_id) ?? {};
|
||||
const st = liste.find((p) => p.id === m.kontakt_id);
|
||||
const groesse = subs.find((s) => s.kontakt_id === k.id)?.kolonnengroesse;
|
||||
const rolle = k.rolle === "subunternehmer" ? `Subunternehmer${groesse ? `, ${zahl(Number(groesse))} P.` : ""}`
|
||||
: FUNKTION[st?.stammdaten?.funktion] ?? "Mitarbeiter";
|
||||
return `<tr><td>${esc(kName(k))}${k.id === o.leitung_kontakt_id ? ' <span class="marke gut">Leitung</span>' : ""}</td><td class="hinweis">${esc(rolle)}</td>
|
||||
<td><button class="neben" data-weg="${m.id}" title="Aus der Kolonne nehmen">×</button></td></tr>`;
|
||||
}).join("")}</tbody></table>` : '<p class="hinweis">Noch niemand in dieser Kolonne.</p>'}
|
||||
<div class="zeile-dazu"><select id="k-wer" aria-label="Mitglied hinzufügen"><option value="">– hinzufügen –</option>${leute.filter((k) => !ids.includes(k.id)).map((k) => `<option value="${k.id}">${esc(kName(k))} (${k.rolle === "mitarbeiter" ? "Mitarbeiter" : "Subunternehmer"})</option>`).join("")}</select>
|
||||
<button class="haupt" data-a="dazu">Hinzufügen</button></div>
|
||||
<p class="fehler" id="k-fehler"></p></section>
|
||||
<section class="karte breit"><div class="karte-kopf"><h2>Einsätze</h2><a class="neben" href="#terminplan">Terminplan</a></div>
|
||||
${einsaetze.length ? `<table class="einfach"><tbody>${einsaetze.map((b: Zeile) => { const p = projektVon(b.v); return `<tr><td>${esc(p ? `${p.nummer} ${p.bezeichnung}` : "")}</td><td>${esc(b.v.name)}</td><td>${dat(b.v.anfang)} – ${dat(b.v.ende)}</td>
|
||||
<td>${b.freigegeben ? '<span class="marke gut">freigegeben</span>' : '<span class="marke offen">vorgemerkt</span>'}</td></tr>`; }).join("")}</tbody></table>`
|
||||
: '<p class="hinweis">Keine anstehenden Einsätze. Im Terminplan beim Vorgang unter „+ Personal“ die Kolonne wählen.</p>'}</section>`;
|
||||
inhalt.appendChild(raster);
|
||||
raster.addEventListener("click", async (ev) => {
|
||||
const t = ev.target as HTMLElement;
|
||||
try {
|
||||
if (t.dataset.weg) { await api(`kolonnen-mitglieder/${t.dataset.weg}`, "DELETE"); return neuLaden(); }
|
||||
if (t.dataset.a === "dazu") {
|
||||
const w = raster.querySelector<HTMLSelectElement>("#k-wer")!.value;
|
||||
if (!w) throw new Error("Bitte jemanden auswählen.");
|
||||
await api("kolonnen-mitglieder", "POST", { kolonne_id: id, kontakt_id: w });
|
||||
return neuLaden();
|
||||
}
|
||||
if (t.dataset.a === "bearbeiten") {
|
||||
const r = await dialog("Kolonne", [
|
||||
{ name: "name", titel: "Name", pflicht: true },
|
||||
{ name: "leitung_kontakt_id", titel: "Leitung", art: "auswahl", optionen: [["", "– keine –"], ...ids.map((x): [string, string] => [x, kName(kontakte.find((k) => k.id === x) ?? {})])] },
|
||||
{ name: "aktiv", titel: "Status", art: "auswahl", optionen: [["ja", "aktiv"], ["nein", "ruht (im Terminplan nicht wählbar)"]] },
|
||||
{ name: "notiz", titel: "Notiz", art: "langtext" },
|
||||
], { ...o, aktiv: o.aktiv ? "ja" : "nein" }, true);
|
||||
if (!r) return;
|
||||
if (r.aktion === "loeschen") { await api(`kolonnen/${id}`, "DELETE"); location.hash = "personal-kolonnen"; return; }
|
||||
await api(`kolonnen/${id}`, "PATCH", { ...r.daten, aktiv: r.daten.aktiv !== "nein" });
|
||||
return neuLaden();
|
||||
}
|
||||
} catch (e) { raster.querySelector("#k-fehler")!.textContent = (e as Error).message; }
|
||||
});
|
||||
}
|
||||
|
||||
// ---------- Subunternehmer ----------
|
||||
|
||||
/** § 48b: Freistellungsbescheinigung gültig, bald fällig, abgelaufen oder fehlt */
|
||||
function freistellung(s: Zeile | undefined): [string, string] {
|
||||
const bis = s?.freistellung_bis as string | undefined;
|
||||
if (!bis) return ["fehlt", "schlecht"];
|
||||
if (bis < heute()) return [`abgelaufen seit ${dat(bis)}`, "schlecht"];
|
||||
const bald = new Date(Date.now() + 30 * 86400000).toISOString().slice(0, 10);
|
||||
return [`gültig bis ${dat(bis)}`, bis <= bald ? "offen" : "gut"];
|
||||
}
|
||||
const satzText = (s: Zeile | undefined) => !s ? "–" : s.abrechnung === "pauschale" ? "Pauschale"
|
||||
: s.stundensatz != null ? `${formatEuro(Number(s.stundensatz))}/Std.${s.helfersatz != null ? ` · Helfer ${formatEuro(Number(s.helfersatz))}` : ""}` : "–";
|
||||
const zahlungText = (s: Zeile | undefined) => !s ? "–" : [s.zahlungsziel_tage != null ? `${s.zahlungsziel_tage} Tage` : "",
|
||||
Number(s.skonto_prozent) > 0 ? `${prozent(s.skonto_prozent)} Skonto${s.skonto_tage != null ? ` in ${s.skonto_tage} Tagen` : ""}` : ""].filter(Boolean).join(" · ") || "–";
|
||||
|
||||
async function subunternehmerTeil(): Promise<void> {
|
||||
const [kontakte, subs, kosten, tp] = await Promise.all([api<Zeile[]>("kontakte"), api<Zeile[]>("subunternehmer"), api<Zeile[]>("kosten"), api<Zeile>("terminplan")]);
|
||||
seite("Personal", { text: "Neuer Subunternehmer", aktion: () => void neuerSub() });
|
||||
teileLeiste("subunternehmer");
|
||||
const liste = kontakte.filter((k) => k.rolle === "subunternehmer").map((k) => {
|
||||
const s = subs.find((x) => x.kontakt_id === k.id);
|
||||
const offen = kosten.filter((x) => x.kontakt_id === k.id && x.status !== "bezahlt").reduce((n, x) => n + Number(x.netto), 0);
|
||||
const einsaetze = tp.besetzungen.filter((b: Zeile) => (b.kontakt_id === k.id || b.mitglieder?.includes(k.id)) && (tp.vorgaenge.find((v: Zeile) => v.id === b.vorgang_id)?.ende ?? "") >= heute()).length;
|
||||
return { ...k, s, offen, einsaetze, frei: freistellung(s) };
|
||||
});
|
||||
if (!liste.length) { inhalt.insertAdjacentHTML("beforeend", '<p class="hinweis leer">Noch keine Subunternehmer. Oben rechts „Neuer Subunternehmer“, oder einem Kontakt die Rolle „Subunternehmer“ geben.</p>'); return; }
|
||||
inhalt.appendChild(tabelle({
|
||||
schluessel: "subunternehmer", einheit: ["Subunternehmer", "Subunternehmer"],
|
||||
spalten: [
|
||||
{ id: "name", titel: "Subunternehmer", text: (z) => subName(z), wert: (z) => `<b>${esc(subName(z))}</b>${z.firma?.trim() && z.name !== z.firma ? ` <small class="hinweis">${esc(z.name)}</small>` : ""}` },
|
||||
{ id: "gewerk", titel: "Gewerk", wert: (z) => esc(z.gewerk ?? "–") },
|
||||
{ id: "satz", titel: "Stundensatz", text: (z) => satzText(z.s), wert: (z) => esc(satzText(z.s)), sortWert: (z) => Number(z.s?.stundensatz ?? -1) },
|
||||
{ id: "zahlung", titel: "Zahlung", text: (z) => zahlungText(z.s), wert: (z) => esc(zahlungText(z.s)), klasse: "optional" },
|
||||
{ id: "einbehalt", titel: "Einbehalt", art: "zahl", sortWert: (z) => Number(z.s?.einbehalt_prozent ?? 0), wert: (z) => esc(prozent(z.s?.einbehalt_prozent) || "–"), klasse: "optional" },
|
||||
{ id: "freistellung", titel: "§ 48b", text: (z) => z.frei[0], sortWert: (z) => z.s?.freistellung_bis ?? "", wert: (z) => `<span class="marke ${z.frei[1]}">${esc(z.frei[0])}</span>` },
|
||||
{ id: "einsaetze", titel: "Einsätze offen", art: "zahl", sortWert: (z) => z.einsaetze, wert: (z) => String(z.einsaetze), klasse: "zahl" },
|
||||
{ id: "offen", titel: "Kosten offen", art: "zahl", sortWert: (z) => z.offen, wert: (z) => (z.offen ? formatEuro(z.offen) : "–"), klasse: "zahl" },
|
||||
],
|
||||
zeilen: liste, klick: (z) => { location.hash = `subunternehmer-${z.id}`; },
|
||||
}));
|
||||
}
|
||||
|
||||
const SUB_FELDER = (): Feld[] => [
|
||||
{ name: "firma", titel: "Firma" },
|
||||
{ name: "name", titel: "Ansprechpartner", pflicht: true },
|
||||
{ name: "gewerk", titel: "Gewerk", hilfe: "z. B. Dachdecker, Trockenbau, Kran" },
|
||||
{ name: "telefon", titel: "Telefon" },
|
||||
{ name: "email", titel: "E-Mail" },
|
||||
{ name: "abrechnung", titel: "Abrechnung", art: "auswahl", optionen: [["stunden", "nach Stunden"], ["pauschale", "Pauschale je Auftrag"]] },
|
||||
{ name: "stundensatz", titel: "Stundensatz netto (€)", art: "euro", hilfe: "Für die erste Person (Geselle). Mit Satz und Freigabe entstehen die Kosten im Terminplan von selbst." },
|
||||
{ name: "helfersatz", titel: "Satz je weiterer Person (€)", art: "euro", hilfe: "Leer = derselbe Stundensatz" },
|
||||
{ name: "kolonnengroesse", titel: "Übliche Kolonnengröße (Personen)", art: "zahl" },
|
||||
{ name: "zahlungsziel_tage", titel: "Zahlungsziel (Tage)", art: "zahl", hilfe: "Leer = Vorgabe aus den Einstellungen" },
|
||||
{ name: "skonto_prozent", titel: "Skonto (%)", art: "zahl" },
|
||||
{ name: "skonto_tage", titel: "Skonto innerhalb von (Tagen)", art: "zahl", hilfe: "Mit Skonto plant die Liquidität die Zahlung zur Skontofrist." },
|
||||
{ name: "einbehalt_prozent", titel: "Sicherheitseinbehalt (%)", art: "zahl", hilfe: "Wird erst nach der Gewährleistung (5 Jahre) ausgezahlt." },
|
||||
{ name: "freistellung_nr", titel: "Freistellungsbescheinigung § 48b, Nummer" },
|
||||
{ name: "freistellung_bis", titel: "Freistellungsbescheinigung gültig bis", art: "datum", hilfe: "30 Tage vor Ablauf kommt eine Warnung in der Übersicht." },
|
||||
{ name: "notiz", titel: "Notiz", art: "langtext" },
|
||||
];
|
||||
const KONTAKT_TEIL = ["firma", "name", "gewerk", "telefon", "email"];
|
||||
|
||||
/** Kontakt und Konditionen zusammen speichern */
|
||||
async function subSpeichern(d: Zeile, kontaktId: string | null, s: Zeile | undefined): Promise<string> {
|
||||
const kontakt = Object.fromEntries(KONTAKT_TEIL.map((f) => [f, d[f]]));
|
||||
const k = kontaktId ? await api<Zeile>(`kontakte/${kontaktId}`, "PATCH", kontakt) : await api<Zeile>("kontakte", "POST", { ...kontakt, rolle: "subunternehmer" });
|
||||
const kond = Object.fromEntries(Object.entries(d).filter(([f]) => !KONTAKT_TEIL.includes(f)));
|
||||
kond.abrechnung ??= "stunden";
|
||||
if (s) await api(`subunternehmer/${s.id}`, "PATCH", kond);
|
||||
else await api("subunternehmer", "POST", { ...kond, kontakt_id: k.id });
|
||||
return k.id;
|
||||
}
|
||||
|
||||
async function neuerSub(): Promise<void> {
|
||||
const r = await dialog("Neuer Subunternehmer", SUB_FELDER(), { abrechnung: "stunden" }, false);
|
||||
if (r?.aktion !== "speichern") return;
|
||||
location.hash = `subunternehmer-${await subSpeichern(r.daten, null, undefined)}`;
|
||||
}
|
||||
|
||||
let subTeil = "einsaetze";
|
||||
export async function subunternehmerSeite(kontaktId: string): Promise<void> {
|
||||
const [k, subs, kosten, tp, e] = await Promise.all([
|
||||
api<Zeile>(`kontakte/${kontaktId}`), api<Zeile[]>("subunternehmer"), api<Zeile[]>("kosten"), api<Zeile>("terminplan"), api<Zeile>("einstellungen"),
|
||||
]);
|
||||
const s = subs.find((x) => x.kontakt_id === kontaktId);
|
||||
const neuLaden = () => subunternehmerSeite(kontaktId);
|
||||
const frei = freistellung(s);
|
||||
seite(subName(k));
|
||||
inhalt.querySelector(".kopf")!.insertAdjacentHTML("afterbegin", '<a class="neben zurueck" href="#personal-subunternehmer">← Subunternehmer</a>');
|
||||
const projekt = (pid: string) => tp.projekte.find((p: Zeile) => p.id === pid);
|
||||
const projektVon = (v: Zeile) => projekt(tp.abschnitte.find((a: Zeile) => a.id === v.abschnitt_id)?.projekt_id);
|
||||
const eigeneKosten = kosten.filter((x) => x.kontakt_id === kontaktId);
|
||||
const einsaetze = tp.besetzungen.filter((b: Zeile) => b.kontakt_id === kontaktId || b.mitglieder?.includes(kontaktId))
|
||||
.map((b: Zeile) => ({ ...b, v: tp.vorgaenge.find((v: Zeile) => v.id === b.vorgang_id) })).filter((b: Zeile) => b.v)
|
||||
.sort((a: Zeile, b: Zeile) => (a.v.anfang < b.v.anfang ? 1 : -1));
|
||||
const ziel = (x: Zeile) => x.zahlungsziel_tage ?? e.zahlungsziele?.fremdTage ?? 7;
|
||||
const faellig = (x: Zeile) => new Date(Date.parse(`${x.termin}T00:00:00Z`) + ziel(x) * 86400000).toISOString().slice(0, 10);
|
||||
const raster = document.createElement("div");
|
||||
raster.className = "personal-raster";
|
||||
raster.innerHTML = `
|
||||
<section class="karte"><div class="karte-kopf"><h2>Konditionen</h2><button class="neben" data-a="bearbeiten">Bearbeiten</button></div>
|
||||
<dl class="werte">
|
||||
<dt>Gewerk</dt><dd>${esc(k.gewerk ?? "–")}</dd>
|
||||
<dt>Abrechnung</dt><dd>${esc(satzText(s))}</dd>
|
||||
<dt>Kolonnengröße</dt><dd>${s?.kolonnengroesse ? `${zahl(Number(s.kolonnengroesse))} Personen` : "–"}</dd>
|
||||
<dt>Zahlungsziel</dt><dd>${esc(zahlungText(s))}</dd>
|
||||
<dt>Sicherheitseinbehalt</dt><dd>${esc(prozent(s?.einbehalt_prozent) || "–")}</dd>
|
||||
<dt>Kontakt</dt><dd>${esc([k.firma?.trim() ? k.name : "", k.telefon, k.email].filter(Boolean).join(" · ") || "–")}</dd>
|
||||
</dl>
|
||||
${s?.abrechnung !== "pauschale" && !s?.stundensatz ? '<p class="hinweis">Mit einem Stundensatz entstehen die Kosten jedes freigegebenen Einsatzes von selbst im Terminplan und in der Liquidität.</p>' : ""}</section>
|
||||
<section class="karte"><div class="karte-kopf"><h2>Freistellung § 48b</h2></div>
|
||||
<p><span class="marke ${frei[1]}">${esc(frei[0])}</span>${s?.freistellung_nr ? ` <span class="hinweis">Nr. ${esc(s.freistellung_nr)}</span>` : ""}</p>
|
||||
<p class="hinweis">Ohne gültige Freistellungsbescheinigung musst du 15 % jeder Rechnung als Bauabzugsteuer einbehalten und ans Finanzamt abführen. 30 Tage vor Ablauf erscheint eine Warnung in der Übersicht.</p></section>
|
||||
<section class="karte breit projekt-teile"><div class="teile-kopf"><nav class="teile">${([["einsaetze", "Einsätze und Kosten"], ["rechnungen", "Rechnungen"], ["dokumente", "Dokumente"], ["ausschreibungen", "Ausschreibungen"]] as const)
|
||||
.map(([t, titel]) => `<button data-teil="${t}" class="${t === subTeil ? "aktiv" : ""}">${titel}${t === "rechnungen" && eigeneKosten.length ? ` <small>${eigeneKosten.length}</small>` : ""}</button>`).join("")}</nav></div><div id="sub-teil"></div></section>`;
|
||||
inhalt.appendChild(raster);
|
||||
const ziel0 = raster.querySelector<HTMLElement>("#sub-teil")!;
|
||||
|
||||
const zeigeTeil = () => {
|
||||
ziel0.innerHTML = "";
|
||||
raster.querySelectorAll<HTMLElement>("[data-teil]").forEach((b) => b.classList.toggle("aktiv", b.dataset.teil === subTeil));
|
||||
if (subTeil === "einsaetze") {
|
||||
if (!einsaetze.length) { ziel0.innerHTML = '<p class="hinweis">Noch nicht eingeplant. Im Terminplan beim Vorgang unter „+ Personal“ wählen oder in eine Kolonne aufnehmen.</p>'; return; }
|
||||
ziel0.appendChild(tabelle({
|
||||
schluessel: "sub-einsaetze", klein: true, einheit: ["Einsatz", "Einsätze"],
|
||||
zeilen: einsaetze.map((b: Zeile) => {
|
||||
const p = projektVon(b.v);
|
||||
const personen = b.kolonne_id ? Number(s?.kolonnengroesse ?? 1) : Number(b.personen);
|
||||
const leistung = eigeneKosten.filter((x) => x.besetzung_id === b.id && x.besetzung_teil === "leistung");
|
||||
return { ...b, projekt: p ? `${p.nummer} ${p.bezeichnung}` : "", personen, stunden: Number(b.v.dauer) * e.stundenProTag * personen,
|
||||
kosten: leistung.reduce((n, x) => n + Number(x.netto), 0), mitKosten: leistung.length > 0 };
|
||||
}),
|
||||
spalten: [
|
||||
{ id: "projekt", titel: "Projekt", wert: (z) => esc(z.projekt) },
|
||||
{ id: "vorgang", titel: "Vorgang", wert: (z) => `${esc(z.v.name)}${z.kolonne_id ? ` <small class="hinweis">über ${esc(z.anzeige)}</small>` : ""}` },
|
||||
{ id: "zeitraum", titel: "Zeitraum", art: "datum", sortWert: (z) => z.v.anfang, wert: (z) => `${dat(z.v.anfang)} – ${dat(z.v.ende)}` },
|
||||
{ id: "personen", titel: "Personen", art: "zahl", sortWert: (z) => z.personen, wert: (z) => zahl(z.personen), klasse: "zahl" },
|
||||
{ id: "stunden", titel: "Stunden", art: "zahl", sortWert: (z) => z.stunden, wert: (z) => zahl(z.stunden), klasse: "zahl" },
|
||||
{ id: "kosten", titel: "Kosten", art: "zahl", sortWert: (z) => z.kosten, wert: (z) => (z.mitKosten ? formatEuro(z.kosten) : z.freigegeben ? '<span class="hinweis">ohne Satz</span>' : '<span class="hinweis">nach Freigabe</span>'), klasse: "zahl" },
|
||||
{ id: "status", titel: "Status", text: (z) => (z.freigegeben ? "freigegeben" : "vorgemerkt"), wert: (z) => `<span class="marke ${z.freigegeben ? "gut" : "offen"}">${z.freigegeben ? "freigegeben" : "vorgemerkt"}</span>` },
|
||||
],
|
||||
klick: () => { location.hash = "terminplan"; },
|
||||
}));
|
||||
}
|
||||
if (subTeil === "rechnungen") {
|
||||
if (!eigeneKosten.length) { ziel0.innerHTML = '<p class="hinweis">Noch keine Kosten. Sie entstehen aus freigegebenen Einsätzen mit Stundensatz oder auf der Projektseite unter Kosten.</p>'; return; }
|
||||
const STATUS_TEXT: Record<string, string> = { geplant: "geplant", bestellt: "Rechnung da", bezahlt: "bezahlt" };
|
||||
ziel0.appendChild(tabelle({
|
||||
schluessel: "sub-rechnungen", klein: true, einheit: ["Posten", "Posten"],
|
||||
zeilen: eigeneKosten.map((x) => ({ ...x, projekt: projekt(x.projekt_id), faellig: faellig(x) })),
|
||||
spalten: [
|
||||
{ id: "bezeichnung", titel: "Bezeichnung", wert: (z) => `${esc(z.bezeichnung)}${z.automatisch ? ' <small class="hinweis">aus dem Einsatz</small>' : ""}` },
|
||||
{ id: "projekt", titel: "Projekt", text: (z) => z.projekt?.nummer ?? "", wert: (z) => esc(z.projekt ? `${z.projekt.nummer} ${z.projekt.bezeichnung}` : "") },
|
||||
{ id: "termin", titel: "Leistung bis", art: "datum", sortWert: (z) => z.termin, wert: (z) => dat(z.termin) },
|
||||
{ id: "faellig", titel: "Fällig", art: "datum", sortWert: (z) => z.faellig, wert: (z) => dat(z.faellig) },
|
||||
{ id: "netto", titel: "Betrag netto", art: "zahl", sortWert: (z) => Number(z.netto), wert: (z) => formatEuro(Number(z.netto)), klasse: "zahl" },
|
||||
{ id: "status", titel: "Status", text: (z) => STATUS_TEXT[z.status] ?? z.status, wert: (z) => `<span class="marke ${z.status === "bezahlt" ? "gut" : z.status === "bestellt" ? "offen" : "grau"}">${esc(STATUS_TEXT[z.status] ?? z.status)}</span>` },
|
||||
],
|
||||
klick: (z) => void (async () => {
|
||||
const r = await dialog(z.bezeichnung, [
|
||||
{ name: "netto", titel: "Betrag netto (€)", art: "euro", pflicht: true, hilfe: z.automatisch ? "Wer den Betrag ändert, hält ihn fest; er rechnet sich dann nicht mehr aus dem Einsatz." : undefined },
|
||||
{ name: "termin", titel: "Leistung bis / Rechnungsdatum", art: "datum", pflicht: true },
|
||||
{ name: "status", titel: "Status", art: "auswahl", optionen: Object.entries(STATUS_TEXT) as [string, string][] },
|
||||
], z, false);
|
||||
if (r?.aktion !== "speichern") return;
|
||||
const daten: Zeile = { termin: r.daten.termin, status: r.daten.status };
|
||||
if (r.daten.netto !== Number(z.netto)) daten.netto = r.daten.netto;
|
||||
await api(`kosten/${z.id}`, "PATCH", daten);
|
||||
void neuLaden();
|
||||
})(),
|
||||
fuss: (l) => `<p>Offen: <strong>${formatEuro(l.filter((x) => x.status !== "bezahlt").reduce((n, x) => n + Number(x.netto), 0))}</strong> · bezahlt: ${formatEuro(l.filter((x) => x.status === "bezahlt").reduce((n, x) => n + Number(x.netto), 0))}</p>`,
|
||||
}));
|
||||
}
|
||||
if (subTeil === "dokumente") {
|
||||
ziel0.innerHTML = `<table class="einfach"><tbody><tr><td>Freistellungsbescheinigung § 48b</td><td>${s?.freistellung_nr ? `Nr. ${esc(s.freistellung_nr)}` : "–"}</td><td><span class="marke ${frei[1]}">${esc(frei[0])}</span></td></tr></tbody></table>
|
||||
<p class="hinweis">Verträge, Nachweise und die Bescheinigung selbst legst du vorerst in der Nextcloud ab. Eine Ablage hier kommt mit der Baustelle am Handy (Stufe 4).</p>`;
|
||||
}
|
||||
if (subTeil === "ausschreibungen") {
|
||||
ziel0.innerHTML = '<p class="hinweis">Ausschreibungen an Subunternehmer entstehen mit dem Angebotsmodul (Stufe 5): Positionen aus deinem Angebot an mehrere Subunternehmer schicken, Preise vergleichen und den günstigsten übernehmen. Sie erscheinen dann hier.</p>';
|
||||
}
|
||||
};
|
||||
zeigeTeil();
|
||||
|
||||
raster.addEventListener("click", async (ev) => {
|
||||
const t = ev.target as HTMLElement;
|
||||
const teil = t.closest<HTMLElement>("[data-teil]")?.dataset.teil;
|
||||
if (teil) { subTeil = teil; zeigeTeil(); return; }
|
||||
if (t.dataset.a === "bearbeiten") {
|
||||
const werte = { ...k, ...(s ?? { abrechnung: "stunden" }), id: undefined };
|
||||
const r = await dialog(subName(k), SUB_FELDER(), werte, false);
|
||||
if (r?.aktion !== "speichern") return;
|
||||
await subSpeichern(r.daten, kontaktId, s);
|
||||
void neuLaden();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
// ---------- Urlaub und Zeiten aller ----------
|
||||
|
||||
async function urlaubTeil(): Promise<void> {
|
||||
const jahr = Number(heute().slice(0, 4));
|
||||
const [abw, liste] = await Promise.all([api<Zeile[]>("abwesenheiten"), api<Zeile[]>(`personal?heute=${heute()}`)]);
|
||||
seite("Personal");
|
||||
teileLeiste("urlaub");
|
||||
const name = (id: string) => liste.find((p) => p.id === id)?.name ?? "";
|
||||
const zeilen: Zeile[] = abw.filter((a) => a.bis >= `${jahr}-01-01` && liste.some((p) => p.id === a.kontakt_id)).map((a) => ({ ...a, name: name(a.kontakt_id) }));
|
||||
const antraege = zeilen.filter((a) => a.status === "beantragt").length;
|
||||
inhalt.insertAdjacentHTML("beforeend", `<div class="summen">${liste.map((p) => `<div><small>${esc(p.name)}</small><b>${tageText(p.urlaub.rest)}</b><small>Rest von ${zahl(p.urlaub.anspruch + p.urlaub.uebertrag)}</small></div>`).join("")}</div>
|
||||
${antraege ? `<p class="warnung">${antraege} ${antraege === 1 ? "Urlaubsantrag wartet" : "Urlaubsanträge warten"} auf deine Antwort.</p>` : ""}`);
|
||||
if (!zeilen.length) { inhalt.insertAdjacentHTML("beforeend", `<p class="hinweis leer">Keine Abwesenheiten in ${jahr}. Eintragen auf der Seite des Mitarbeiters.</p>`); return; }
|
||||
inhalt.appendChild(tabelle({
|
||||
schluessel: "urlaub-alle", einheit: ["Abwesenheit", "Abwesenheiten"],
|
||||
vorgabe: { sort: [["zeitraum", "auf"]] },
|
||||
spalten: [
|
||||
{ id: "name", titel: "Person", wert: (a) => esc(a.name) },
|
||||
{ id: "art", titel: "Art", text: (a) => ABWESENHEIT_TEXT[a.art as AbwesenheitArt], 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"), klasse: "optional" },
|
||||
{ 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, klick: (a) => void (a.status === "beantragt" && a.art === "urlaub" ? entscheiden(a.id).then((ja) => { if (ja) void urlaubTeil(); }) : (location.hash = `mitarbeiter-${a.kontakt_id}`)),
|
||||
}));
|
||||
}
|
||||
|
||||
async function zeitenTeil(): Promise<void> {
|
||||
const monat = heute().slice(0, 7);
|
||||
const von = `${monat}-01`;
|
||||
const [d, verf, liste] = await Promise.all([api<Zeile>(`zeiten?von=${von}&bis=${heute()}`), api<Zeile[]>(`verfuegbarkeit?von=${von}&bis=${heute()}`), api<Zeile[]>(`personal?heute=${heute()}`)]);
|
||||
seite("Personal");
|
||||
teileLeiste("zeiten");
|
||||
const ist = new Map<string, number>();
|
||||
for (const t of d.tage) ist.set(t.kontakt_id, (ist.get(t.kontakt_id) ?? 0) + t.netto_min / 60);
|
||||
const zeilen = liste.map((p) => {
|
||||
const soll = p.stammdaten && !p.stammdaten.angestellt ? 0 : (verf.find((v) => v.kontakt_id === p.id)?.tage ?? []).reduce((s: number, t: Zeile) => s + t.frei, 0);
|
||||
const i = ist.get(p.id) ?? 0;
|
||||
return { ...p, ist: i, soll, diff: soll ? i - soll : null, tage: d.tage.filter((t: Zeile) => t.kontakt_id === p.id).length };
|
||||
});
|
||||
inhalt.insertAdjacentHTML("beforeend", `<p class="hinweis">Gebuchte Stunden vom 1. bis heute gegen das Soll aus dem Arbeitszeitmodell (ohne Urlaub, Krankheit, Feiertage). Einzelne Tage, Nachtragen und die Stundenliste fürs Steuerbüro stehen unter <a href="#stunden">Stunden</a>.</p>`);
|
||||
inhalt.appendChild(tabelle({
|
||||
schluessel: "zeiten-alle", einheit: ["Person", "Personen"],
|
||||
spalten: [
|
||||
{ id: "name", titel: "Person", wert: (z) => esc(z.name) },
|
||||
{ id: "tage", titel: "Tage gebucht", art: "zahl", sortWert: (z) => z.tage, wert: (z) => String(z.tage), klasse: "zahl" },
|
||||
{ id: "ist", titel: "Ist", art: "zahl", sortWert: (z) => z.ist, wert: (z) => `${zahl(z.ist)} Std.`, klasse: "zahl" },
|
||||
{ id: "soll", titel: "Soll bis heute", art: "zahl", sortWert: (z) => z.soll, wert: (z) => (z.soll ? `${zahl(z.soll)} Std.` : "–"), klasse: "zahl" },
|
||||
{ id: "diff", titel: "Differenz", art: "zahl", sortWert: (z) => z.diff ?? 0, wert: (z) => (z.diff == null ? "–" : `<span class="${z.diff < 0 ? "fehler" : ""}">${z.diff >= 0 ? "+" : ""}${zahl(z.diff)} Std.</span>`), klasse: "zahl" },
|
||||
],
|
||||
zeilen, klick: () => { location.hash = "stunden"; },
|
||||
}));
|
||||
}
|
||||
|
||||
@@ -55,7 +485,7 @@ async function neuerMitarbeiter(): Promise<void> {
|
||||
export async function mitarbeiterSeite(kontaktId: string, inhaber: boolean): Promise<void> {
|
||||
const jahr = Number(heute().slice(0, 4));
|
||||
const bis = new Date(Date.now() + 27 * 86400000).toISOString().slice(0, 10);
|
||||
const [kontakt, liste, alleStamm, modelle, abw, konten, verf] = await Promise.all([
|
||||
const [kontakt, liste, alleStamm, modelle, abw, konten, verf, kolonnen, mitglieder] = await Promise.all([
|
||||
api<Zeile>(`kontakte/${kontaktId}`),
|
||||
api<Zeile[]>(`personal?heute=${heute()}`),
|
||||
api<Zeile[]>("mitarbeiter"),
|
||||
@@ -63,7 +493,9 @@ export async function mitarbeiterSeite(kontaktId: string, inhaber: boolean): Pro
|
||||
api<Zeile[]>("abwesenheiten"),
|
||||
api<Zeile[]>("urlaubskonten"),
|
||||
api<Zeile[]>(`verfuegbarkeit?von=${heute()}&bis=${bis}&kontakt_id=${kontaktId}`),
|
||||
api<Zeile[]>("kolonnen"), api<Zeile[]>("kolonnen-mitglieder"),
|
||||
]);
|
||||
const kolonnenNamen = mitglieder.filter((m) => m.kontakt_id === kontaktId).map((m) => kolonnen.find((o) => o.id === m.kolonne_id)?.name).filter(Boolean) as string[];
|
||||
const ich = liste.find((x) => x.id === kontaktId);
|
||||
const stamm = alleStamm.find((m) => m.kontakt_id === kontaktId) ?? null;
|
||||
const eigeneModelle = modelle.filter((m) => m.kontakt_id === kontaktId).sort((a, b) => (a.gueltig_ab < b.gueltig_ab ? 1 : -1));
|
||||
@@ -81,6 +513,8 @@ export async function mitarbeiterSeite(kontaktId: string, inhaber: boolean): Pro
|
||||
<dl class="werte">
|
||||
<dt>Personalnummer</dt><dd>${esc(stamm?.personalnummer ?? "–")}</dd>
|
||||
<dt>Eintritt</dt><dd>${stamm?.eintritt ? dat(stamm.eintritt) : "–"}${stamm?.austritt ? ` bis ${dat(stamm.austritt)}` : ""}</dd>
|
||||
<dt>Rolle</dt><dd>${esc(FUNKTION[stamm?.funktion] ?? "–")}</dd>
|
||||
<dt>Kolonnen</dt><dd>${esc(kolonnenNamen.join(", ") || "–")}</dd>
|
||||
<dt>Art</dt><dd>${stamm && !stamm.angestellt ? "Inhaber (keine Pausenregel, keine Lohnübergabe)" : "angestellt"}</dd>
|
||||
${inhaber ? `<dt>Lohnkosten je Stunde</dt><dd>${stamm?.lohn_cent != null ? formatEuro(stamm.lohn_cent) : "–"}</dd>` : ""}
|
||||
<dt>Zugang</dt><dd>${ich?.anmeldename ? esc(ich.anmeldename) : inhaber ? '<a href="#benutzer">anlegen unter Benutzer</a>' : "keiner"}</dd>
|
||||
@@ -140,6 +574,7 @@ export async function mitarbeiterSeite(kontaktId: string, inhaber: boolean): Pro
|
||||
// ---------- Dialoge ----------
|
||||
async function stammDialog(): Promise<void> {
|
||||
const felder: Feld[] = [
|
||||
{ name: "funktion", titel: "Rolle", art: "auswahl", optionen: [["", "– offen –"], ...FUNKTIONEN], hilfe: "Wie die Lohnarten der Kalkulation" },
|
||||
{ name: "personalnummer", titel: "Personalnummer (für das Steuerbüro)" },
|
||||
{ name: "eintritt", titel: "Eintritt", art: "datum" },
|
||||
{ name: "austritt", titel: "Austritt", art: "datum" },
|
||||
@@ -151,7 +586,7 @@ export async function mitarbeiterSeite(kontaktId: string, inhaber: boolean): Pro
|
||||
const r = await dialog("Stammdaten", felder, werte, false);
|
||||
if (r?.aktion !== "speichern") return;
|
||||
const d = r.daten;
|
||||
const daten: Zeile = { personalnummer: d.personalnummer, eintritt: d.eintritt, austritt: d.austritt, angestellt: d.angestellt !== "nein", urlaubstage: d.urlaubstage ?? 30 };
|
||||
const daten: Zeile = { funktion: d.funktion, personalnummer: d.personalnummer, eintritt: d.eintritt, austritt: d.austritt, angestellt: d.angestellt !== "nein", urlaubstage: d.urlaubstage ?? 30 };
|
||||
if (inhaber) daten.lohn_cent = d.lohn;
|
||||
if (stamm) await api(`mitarbeiter/${stamm.id}`, "PATCH", daten);
|
||||
else await api("mitarbeiter", "POST", { ...daten, kontakt_id: kontaktId });
|
||||
|
||||
@@ -117,7 +117,7 @@ button.neben.an { background: var(--akzent-hell); border-color: var(--akzent); c
|
||||
.gantt { overflow: auto; max-height: calc(100vh - 150px); background: var(--fl); border: 1px solid var(--linie); border-radius: 10px; position: relative; }
|
||||
.g-inhalt { position: relative; }
|
||||
.g-kopf { position: sticky; top: 0; z-index: 4; display: flex; background: var(--fl); border-bottom: 1px solid var(--linie); }
|
||||
.g-links { position: sticky; left: 0; z-index: 2; width: var(--links); flex: none; display: grid; grid-template-columns: var(--sp-nr) minmax(var(--sp-name), 1fr) var(--sp-dauer) var(--sp-vg) var(--sp-anfang) var(--sp-ende) var(--sp-res); align-items: stretch; height: 42px; background: var(--fl); font-size: 13px; overflow: hidden; }
|
||||
.g-links { position: sticky; left: 0; z-index: 2; width: var(--links); flex: none; display: grid; grid-template-columns: var(--sp-nr) minmax(var(--sp-name), 1fr) var(--sp-dauer) var(--sp-vg) var(--sp-anfang) var(--sp-ende) var(--sp-erl) var(--sp-res); align-items: stretch; height: 42px; background: var(--fl); font-size: 13px; overflow: hidden; }
|
||||
.g-links > * { display: flex; align-items: center; min-width: 0; padding: 0 6px; border-right: 1px solid var(--linie); border-bottom: 1px solid var(--linie); white-space: nowrap; overflow: hidden; }
|
||||
.g-links .zahl { display: block; line-height: 41px; text-align: right; text-overflow: ellipsis; font-variant-numeric: tabular-nums; }
|
||||
.g-links.kopf .zahl { line-height: normal; display: flex; justify-content: flex-end; }
|
||||
@@ -671,3 +671,32 @@ td .unter.nur-schmal, .liste-leiste .nur-schmal { display: none; }
|
||||
.vorlage-tabelle input, .vorlage-tabelle select { padding: 6px 8px; }
|
||||
.vorlage-tabelle input.zahl { width: 70px; text-align: right; }
|
||||
.vorlage-tabelle td:first-child { min-width: 200px; }
|
||||
|
||||
/* 0.15: Abarbeitungsgrad im Terminplan */
|
||||
.g-links .erl { cursor: pointer; }
|
||||
.g-links .erl:hover { background: var(--akzent-hell); }
|
||||
.g-links .erl.fertig { color: var(--gut-text); font-weight: 600; }
|
||||
.g-links .erl.verzug { color: var(--warn); font-weight: 600; }
|
||||
.g-links .erl.summe { font-weight: 600; }
|
||||
.balken .erledigt { position: absolute; left: 0; top: 0; bottom: 0; background: var(--g-vorgang-rand); pointer-events: none; }
|
||||
.balken.vorgang.fertig { background: var(--gut-text); border-color: var(--gut-text); }
|
||||
.balken.vorgang.verzug { border-color: var(--warn); box-shadow: 0 0 0 1px var(--warn); }
|
||||
.balken.meilenstein.fertig { background: var(--gut-text); }
|
||||
.balken.meilenstein.verzug { background: var(--warn); }
|
||||
.b-verzug { color: var(--warn); font-weight: 600; margin-left: 4px; }
|
||||
.erl-menue { position: fixed; z-index: 50; background: var(--fl); border: 1px solid var(--linie); border-radius: 8px; box-shadow: 0 8px 24px rgb(0 0 0 / 0.18); padding: 10px 12px; display: grid; gap: 8px; max-width: min(360px, calc(100vw - 16px)); font-size: 13px; }
|
||||
.erl-menue > div { display: flex; gap: 6px; flex-wrap: wrap; }
|
||||
.erl-menue .neben.an { border-color: var(--akzent); color: var(--akzent); font-weight: 600; }
|
||||
.erl-menue input { width: 56px; margin-left: 6px; }
|
||||
/* 0.15: Personal mit Reitern, Kolonnen, Subunternehmer */
|
||||
.personal-teile { padding: 0; margin-bottom: 14px; }
|
||||
.last-anteil { display: inline-block; width: 52px; height: 8px; border-radius: 4px; background: var(--linie); vertical-align: middle; overflow: hidden; margin-right: 4px; }
|
||||
.last-anteil i { display: block; height: 100%; background: var(--akzent); }
|
||||
.last-anteil.ueber i { background: var(--warn); }
|
||||
.last-anteil.leer i { background: var(--leise); }
|
||||
table.einfach { width: 100%; border-collapse: collapse; font-size: 14px; }
|
||||
table.einfach td { padding: 7px 6px; border-bottom: 1px solid var(--linie); vertical-align: middle; }
|
||||
table.einfach td:last-child { text-align: right; white-space: nowrap; }
|
||||
.zeile-dazu { display: flex; gap: 8px; margin-top: 10px; flex-wrap: wrap; }
|
||||
.zeile-dazu select { flex: 1; min-width: 0; }
|
||||
.personal-raster #sub-teil { padding: 12px 16px 16px; }
|
||||
|
||||
101
test/api.test.ts
101
test/api.test.ts
@@ -888,3 +888,104 @@ describe.skipIf(!url)("Zahlungen, Kosten und Aufgaben im Terminplan", () => {
|
||||
expect((await hole(`zahlungen/${s.id}`)).netto).toBe(1_200_000);
|
||||
});
|
||||
});
|
||||
|
||||
describe.skipIf(!url)("Kolonnen und Subunternehmer (0.15)", () => {
|
||||
let pool: Pool;
|
||||
let app: FastifyInstance;
|
||||
|
||||
beforeAll(async () => {
|
||||
pool = erstellePool(url!);
|
||||
await pool.query("drop schema public cascade; create schema public;");
|
||||
await migriere(pool);
|
||||
app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", anmeldung: "testversion" });
|
||||
});
|
||||
afterAll(async () => {
|
||||
await app?.close();
|
||||
await pool?.end();
|
||||
});
|
||||
|
||||
const neu = async (pfad: string, body: object) => {
|
||||
const r = await app.inject({ method: "POST", url: `/api/${pfad}`, payload: body });
|
||||
expect(r.statusCode, r.body).toBe(201);
|
||||
return r.json();
|
||||
};
|
||||
const aendern = async (pfad: string, body: object) => {
|
||||
const r = await app.inject({ method: "PATCH", url: `/api/${pfad}`, payload: body });
|
||||
expect(r.statusCode, r.body).toBe(200);
|
||||
return r.json();
|
||||
};
|
||||
const hole = async (pfad: string) => (await app.inject(`/api/${pfad}`)).json();
|
||||
type K = { kontakt_id: string; besetzung_teil: string; netto: number; termin: string; zahlungsziel_tage: number | null; automatisch: boolean; id: string; bezeichnung: string };
|
||||
const subKosten = async (id: string) => ((await hole("kosten")) as K[]).filter((k) => k.kontakt_id === id).sort((a, b) => a.besetzung_teil.localeCompare(b.besetzung_teil));
|
||||
|
||||
it("Kolonne als eine Ressource: zählt mit allen Mitgliedern, mit Subunternehmer erst nach Freigabe", async () => {
|
||||
const anna = await neu("kontakte", { name: "Anna Holz", rolle: "mitarbeiter" });
|
||||
const ben = await neu("kontakte", { name: "Ben Balken", rolle: "mitarbeiter" });
|
||||
const sub = await neu("kontakte", { name: "Jan Meier", firma: "Meier Dach GmbH", rolle: "subunternehmer" });
|
||||
await neu("subunternehmer", { kontakt_id: sub.id, stundensatz: 5000, kolonnengroesse: 2 });
|
||||
const k1 = await neu("kolonnen", { name: "Kolonne 1", leitung_kontakt_id: anna.id });
|
||||
for (const m of [anna, ben]) await neu("kolonnen-mitglieder", { kolonne_id: k1.id, kontakt_id: m.id });
|
||||
const p = await neu("projekte", { nummer: "P-26-300", bezeichnung: "Halle Nord", status: "auftrag" });
|
||||
const a = await neu("abschnitte", { projekt_id: p.id, name: "Bauablauf" });
|
||||
// 64 Stunden mit zwei Leuten à 8 Std. = 4 Arbeitstage
|
||||
const v = await neu("vorgaenge", { abschnitt_id: a.id, name: "Abbund", start: "2027-03-08", dauer: 1, stunden: 64, dauer_fest: false });
|
||||
const b = await neu("besetzungen", { vorgang_id: v.id, kolonne_id: k1.id });
|
||||
expect(b.freigegeben).toBe(true);
|
||||
expect((await hole(`vorgaenge/${v.id}`)).dauer).toBe(4);
|
||||
// ein Mitarbeiter der Kolonne zugleich direkt auf einem anderen Vorgang: Überschneidung
|
||||
const v2 = await neu("vorgaenge", { abschnitt_id: a.id, name: "Dach", start: "2027-03-09", dauer: 1 });
|
||||
await neu("besetzungen", { vorgang_id: v2.id, kontakt_id: ben.id });
|
||||
const tp = await hole("terminplan");
|
||||
expect(tp.ueberschneidungen.some((u: { wer: string }) => u.wer === ben.id)).toBe(true);
|
||||
expect(tp.besetzungen.find((x: { id: string }) => x.id === b.id)).toMatchObject({ anzeige: "Kolonne 1", mitglieder: [anna.id, ben.id] });
|
||||
// Kolonne mit Subunternehmer: nur vorgemerkt
|
||||
const k2 = await neu("kolonnen", { name: "Dachkolonne" });
|
||||
await neu("kolonnen-mitglieder", { kolonne_id: k2.id, kontakt_id: sub.id });
|
||||
const b2 = await neu("besetzungen", { vorgang_id: v2.id, kolonne_id: k2.id });
|
||||
expect(b2.freigegeben).toBe(false);
|
||||
// Person, Platzhalter oder Kolonne, nie zwei davon
|
||||
const r = await app.inject({ method: "POST", url: "/api/besetzungen", payload: { vorgang_id: v.id, kolonne_id: k1.id, kontakt_id: anna.id } });
|
||||
expect(r.statusCode).toBeGreaterThanOrEqual(400);
|
||||
});
|
||||
|
||||
it("Einsatz eines Subunternehmers wird zur Ausgabe mit Skonto, Einbehalt und Zahlungsziel", async () => {
|
||||
const sub = await neu("kontakte", { name: "Kai Kran", firma: "Kran Kai", rolle: "subunternehmer" });
|
||||
await neu("subunternehmer", { kontakt_id: sub.id, stundensatz: 6000, helfersatz: 4000, zahlungsziel_tage: 14, skonto_prozent: 2, skonto_tage: 7, einbehalt_prozent: 5 });
|
||||
const p = await neu("projekte", { nummer: "P-26-301", bezeichnung: "Carport", status: "auftrag" });
|
||||
const a = await neu("abschnitte", { projekt_id: p.id, name: "Bauablauf" });
|
||||
const v = await neu("vorgaenge", { abschnitt_id: a.id, name: "Richten", start: "2027-03-08", dauer: 2 });
|
||||
const b = await neu("besetzungen", { vorgang_id: v.id, kontakt_id: sub.id, personen: 2 });
|
||||
// vorgemerkt: noch keine Kosten
|
||||
expect(await subKosten(sub.id)).toHaveLength(0);
|
||||
await aendern(`besetzungen/${b.id}`, { freigegeben: true });
|
||||
// 2 Tage × 8 Std. × (60 € + 40 €) = 1.600 €; 2 % Skonto = 1.568 €; davon 5 % Einbehalt = 78,40 €
|
||||
let [einbehalt, leistung] = await subKosten(sub.id);
|
||||
expect(leistung).toMatchObject({ netto: 148960, termin: "2027-03-09", zahlungsziel_tage: 7, automatisch: true });
|
||||
expect(einbehalt).toMatchObject({ netto: 7840, termin: "2032-03-09" });
|
||||
// Vorgang länger: Kosten und Termin gehen mit
|
||||
await aendern(`vorgaenge/${v.id}`, { dauer: 3 });
|
||||
[einbehalt, leistung] = await subKosten(sub.id);
|
||||
expect(leistung).toMatchObject({ netto: 223440, termin: "2027-03-10" });
|
||||
// Betrag von Hand: bleibt fest
|
||||
await aendern(`kosten/${leistung.id}`, { netto: 200000 });
|
||||
await aendern(`vorgaenge/${v.id}`, { dauer: 4 });
|
||||
[einbehalt, leistung] = await subKosten(sub.id);
|
||||
expect(leistung).toMatchObject({ netto: 200000, automatisch: false });
|
||||
expect(einbehalt.netto).toBe(15680);
|
||||
// Einsatz entfernt: geplante automatische Kosten verschwinden, die von Hand geänderte bleibt
|
||||
await app.inject({ method: "DELETE", url: `/api/besetzungen/${b.id}` });
|
||||
const rest = await subKosten(sub.id);
|
||||
expect(rest.map((k) => k.netto)).toEqual([200000]);
|
||||
// Einbehalt steht nicht im Terminplan
|
||||
expect((await hole("terminplan")).kosten.some((k: { bezeichnung: string }) => k.bezeichnung.includes("Sicherheitseinbehalt"))).toBe(false);
|
||||
});
|
||||
|
||||
it("Übersicht warnt vor fehlender oder ablaufender Freistellungsbescheinigung", async () => {
|
||||
const sub = await neu("kontakte", { name: "Olaf Ohne", rolle: "subunternehmer" });
|
||||
await neu("subunternehmer", { kontakt_id: sub.id, freistellung_bis: "2027-03-20" });
|
||||
const u = await hole("uebersicht?heute=2027-03-01");
|
||||
expect(u.warnungen).toContainEqual(expect.objectContaining({ art: "freistellung", ziel: `subunternehmer-${sub.id}`, text: expect.stringContaining("läuft am 20.03.2027 ab") }));
|
||||
const u2 = await hole("uebersicht?heute=2027-03-21");
|
||||
expect(u2.warnungen).toContainEqual(expect.objectContaining({ text: expect.stringContaining("Olaf Ohne ist seit 20.03.2027 abgelaufen") }));
|
||||
});
|
||||
});
|
||||
|
||||
26
test/fortschritt.test.ts
Normal file
26
test/fortschritt.test.ts
Normal file
@@ -0,0 +1,26 @@
|
||||
import { describe, it, expect } from "vitest";
|
||||
import { gesamtFortschritt, imVerzug, sollFortschritt } from "../src/domain/fortschritt.js";
|
||||
|
||||
const woche = { tage: [1, 2, 3, 4] };
|
||||
// Mo 8.3. bis Do 11.3.2027: vier Arbeitstage
|
||||
const v = { anfang: "2027-03-08", ende: "2027-03-11", dauer: 4 };
|
||||
|
||||
describe("Abarbeitungsgrad", () => {
|
||||
it("Soll wächst mit den vergangenen Arbeitstagen", () => {
|
||||
expect(sollFortschritt(v, "2027-03-08", woche)).toBe(0);
|
||||
expect(sollFortschritt(v, "2027-03-10", woche)).toBe(50);
|
||||
expect(sollFortschritt(v, "2027-03-12", woche)).toBe(100);
|
||||
});
|
||||
it("im Verzug ab 10 Punkten Rückstand oder nach dem Ende", () => {
|
||||
expect(imVerzug({ ...v, fortschritt: 45 }, "2027-03-10", woche)).toBe(false);
|
||||
expect(imVerzug({ ...v, fortschritt: 25 }, "2027-03-10", woche)).toBe(true);
|
||||
expect(imVerzug({ ...v, fortschritt: 95 }, "2027-03-15", woche)).toBe(true);
|
||||
expect(imVerzug({ ...v, fortschritt: 100 }, "2027-03-15", woche)).toBe(false);
|
||||
});
|
||||
it("Stand mehrerer Vorgänge nach Stunden gewichtet", () => {
|
||||
expect(gesamtFortschritt([{ ...v, stunden: 30, fortschritt: 100 }, { ...v, stunden: 10, fortschritt: 0 }])).toBe(75);
|
||||
// ohne Stunden nach Dauer
|
||||
expect(gesamtFortschritt([{ ...v, dauer: 3, fortschritt: 100 }, { ...v, dauer: 1, fortschritt: 0 }])).toBe(75);
|
||||
expect(gesamtFortschritt([])).toBeNull();
|
||||
});
|
||||
});
|
||||
Reference in New Issue
Block a user