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