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:
@@ -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)
|
||||
|
||||
Reference in New Issue
Block a user