Stundensätze im Personalmodul, Übergabe ans Angebot (0.26.0)
Rechentabellen je Lohnart wie Hennings Excel (Zeit, Kosten, Vollkostensatz), Mittellohn mit Schaltern, Versionen mit gilt ab. Excel-Fassung centgenau (80,38 / 107,81 EUR), Fassung nach S2 mit Akquise/Verwaltung als Kosten. Angebote schreiben die geltenden Sätze fest, Lohnzuschlag 0 %, Nachfrage bei neuer Version. 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,9 +13,25 @@ export type Kostenart = (typeof KOSTENARTEN)[number];
|
||||
export const KOSTENART_NAME: Record<Kostenart | "ohne", string> = {
|
||||
lohn: "Lohn", material: "Material", geraet: "Gerät", fahrt: "Fahrt", subunternehmer: "Subunternehmer", sonstiges: "Sonstiges", ohne: "ohne Kalkulation",
|
||||
};
|
||||
// Lohnarten ohne Stundensatz-Tabellen; mit Tabellen (M17) sind es deren Schlüssel und der Mittellohn
|
||||
export const LOHNARTEN = ["planer", "geselle", "helfer"] as const;
|
||||
export type Lohnart = (typeof LOHNARTEN)[number];
|
||||
export const LOHNART_NAME: Record<Lohnart, string> = { planer: "Planer", geselle: "Geselle", helfer: "Helfer" };
|
||||
export type Lohnart = string;
|
||||
export const LOHNART_NAME: Record<string, string> = { planer: "Planer", geselle: "Geselle", helfer: "Helfer", chef: "Chef", mittellohn: "Mittellohn" };
|
||||
/** Lohnarten, die ein Angebot kennt: aus den festgeschriebenen Stundensatz-Tabellen oder die drei festen */
|
||||
export function lohnartenVon(s: Pick<Saetze, "lohnarten" | "stundensaetze">): { id: string; name: string }[] {
|
||||
if (s.lohnarten?.length) return s.lohnarten;
|
||||
return Object.keys(s.stundensaetze).map((id) => ({ id, name: LOHNART_NAME[id] ?? id }));
|
||||
}
|
||||
/** Auswahl für eine Lohnzeile; eine Lohnart, die das Angebot nicht kennt, bleibt sichtbar */
|
||||
export function lohnartOptionen(liste: { id: string; name: string }[], aktuell: string | null | undefined): [string, string][] {
|
||||
const o = liste.map((x): [string, string] => [x.id, x.name]);
|
||||
if (aktuell && !o.some(([id]) => id === aktuell)) o.push([aktuell, LOHNART_NAME[aktuell] ?? aktuell]);
|
||||
return o;
|
||||
}
|
||||
/** Lohnarten für Vorlagen ohne Angebot: Mittellohn und die üblichen Tabellen */
|
||||
export const VORLAGE_LOHNARTEN = ["mittellohn", "chef", "planer", "geselle", "helfer"].map((id) => ({ id, name: LOHNART_NAME[id]! }));
|
||||
/** Lohnart neuer Lohnzeilen: Mittellohn, wenn das Angebot einen hat, sonst Geselle */
|
||||
export const standardLohnart = (s: Pick<Saetze, "stundensaetze">) => (s.stundensaetze.mittellohn != null ? "mittellohn" : "geselle");
|
||||
|
||||
// A28: Alternativ- und Eventualpositionen stehen mit Preis da, zählen aber nicht; „eventual_summe“ ist einkalkuliert
|
||||
export const POSITIONSARTEN = ["normal", "alternativ", "eventual", "eventual_summe"] as const;
|
||||
@@ -40,7 +56,11 @@ export function einheitRichtig(e: string): string | undefined {
|
||||
|
||||
export interface Saetze {
|
||||
/** EK-Stundensätze in Cent je Lohnart, beim Anlegen des Angebots festgeschrieben (A36) */
|
||||
stundensaetze: Record<Lohnart, Cent>;
|
||||
stundensaetze: Record<string, Cent>;
|
||||
/** Lohnarten mit Namen aus den Stundensatz-Tabellen (M17), Mittellohn zuerst */
|
||||
lohnarten?: { id: string; name: string }[];
|
||||
/** Version der Stundensätze, aus der die Sätze stammen */
|
||||
stundensatz_version?: { id: string; name: string; gilt_ab: string } | null;
|
||||
/** Standardzuschläge in % je Kostenart */
|
||||
zuschlaege: Record<Kostenart, number>;
|
||||
wagnis: number;
|
||||
@@ -180,7 +200,7 @@ export function verteile(betrag: Cent, gewichte: number[]): Cent[] {
|
||||
export function ekVon(k: KKosten, s: Saetze): number {
|
||||
if (k.ek !== null && k.ek !== undefined && k.ek !== "") return Number(k.ek);
|
||||
if (k.kostenart === "fahrt") return s.kilometersatz ?? 50;
|
||||
return k.kostenart === "lohn" ? s.stundensaetze[k.lohnart ?? "geselle"] ?? 0 : 0;
|
||||
return k.kostenart === "lohn" ? s.stundensaetze[k.lohnart ?? "geselle"] ?? s.stundensaetze.geselle ?? 0 : 0;
|
||||
}
|
||||
|
||||
export function zuschlagVon(k: KKosten, s: Saetze): number {
|
||||
|
||||
93
src/domain/stundensatz-excel.ts
Normal file
93
src/domain/stundensatz-excel.ts
Normal file
@@ -0,0 +1,93 @@
|
||||
// Erste Fassung der Stundensätze aus Hennings Excel 26-05-26_Pers_Stundenlohn_HS.xlsx (M19): Blätter Personalzeit,
|
||||
// Personalkosten (Chef) und Planerkosten mit denselben Zahlen. Beträge aus „Zim. Grundk.“ (andere Datei) stehen hier
|
||||
// fest auf den Cent gerundet. Abnahme: 80,38 €/Std Chef und 107,81 €/Std Planer.
|
||||
// Die zweite Fassung setzt Hennings Antwort S2 um: Akquise und Verwaltung als Kosten statt als Zeitabzug.
|
||||
import type { Kostenzeile, Rechentabelle, StundensatzDaten, Unproduktiv } from "./stundensatz.js";
|
||||
|
||||
const zeit = (): Rechentabelle["zeit"] => ({
|
||||
stundenTag: 8, tageJahr: 260, feiertage: 10,
|
||||
ausfall: [
|
||||
{ id: "a1", name: "Urlaub", tage: 30 }, { id: "a2", name: "Fort- und Weiterbildung", tage: 3 }, { id: "a3", name: "Krankheit, Kuren, Reha", tage: 8 },
|
||||
{ id: "a4", name: "Sonderurlaub, Sonderbefreiung", tage: 0 }, { id: "a5", name: "Kinderbetreuung", tage: 1 },
|
||||
],
|
||||
unproduktiv: [
|
||||
{ id: "u1", name: "Akquise, Kundenberatung", stunden: 7, je: "monat", als: "zeit" }, { id: "u2", name: "Verwaltung", stunden: 7, je: "monat", als: "zeit" },
|
||||
{ id: "u3", name: "Rüstzeiten", stunden: 1, je: "tag", als: "zeit" }, { id: "u4", name: "Koordinationszeit", stunden: 0.5, je: "tag", als: "zeit" },
|
||||
],
|
||||
});
|
||||
|
||||
const sozial = (): Kostenzeile[] => [
|
||||
{ id: "k3", block: 2, name: "AG-Anteil Krankenversicherung", art: "prozent", prozent: 15 },
|
||||
{ id: "k4", block: 2, name: "AG-Anteil Rentenversicherung", art: "prozent", prozent: 19 },
|
||||
{ id: "k5", block: 2, name: "AG-Anteil Pflegeversicherung", art: "prozent", prozent: 4 },
|
||||
{ id: "k6", block: 2, name: "AG-Anteil Arbeitslosenversicherung", art: "prozent", prozent: 0 },
|
||||
{ id: "k7", block: 2, name: "Berufsgenossenschaft (BG)", art: "jahr", betrag: 0 },
|
||||
{ id: "k8", block: 2, name: "SoKa-Bau", art: "prozent", prozent: 0 },
|
||||
];
|
||||
|
||||
function chef(): Rechentabelle {
|
||||
return {
|
||||
id: "chef", name: "Chef", zeit: zeit(), gewinn: 0, lohnanteil: 55, wagnis: 3,
|
||||
kosten: [
|
||||
{ id: "k1", block: 1, name: "Grundvergütung", art: "netto", betrag: 300000, faktor: 0.7 },
|
||||
{ id: "k2", block: 1, name: "Telefonzuschuss", art: "monat", betrag: 1000 },
|
||||
...sozial(),
|
||||
{ id: "k9", block: 3, name: "Betriebsärztlicher Dienst", art: "jahr", betrag: 15000 },
|
||||
{ id: "k10", block: 3, name: "Fortbildung", art: "jahr", betrag: 50000 },
|
||||
{ id: "k11", block: 4, name: "Sachaufwand Fahrzeuge", art: "jahr", betrag: 1134490, koepfe: true, notiz: "aus Zim. Grundk." },
|
||||
{ id: "k12", block: 4, name: "Sachaufwand Werkzeug", art: "jahr", betrag: 241392, koepfe: true, notiz: "aus Zim. Grundk." },
|
||||
{ id: "k13", block: 4, name: "Sachaufwand Software", art: "jahr", betrag: 177000, koepfe: true, notiz: "aus Zim. Grundk." },
|
||||
{ id: "k14", block: 4, name: "Investitionsrücklagen", art: "monat", betrag: 10000, koepfe: true },
|
||||
{ id: "k15", block: 4, name: "Verwaltung", art: "stunden", stunden: 8, betrag: 6500, koepfe: true },
|
||||
{ id: "k16", block: 4, name: "Kundenberatung, Akquisekosten", art: "stunden", stunden: 8, betrag: 6500, koepfe: true },
|
||||
{ id: "k17", block: 4, name: "Verbände", art: "jahr", betrag: 118000, koepfe: true, notiz: "aus Zim. Grundk." },
|
||||
{ id: "k18", block: 5, name: "FiBu (USt, Mitarbeiterverwaltung)", art: "monat", betrag: 120000, koepfe: true, notiz: "aus Zim. Grundk." },
|
||||
{ id: "k19", block: 5, name: "Steuerberatung", art: "jahr", betrag: 198615, koepfe: true, notiz: "aus Zim. Grundk." },
|
||||
],
|
||||
};
|
||||
}
|
||||
|
||||
function planer(): Rechentabelle {
|
||||
return {
|
||||
id: "planer", name: "Planer", zeit: zeit(), gewinn: 0, lohnanteil: 100, wagnis: 3,
|
||||
kosten: [
|
||||
{ id: "k1", block: 1, name: "Grundvergütung", art: "netto", betrag: 500000, faktor: 0.7 },
|
||||
{ id: "k2", block: 1, name: "Telefonzuschuss", art: "monat", betrag: 1000 },
|
||||
...sozial(),
|
||||
{ id: "k10", block: 3, name: "Fortbildung", art: "jahr", betrag: 50000 },
|
||||
{ id: "k11", block: 4, name: "Sachaufwand Fahrzeuge", art: "jahr", betrag: 200000 },
|
||||
{ id: "k12", block: 4, name: "Sachaufwand Werkzeug", art: "jahr", betrag: 0 },
|
||||
{ id: "k13", block: 4, name: "Sachaufwand Software", art: "jahr", betrag: 200000, notiz: "10.000 € auf 5 Jahre" },
|
||||
{ id: "k14", block: 4, name: "Investitionsrücklagen", art: "monat", betrag: 10000 },
|
||||
{ id: "k17", block: 4, name: "Verbände", art: "jahr", betrag: 22000, notiz: "aus Zim. Grundk." },
|
||||
{ id: "k18", block: 5, name: "FiBu (USt, Mitarbeiterverwaltung)", art: "monat", betrag: 120000, anteil: 20, notiz: "aus Zim. Grundk." },
|
||||
{ id: "k19", block: 5, name: "Steuerberatung", art: "jahr", betrag: 198615, anteil: 20, notiz: "aus Zim. Grundk." },
|
||||
],
|
||||
};
|
||||
}
|
||||
|
||||
/** Fassung 1: genau die Excel-Tabelle; Geselle und Helfer zunächst als Kopie von Chef (in der Excel gibt es sie nicht) */
|
||||
export function stundensaetzeAusExcel(): StundensatzDaten {
|
||||
const geselle = { ...chef(), id: "geselle", name: "Geselle", hinweis: "Kopie von Chef (in deiner Excel gleich). Bitte Lohn und Zeiten anpassen." };
|
||||
const helfer = { ...chef(), id: "helfer", name: "Helfer", hinweis: "In deiner Excel gibt es kein Helfer-Blatt: Kopie von Chef, bitte Lohn und Zeiten eintragen." };
|
||||
return {
|
||||
tabellen: [chef(), planer(), geselle, helfer],
|
||||
koepfe: 2,
|
||||
bewertung: "geselle",
|
||||
mittellohn: { chef: { an: true, personen: 1 }, geselle: { an: true, personen: 1 }, helfer: { an: false, personen: null }, planer: { an: false, personen: null } },
|
||||
};
|
||||
}
|
||||
|
||||
/** Fassung 2 (S2): Akquise und Verwaltung zählen nicht mehr als Zeit, sondern als Kosten zum Lohnkostensatz des Gesellen */
|
||||
export function stundensaetzeNachS2(d: StundensatzDaten): StundensatzDaten {
|
||||
const x = structuredClone(d);
|
||||
for (const t of x.tabellen) {
|
||||
const akquise = (u: Unproduktiv) => /akquise|verwaltung/i.test(u.name);
|
||||
if (!t.zeit.unproduktiv.some(akquise)) continue;
|
||||
for (const u of t.zeit.unproduktiv) if (akquise(u)) u.als = "kosten";
|
||||
t.kosten = t.kosten.filter((k) => !(k.art === "stunden" && /akquise|verwaltung/i.test(k.name)));
|
||||
}
|
||||
x.koepfe = null;
|
||||
for (const m of Object.values(x.mittellohn)) m.personen = null;
|
||||
return x;
|
||||
}
|
||||
270
src/domain/stundensatz.ts
Normal file
270
src/domain/stundensatz.ts
Normal file
@@ -0,0 +1,270 @@
|
||||
// Stundensätze im Personalmodul (M15–M19, Henning 22.10.2026, angebote/stundensaetze/stundensatz-konzept.md):
|
||||
// je Lohnart eine Rechentabelle wie Hennings Excel-Blatt. 1 Zeit: Arbeitstage × Std/Tag − Feiertage − Ausfall
|
||||
// − unproduktive Zeiten = produktive Stunden. 2 Kosten in fünf Blöcken (Lohn, AG-Anteile, indirekte Personalkosten,
|
||||
// Sachkosten, Verwaltung) plus kalkulatorischer Gewinn. 3 Stundensatz = Kosten je Jahr ÷ produktive Stunden (Vollkosten).
|
||||
// Unproduktive Zeiten können statt als Zeitabzug als Kosten zählen (S2): Stunden × Lohnkostensatz der Bewertungs-
|
||||
// Tabelle (Blöcke 1–3 ÷ produktive Stunden, ohne Gemeinkosten, damit keine Zirkelrechnung entsteht).
|
||||
// Gerechnet wird ohne Zwischenrundung wie in Excel; gerundet wird nur der Satz auf den Cent.
|
||||
import type { Cent } from "./geld.js";
|
||||
|
||||
export const BLOECKE = [1, 2, 3, 4, 5] as const;
|
||||
export type Block = (typeof BLOECKE)[number];
|
||||
export const BLOCK_NAME: Record<Block, string> = {
|
||||
1: "Lohn (direkter Personalaufwand)", 2: "AG-Anteile, BG, SoKa", 3: "indirekter Personalaufwand", 4: "Sachkosten (Organisationsaufwand)", 5: "zentrale Verwaltung",
|
||||
};
|
||||
|
||||
/** monat/jahr: fester Betrag; netto: Monatslohn netto ÷ Faktor = brutto; prozent: Anteil der Lohnsumme (Block 1);
|
||||
* stunden: Std je Monat × € je Std; laufend: Summe gewählter laufender Kosten im Jahr */
|
||||
export const KOSTENARTEN_S = ["netto", "monat", "jahr", "prozent", "stunden", "laufend"] as const;
|
||||
export type KostenArtS = (typeof KOSTENARTEN_S)[number];
|
||||
export const KOSTENART_S_NAME: Record<KostenArtS, string> = {
|
||||
netto: "netto je Monat", monat: "je Monat", jahr: "je Jahr", prozent: "% vom Lohn", stunden: "Std/Monat × €", laufend: "aus laufenden Kosten",
|
||||
};
|
||||
|
||||
export interface Kostenzeile {
|
||||
id: string;
|
||||
block: Block;
|
||||
name: string;
|
||||
art: KostenArtS;
|
||||
/** Cent: je Monat (netto, monat), je Jahr (jahr), je Stunde (stunden) */
|
||||
betrag?: Cent;
|
||||
/** netto: Anteil, der netto bleibt (0,7) */
|
||||
faktor?: number;
|
||||
/** prozent: Prozent der Lohnsumme */
|
||||
prozent?: number;
|
||||
/** stunden: Std je Monat */
|
||||
stunden?: number;
|
||||
/** laufend: ids der laufenden Kosten */
|
||||
laufend?: string[];
|
||||
/** Betrag auf die Köpfe des Betriebs verteilen */
|
||||
koepfe?: boolean;
|
||||
/** Anteil in %, Vorgabe 100 */
|
||||
anteil?: number;
|
||||
notiz?: string;
|
||||
}
|
||||
|
||||
export interface Ausfall { id: string; name: string; tage: number }
|
||||
export interface Unproduktiv { id: string; name: string; stunden: number; je: "monat" | "tag"; als: "zeit" | "kosten" }
|
||||
|
||||
export interface Rechentabelle {
|
||||
/** fester Schlüssel, zugleich die Lohnart im Angebot (chef, planer, geselle, helfer, …) */
|
||||
id: string;
|
||||
name: string;
|
||||
hinweis?: string;
|
||||
zeit: { stundenTag: number; tageJahr: number; feiertage: number; ausfall: Ausfall[]; unproduktiv: Unproduktiv[] };
|
||||
kosten: Kostenzeile[];
|
||||
/** kalkulatorischer Gewinn in % der Kosten */
|
||||
gewinn: number;
|
||||
/** Umsatzbedarf: Lohnanteil am Umsatz in % und Wagnis darin */
|
||||
lohnanteil: number;
|
||||
wagnis: number;
|
||||
}
|
||||
|
||||
export interface StundensatzDaten {
|
||||
tabellen: Rechentabelle[];
|
||||
/** Köpfe, auf die Sachkosten verteilt werden; leer = aus dem Personal gezählt */
|
||||
koepfe: number | null;
|
||||
/** Tabelle, mit deren Lohnkostensatz unproduktive Zeiten als Kosten bewertet werden (S2) */
|
||||
bewertung: string;
|
||||
/** je Tabelle: im Mittellohn an/aus und Personen (leer = aus dem Personal gezählt) */
|
||||
mittellohn: Record<string, { an: boolean; personen: number | null }>;
|
||||
}
|
||||
|
||||
/** Was das Programm selbst weiß: Köpfe und Personen je Lohnart aus dem Personal, laufende Kosten im Jahr */
|
||||
export interface Umfeld {
|
||||
koepfe: number;
|
||||
personen: Record<string, number>;
|
||||
laufend: Record<string, Cent>;
|
||||
}
|
||||
|
||||
export interface ZeileErgebnis {
|
||||
id: string;
|
||||
block: Block;
|
||||
name: string;
|
||||
jahr: number;
|
||||
monat: number;
|
||||
jeStd: number;
|
||||
/** Anteil an den Gesamtkosten in % */
|
||||
anteil: number;
|
||||
rechnung: string;
|
||||
/** aus einer unproduktiven Zeit „als Kosten“ */
|
||||
ausZeit?: boolean;
|
||||
}
|
||||
|
||||
export interface TabellenErgebnis {
|
||||
id: string;
|
||||
name: string;
|
||||
zeit: {
|
||||
bruttoStd: number; feiertageStd: number; jahresStd: number; jahresTage: number;
|
||||
ausfall: { id: string; std: number; tage: number }[]; ausfallStd: number; ausfallTage: number; anwesenheitTage: number;
|
||||
unproduktiv: { id: string; std: number; tage: number; als: "zeit" | "kosten" }[];
|
||||
produktiv: number; produktivTage: number;
|
||||
};
|
||||
zeilen: ZeileErgebnis[];
|
||||
/** je Block die Summe und die Zwischensumme bis einschließlich dieses Blocks (wie im Excel-Blatt) */
|
||||
bloecke: { block: Block; jahr: number; bis: number; bisJeStd: number }[];
|
||||
/** Blöcke 1–3: Lohnkosten ohne Gemeinkosten */
|
||||
lohnkosten: number;
|
||||
lohnkostensatz: Cent;
|
||||
gewinn: number;
|
||||
summe: number;
|
||||
/** Vollkosten-Stundensatz, auf den Cent gerundet */
|
||||
satz: Cent;
|
||||
satzGenau: number;
|
||||
gemeinkostenanteil: Cent;
|
||||
umsatzbedarf: number;
|
||||
}
|
||||
|
||||
export interface MittellohnErgebnis {
|
||||
zeilen: { id: string; name: string; an: boolean; personen: number; gezaehlt: number; std: number; satz: Cent; lohnkostensatz: Cent }[];
|
||||
personen: number;
|
||||
std: number;
|
||||
satz: Cent | null;
|
||||
lohnkostensatz: Cent | null;
|
||||
}
|
||||
|
||||
export interface StundensatzErgebnis {
|
||||
tabellen: TabellenErgebnis[];
|
||||
koepfe: number;
|
||||
bewertungssatz: Cent;
|
||||
mittellohn: MittellohnErgebnis;
|
||||
umsatzbedarf: { jahr: number; monat: number; lohn: number; material: number };
|
||||
}
|
||||
|
||||
const zahl = (n: number) => n.toLocaleString("de-DE", { maximumFractionDigits: 2 });
|
||||
const eur = (c: number) => `${(c / 100).toLocaleString("de-DE", { minimumFractionDigits: 2, maximumFractionDigits: 2 })} €`;
|
||||
|
||||
export function zeitRechnen(t: Rechentabelle): TabellenErgebnis["zeit"] {
|
||||
const z = t.zeit, h = z.stundenTag;
|
||||
const bruttoStd = z.tageJahr * h, feiertageStd = z.feiertage * h;
|
||||
const ausfall = z.ausfall.map((a) => ({ id: a.id, std: a.tage * h, tage: a.tage }));
|
||||
const ausfallStd = ausfall.reduce((s, a) => s + a.std, 0), ausfallTage = ausfall.reduce((s, a) => s + a.tage, 0);
|
||||
const anwesenheitTage = z.tageJahr - z.feiertage - ausfallTage;
|
||||
const unproduktiv = z.unproduktiv.map((u) => {
|
||||
const std = u.stunden * (u.je === "monat" ? 12 : anwesenheitTage);
|
||||
return { id: u.id, std, tage: h ? Math.ceil(std / h) : 0, als: u.als };
|
||||
});
|
||||
const produktiv = bruttoStd - feiertageStd - ausfallStd - unproduktiv.filter((u) => u.als === "zeit").reduce((s, u) => s + u.std, 0);
|
||||
return {
|
||||
bruttoStd, feiertageStd, jahresStd: bruttoStd - feiertageStd, jahresTage: z.tageJahr - z.feiertage, ausfall, ausfallStd, ausfallTage, anwesenheitTage,
|
||||
unproduktiv, produktiv, produktivTage: z.tageJahr - z.feiertage - ausfallTage - unproduktiv.filter((u) => u.als === "zeit").reduce((s, u) => s + u.tage, 0),
|
||||
};
|
||||
}
|
||||
|
||||
/** Kosten einer Zeile im Jahr (Cent, ungerundet) und wie sie entstehen */
|
||||
function zeileRechnen(k: Kostenzeile, lohnsumme: number, u: Umfeld): { jahr: number; rechnung: string } {
|
||||
const anteil = (k.anteil ?? 100) / 100;
|
||||
const teiler = k.koepfe ? Math.max(1, u.koepfe) : 1;
|
||||
const nach = (x: number) => (x * anteil) / teiler;
|
||||
const zusatz = `${anteil !== 1 ? ` × ${zahl(anteil * 100)} %` : ""}${teiler !== 1 ? ` ÷ ${zahl(teiler)} Köpfe` : ""}`;
|
||||
const b = k.betrag ?? 0;
|
||||
switch (k.art) {
|
||||
case "netto": {
|
||||
const f = k.faktor && k.faktor > 0 ? k.faktor : 1;
|
||||
return { jahr: nach((b / f) * 12), rechnung: `${eur(b)} netto ÷ ${zahl(f)} = ${eur(b / f)} brutto × 12${zusatz}` };
|
||||
}
|
||||
case "monat": return { jahr: nach(b * 12), rechnung: `${eur(b)} × 12${zusatz}` };
|
||||
case "jahr": return { jahr: nach(b), rechnung: `${eur(b)} im Jahr${zusatz}` };
|
||||
case "prozent": return { jahr: nach((lohnsumme * (k.prozent ?? 0)) / 100), rechnung: `${zahl(k.prozent ?? 0)} % von ${eur(lohnsumme)}${zusatz}` };
|
||||
case "stunden": return { jahr: nach((k.stunden ?? 0) * b * 12), rechnung: `${zahl(k.stunden ?? 0)} Std × ${eur(b)} × 12${zusatz}` };
|
||||
case "laufend": {
|
||||
const s = (k.laufend ?? []).reduce((x, id) => x + (u.laufend[id] ?? 0), 0);
|
||||
return { jahr: nach(s), rechnung: `${(k.laufend ?? []).length} laufende Kosten, ${eur(s)} im Jahr${zusatz}` };
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function tabelleRechnen(t: Rechentabelle, u: Umfeld, bewertung: (eigen: Cent) => Cent): TabellenErgebnis {
|
||||
const zeit = zeitRechnen(t);
|
||||
const prod = zeit.produktiv > 0 ? zeit.produktiv : NaN;
|
||||
const roh: Omit<ZeileErgebnis, "monat" | "jeStd" | "anteil">[] = [];
|
||||
let lohnsumme = 0;
|
||||
for (const block of BLOECKE) {
|
||||
if (block === 4) {
|
||||
// Lohnkostensatz steht nach Block 3 fest; unproduktive Zeiten „als Kosten“ kommen in die Sachkosten
|
||||
const lohnkosten = roh.reduce((s, z) => s + z.jahr, 0);
|
||||
const satz = bewertung(Number.isFinite(prod) ? Math.round(lohnkosten / prod) : 0);
|
||||
for (const p of t.zeit.unproduktiv) {
|
||||
if (p.als !== "kosten") continue;
|
||||
const std = zeit.unproduktiv.find((x) => x.id === p.id)!.std;
|
||||
roh.push({ id: `zeit-${p.id}`, block: 4, name: p.name, jahr: std * satz, rechnung: `${zahl(std)} Std × ${eur(satz)} Lohnkosten je Std`, ausZeit: true });
|
||||
}
|
||||
}
|
||||
for (const k of t.kosten.filter((x) => x.block === block)) {
|
||||
const r = zeileRechnen(k, lohnsumme, u);
|
||||
roh.push({ id: k.id, block, name: k.name, jahr: r.jahr, rechnung: r.rechnung });
|
||||
}
|
||||
if (block === 1) lohnsumme = roh.reduce((s, z) => s + z.jahr, 0);
|
||||
}
|
||||
const kosten = roh.reduce((s, z) => s + z.jahr, 0);
|
||||
const gewinn = (kosten * (t.gewinn ?? 0)) / 100;
|
||||
const summe = kosten + gewinn;
|
||||
const lohnkosten = roh.filter((z) => z.block <= 3).reduce((s, z) => s + z.jahr, 0);
|
||||
let bis = 0;
|
||||
const bloecke = BLOECKE.map((block) => {
|
||||
const jahr = roh.filter((z) => z.block === block).reduce((s, z) => s + z.jahr, 0);
|
||||
bis += jahr;
|
||||
return { block, jahr, bis, bisJeStd: bis / prod };
|
||||
});
|
||||
const satzGenau = summe / prod;
|
||||
const satz = Number.isFinite(satzGenau) ? Math.round(satzGenau) : 0;
|
||||
const lohnkostensatz = Number.isFinite(prod) ? Math.round(lohnkosten / prod) : 0;
|
||||
const netto = (t.lohnanteil - t.wagnis) / 100;
|
||||
return {
|
||||
id: t.id, name: t.name, zeit,
|
||||
zeilen: roh.map((z) => ({ ...z, monat: z.jahr / 12, jeStd: z.jahr / prod, anteil: summe ? (z.jahr / summe) * 100 : 0 })),
|
||||
bloecke, lohnkosten, lohnkostensatz, gewinn, summe, satz, satzGenau, gemeinkostenanteil: satz - lohnkostensatz,
|
||||
umsatzbedarf: netto > 0 ? summe / netto : 0,
|
||||
};
|
||||
}
|
||||
|
||||
/** Personen je Tabelle: eingetragen oder aus dem Personal gezählt */
|
||||
export const personenVon = (d: StundensatzDaten, u: Umfeld, id: string) => d.mittellohn[id]?.personen ?? u.personen[id] ?? 0;
|
||||
|
||||
export function rechneStundensaetze(d: StundensatzDaten, u: Umfeld): StundensatzErgebnis {
|
||||
const koepfe = d.koepfe ?? u.koepfe;
|
||||
const umfeld = { ...u, koepfe };
|
||||
// Bewertungssatz: Lohnkostensatz der Bewertungs-Tabelle, die ihre eigenen Zeiten dabei nur als Zeit kennt
|
||||
const bt = d.tabellen.find((t) => t.id === d.bewertung);
|
||||
const bewertungssatz = bt ? tabelleRechnen(bt, umfeld, (eigen) => eigen).lohnkostensatz : 0;
|
||||
const tabellen = d.tabellen.map((t) => tabelleRechnen(t, umfeld, (eigen) => (bt ? bewertungssatz : eigen)));
|
||||
const zeilen = tabellen.map((t) => {
|
||||
const m = d.mittellohn[t.id];
|
||||
return { id: t.id, name: t.name, an: m?.an ?? false, personen: personenVon(d, u, t.id), gezaehlt: u.personen[t.id] ?? 0, std: t.zeit.produktiv, satz: t.satz, lohnkostensatz: t.lohnkostensatz };
|
||||
});
|
||||
const mit = zeilen.filter((z) => z.an && z.personen > 0 && z.std > 0);
|
||||
const std = mit.reduce((s, z) => s + z.std * z.personen, 0);
|
||||
const gewichtet = (f: (z: (typeof mit)[number]) => number) => (std > 0 ? Math.round(mit.reduce((s, z) => s + f(z) * z.std * z.personen, 0) / std) : null);
|
||||
const jahr = tabellen.reduce((s, t) => s + t.umsatzbedarf * personenVon(d, u, t.id), 0);
|
||||
const lohn = tabellen.reduce((s, t) => s + t.summe * personenVon(d, u, t.id), 0);
|
||||
return {
|
||||
tabellen, koepfe, bewertungssatz,
|
||||
mittellohn: { zeilen, personen: mit.reduce((s, z) => s + z.personen, 0), std, satz: gewichtet((z) => z.satz), lohnkostensatz: gewichtet((z) => z.lohnkostensatz) },
|
||||
umsatzbedarf: { jahr, monat: jahr / 12, lohn, material: jahr - lohn },
|
||||
};
|
||||
}
|
||||
|
||||
export const MITTELLOHN = "mittellohn";
|
||||
|
||||
/** Sätze und Lohnarten, wie sie ein Angebot festschreibt (A36): Mittellohn zuerst, dann jede Tabelle */
|
||||
export function saetzeFuerAngebot(e: StundensatzErgebnis): { stundensaetze: Record<string, Cent>; lohnarten: { id: string; name: string }[] } {
|
||||
const stundensaetze: Record<string, Cent> = {};
|
||||
const lohnarten: { id: string; name: string }[] = [];
|
||||
if (e.mittellohn.satz != null) { stundensaetze[MITTELLOHN] = e.mittellohn.satz; lohnarten.push({ id: MITTELLOHN, name: "Mittellohn" }); }
|
||||
for (const t of e.tabellen) { stundensaetze[t.id] = t.satz; lohnarten.push({ id: t.id, name: t.name }); }
|
||||
return { stundensaetze, lohnarten };
|
||||
}
|
||||
|
||||
/** Schlüssel für eine neue Tabelle aus dem Namen: „2. Vorarbeiter“ → „2-vorarbeiter“, eindeutig */
|
||||
export function schluesselFuer(name: string, vorhanden: string[]): string {
|
||||
const roh = name.toLowerCase().replace(/ä/g, "ae").replace(/ö/g, "oe").replace(/ü/g, "ue").replace(/ß/g, "ss").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 30) || "lohnart";
|
||||
let s = roh === MITTELLOHN ? "lohnart" : roh, i = 2;
|
||||
while (vorhanden.includes(s)) s = `${roh}-${i++}`;
|
||||
return s;
|
||||
}
|
||||
|
||||
/** Jahressumme einer laufenden Kosten-Position im Jahr (einmalige zählen nicht) */
|
||||
export function laufendImJahr(k: { betrag: number; rhythmus: string; start: string; ende?: string | null }, jahr: number): Cent {
|
||||
if (k.rhythmus === "einmalig" || k.start > `${jahr}-12-31` || (k.ende && k.ende < `${jahr}-01-01`)) return 0;
|
||||
return k.betrag * ({ monatlich: 12, vierteljaehrlich: 4, jaehrlich: 1 } as Record<string, number>)[k.rhythmus]!;
|
||||
}
|
||||
@@ -13,6 +13,7 @@ import type { Mengenvorlage } from "../domain/mengenvorlagen.js";
|
||||
import { hatBlatt, vorlagen } from "./leistungen-daten.js";
|
||||
import { plusTage } from "../domain/datum.js";
|
||||
import { naechsterArbeitstag } from "../domain/kalender.js";
|
||||
import { aktuelleSaetze } from "./stundensaetze.js";
|
||||
|
||||
const IdParam = z.object({ id: z.uuid() });
|
||||
const heute = () => new Date().toISOString().slice(0, 10);
|
||||
@@ -30,9 +31,11 @@ export class AngebotFehler extends Error {
|
||||
|
||||
/** Sätze des Angebots (beim Anlegen kopiert); was fehlt, kommt aus den Einstellungen */
|
||||
export function saetzeVon(a: { saetze?: unknown; wagnis_prozent: unknown; gewinn_prozent: unknown; ausfall_prozent: unknown }, e: Einstellungen): Saetze {
|
||||
const s = (a.saetze ?? {}) as Partial<Pick<Saetze, "stundensaetze" | "zuschlaege" | "mengen" | "kilometersatz">>;
|
||||
const s = (a.saetze ?? {}) as Partial<Pick<Saetze, "stundensaetze" | "zuschlaege" | "mengen" | "kilometersatz" | "lohnarten" | "stundensatz_version">>;
|
||||
return {
|
||||
stundensaetze: { ...e.kalkulation.stundensaetze, ...(s.stundensaetze ?? {}) },
|
||||
...(s.lohnarten?.length ? { lohnarten: s.lohnarten } : {}),
|
||||
stundensatz_version: s.stundensatz_version ?? null,
|
||||
zuschlaege: { ...e.kalkulation.zuschlaege, ...(s.zuschlaege ?? {}) },
|
||||
wagnis: Number(a.wagnis_prozent), gewinn: Number(a.gewinn_prozent), ausfall: Number(a.ausfall_prozent),
|
||||
mengen: { verschnitt: e.kalkulation.verschnitt, oeffnung_ab: e.kalkulation.oeffnungAb, ...(s.mengen ?? {}) },
|
||||
@@ -205,6 +208,8 @@ export function registriereAngebote(
|
||||
const nummer = /^A-\d{2}-\d+/.test(p.nummer) && !belegt.has(p.nummer) ? p.nummer : naechsteNummer(nummern, new Date().getFullYear());
|
||||
const k = e.kalkulation;
|
||||
const datum = heute();
|
||||
// M17: Sätze aus den Stundensatz-Tabellen, die heute gelten; Vollkostensatz, daher Lohnzuschlag 0 % (A37, S4)
|
||||
const neue = await aktuelleSaetze(c, datum);
|
||||
const vorlage = q.von_angebot_id ? (await c.query("select * from angebot where id = $1", [q.von_angebot_id])).rows[0] : undefined;
|
||||
const neu = (await c.query(`insert into angebot (projekt_id, nummer, belegart, datum, bindefrist, betreff, kopftext, schlusstext, wagnis_prozent, gewinn_prozent, ausfall_prozent, saetze)
|
||||
values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12) returning *`,
|
||||
@@ -212,7 +217,8 @@ export function registriereAngebote(
|
||||
vorlage?.betreff ?? null, vorlage?.kopftext ?? k.kopftext, vorlage?.schlusstext ?? k.schlusstext,
|
||||
vorlage?.wagnis_prozent ?? k.wagnis, vorlage?.gewinn_prozent ?? k.gewinn, vorlage?.ausfall_prozent ?? k.ausfall,
|
||||
// A36: Sätze von heute festschreiben; eine Kopie übernimmt die Sätze nicht, sondern bekommt die aktuellen
|
||||
{ stundensaetze: k.stundensaetze, zuschlaege: k.zuschlaege, mengen: { verschnitt: k.verschnitt, oeffnung_ab: k.oeffnungAb }, kilometersatz: k.kilometersatz, stand: datum }])).rows[0];
|
||||
{ stundensaetze: { ...k.stundensaetze, ...neue?.stundensaetze }, ...(neue ? { lohnarten: neue.lohnarten, stundensatz_version: neue.stundensatz_version } : {}),
|
||||
zuschlaege: neue ? { ...k.zuschlaege, lohn: 0 } : k.zuschlaege, mengen: { verschnitt: k.verschnitt, oeffnung_ab: k.oeffnungAb }, kilometersatz: k.kilometersatz, stand: datum }])).rows[0];
|
||||
if (vorlage) await kopiereInhalt(c, vorlage.id, neu.id);
|
||||
if (p.status === "anfrage") await c.query("update projekt set status = 'angebot' where id = $1", [p.id]);
|
||||
return neu;
|
||||
@@ -226,7 +232,36 @@ export function registriereAngebote(
|
||||
const e = await einstellungen();
|
||||
const x = await ladeAngebot(pool, id, e);
|
||||
if (!x) return reply.status(404).send({ fehler: "Nicht gefunden" });
|
||||
return { ...x, pruefung: pruefung(x), ust_satz: e.ust.satz };
|
||||
return { ...x, pruefung: pruefung(x), ust_satz: e.ust.satz, neue_stundensaetze: await neueSaetze(x) };
|
||||
});
|
||||
|
||||
/** A36: gelten heute andere Stundensätze als im Entwurf festgeschrieben, fragt die Seite, ob sie übernommen werden */
|
||||
async function neueSaetze(x: NonNullable<Awaited<ReturnType<typeof ladeAngebot>>>) {
|
||||
if (x.angebot.status !== "entwurf") return null;
|
||||
const neu = await aktuelleSaetze(pool, heute());
|
||||
if (!neu) return null;
|
||||
const alt = x.saetze.stundensaetze;
|
||||
const gleich = neu.stundensatz_version.id === x.saetze.stundensatz_version?.id && Object.entries(neu.stundensaetze).every(([k, v]) => alt[k] === v);
|
||||
return gleich ? null : neu;
|
||||
}
|
||||
|
||||
// neue Stundensätze in den Entwurf übernehmen; ohne Version vorher (alte Sätze aus den Einstellungen) wird der Lohnzuschlag 0 %
|
||||
app.post("/api/angebote/:id/stundensaetze", async (req, reply) => {
|
||||
const { id } = IdParam.parse(req.params);
|
||||
const r = await transaktion(pool, wer(req), async (c) => {
|
||||
const a = (await c.query("select status, saetze from angebot where id = $1 for update", [id])).rows[0];
|
||||
if (!a) return null;
|
||||
if (a.status !== "entwurf") throw new AngebotFehler("Nur Entwürfe bekommen neue Stundensätze; versendete Angebote bleiben, wie sie sind.");
|
||||
const neu = await aktuelleSaetze(c, heute());
|
||||
if (!neu) throw new AngebotFehler("Es gibt noch keine Stundensätze unter Personal → Stundensätze.");
|
||||
const s = a.saetze ?? {};
|
||||
const saetze = { ...s, stundensaetze: { ...s.stundensaetze, ...neu.stundensaetze }, lohnarten: neu.lohnarten, stundensatz_version: neu.stundensatz_version,
|
||||
zuschlaege: s.stundensatz_version ? s.zuschlaege : { ...s.zuschlaege, lohn: 0 } };
|
||||
await c.query("update angebot set saetze = $2 where id = $1", [id, saetze]);
|
||||
return saetze;
|
||||
});
|
||||
if (!r) return reply.status(404).send({ fehler: "Nicht gefunden" });
|
||||
return r;
|
||||
});
|
||||
|
||||
// A14: vor dem Versand prüfen; mit Fehlern nur, wenn ausdrücklich „trotzdem“
|
||||
|
||||
@@ -39,8 +39,8 @@ function recht(methode: string, muster: string | undefined, url: string): Recht
|
||||
const k = `${methode} ${muster ?? ""}`;
|
||||
if (OFFEN.has(k)) return "offen";
|
||||
if (muster?.startsWith("/api/ich/") || muster === "/api/ich" || ALLE.has(k)) return "alle";
|
||||
// Jahresplan und BWA (Stufe 5) nur für den Inhaber
|
||||
if (muster?.startsWith("/api/benutzer") || muster?.startsWith("/api/jahresplan") || muster?.startsWith("/api/bwa") || muster?.startsWith("/api/finanzmonat") || INHABER.has(k)) return "inhaber";
|
||||
// Jahresplan und BWA (Stufe 5) und Stundensätze (Löhne, U2) nur für den Inhaber
|
||||
if (muster?.startsWith("/api/benutzer") || muster?.startsWith("/api/jahresplan") || muster?.startsWith("/api/stundensaetze") || muster?.startsWith("/api/bwa") || muster?.startsWith("/api/finanzmonat") || INHABER.has(k)) return "inhaber";
|
||||
return muster ? "buero" : "inhaber";
|
||||
}
|
||||
|
||||
|
||||
@@ -28,6 +28,7 @@ import { registriereUrlaub, zeitraumText } from "./urlaub.js";
|
||||
import { vorlageAnwenden } from "./vorlage.js";
|
||||
import { AngebotFehler, pruefeBearbeitbar, registriereAngebote } from "./angebote.js";
|
||||
import { registriereStammdaten } from "./stammdaten.js";
|
||||
import { registriereStundensaetze } from "./stundensaetze.js";
|
||||
import { finanzsitzungAnlegen, geltendePlaene, jahresplanStand, registriereJahresplan } from "./jahresplan.js";
|
||||
import { planPosten } from "../domain/jahresplan.js";
|
||||
import { type BezugArt, bezugsTage } from "../domain/bezug.js";
|
||||
@@ -98,6 +99,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
|
||||
registriereAngebote(app, pool, ladeEinstellungen, mitOrdner);
|
||||
registriereStammdaten(app, pool, ladeEinstellungen);
|
||||
registriereStundensaetze(app, pool);
|
||||
registriereJahresplan(app, pool, { einstellungen: ladeEinstellungen, liquiDaten: () => liquiDaten() });
|
||||
|
||||
app.post("/api/projekte/:id/ordner", async (req, reply) => {
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
// Jahresfinanzplanung und BWA (Stufe 5, Henning 21.10.2026). Nur für den Inhaber (Rollen im Heft).
|
||||
// Ein Jahr hat Versionen: die Basis bleibt, eine Version „gilt“ und speist Liquidität, Übersicht und Plan/Ist.
|
||||
import { aktuelleSaetze } from "./stundensaetze.js";
|
||||
import type { FastifyInstance, FastifyRequest } from "fastify";
|
||||
import { z } from "zod";
|
||||
import { type Client, type Pool, transaktion } from "./db.js";
|
||||
@@ -101,7 +102,7 @@ export function registriereJahresplan(app: FastifyInstance, pool: Pool, h: Hilfe
|
||||
const personalListe = (await pool.query(`select k.name, m.angestellt, m.lohn_cent, m.eintritt, m.austritt from mitarbeiter m join kontakt k on k.id = m.kontakt_id
|
||||
where m.austritt is null or m.austritt >= $1 order by m.angestellt, k.name`, [`${jahr}-01-01`])).rows;
|
||||
return { laufend: { ohnePersonal, personal, posten }, kontostand: e.startsaldo, mindestgrenze, vorjahr, saisonVorjahr, personal: personalListe,
|
||||
stundensatzEk: e.kalkulation.stundensaetze.geselle };
|
||||
stundensatzEk: (await aktuelleSaetze(pool, heute()))?.stundensaetze.mittellohn ?? e.kalkulation.stundensaetze.geselle };
|
||||
}
|
||||
|
||||
async function zuordnung(): Promise<Map<number, Planzeile>> {
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
// Leistungen und Mengenvorlagen aus Programm und Datenbank, mit den aktuellen Artikelpreisen aus dem Materialstamm.
|
||||
// Eine Kostenzeile mit Artikel nimmt immer den EK des Artikels: neue Preise rechnen die Leistungen neu,
|
||||
// Angebote behalten ihre Preise, weil die Kostenzeilen dort beim Einfügen festgeschrieben werden.
|
||||
import type { AngebotsSaetze } from "./stundensaetze.js";
|
||||
import type { Pool } from "./db.js";
|
||||
import type { Einstellungen } from "./einstellungen.js";
|
||||
import { type Mengenvorlage, STANDARD_VORLAGEN } from "../domain/mengenvorlagen.js";
|
||||
@@ -32,12 +33,13 @@ export async function artikelNach(c: Pick<Pool, "query">, ids: string[]): Promis
|
||||
return new Map(r.rows.map((a) => [a.id, { ...a, ek: a.ek === null ? null : Number(a.ek), preiseinheit: Number(a.preiseinheit), ek_je_einheit: ekJeEinheit(a) }]));
|
||||
}
|
||||
|
||||
/** Sätze der Stammdaten: Vorgaben der Angebote aus den Einstellungen */
|
||||
export function stammSaetze(e: Einstellungen): Saetze {
|
||||
/** Sätze der Stammdaten: wie ein neues Angebot heute, also Stundensätze aus Personal → Stundensätze, sonst Einstellungen */
|
||||
export function stammSaetze(e: Einstellungen, neue?: AngebotsSaetze | null): Saetze {
|
||||
const k = e.kalkulation;
|
||||
return {
|
||||
stundensaetze: { ...k.stundensaetze }, zuschlaege: { ...k.zuschlaege }, wagnis: k.wagnis, gewinn: k.gewinn, ausfall: k.ausfall,
|
||||
stundensaetze: { ...k.stundensaetze, ...neue?.stundensaetze }, zuschlaege: neue ? { ...k.zuschlaege, lohn: 0 } : { ...k.zuschlaege }, wagnis: k.wagnis, gewinn: k.gewinn, ausfall: k.ausfall,
|
||||
mengen: { verschnitt: k.verschnitt, oeffnung_ab: k.oeffnungAb }, kilometersatz: k.kilometersatz,
|
||||
...(neue ? { lohnarten: neue.lohnarten, stundensatz_version: neue.stundensatz_version } : {}),
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
20
src/server/migrations/020_stundensaetze.sql
Normal file
20
src/server/migrations/020_stundensaetze.sql
Normal file
@@ -0,0 +1,20 @@
|
||||
-- Stundensätze im Personalmodul (M15–M19, Henning 22.10.2026): Versionen mit „gilt ab“, je Version die
|
||||
-- Rechentabellen aller Lohnarten und die Mittellohn-Auswahl als JSON. Ein Angebot nimmt die Version, die an
|
||||
-- seinem Datum gilt, und schreibt die Sätze fest (A36).
|
||||
create table stundensatz_version (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
name text not null check (trim(name) <> ''),
|
||||
gilt_ab date not null unique,
|
||||
daten jsonb not null default '{}',
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
create trigger stundensatz_version_protokoll before insert or update or delete on stundensatz_version
|
||||
for each row execute function stempel_und_protokoll();
|
||||
|
||||
-- Lohnarten sind jetzt die Rechentabellen (Chef, Planer, Geselle, Helfer, eigene) und der Mittellohn
|
||||
alter table angebot_kosten drop constraint angebot_kosten_lohnart_check;
|
||||
alter table angebot_kosten add constraint angebot_kosten_lohnart_check check (lohnart ~ '^[a-z0-9-]{1,40}$');
|
||||
alter table mitarbeiter drop constraint mitarbeiter_funktion_check;
|
||||
alter table mitarbeiter add constraint mitarbeiter_funktion_check check (funktion ~ '^[a-z0-9-]{1,40}$');
|
||||
@@ -1,5 +1,6 @@
|
||||
// Stammdaten (Henning, 21.10.2026): Leistungen mit Vorkalkulation, GAEB-Import in Ordner, Materialstamm mit
|
||||
// DATANORM-Import und Rabatten je Lieferant. Siehe Entwürfe 1–4 in stammdaten/entwurf.
|
||||
import { aktuelleSaetze } from "./stundensaetze.js";
|
||||
import type { FastifyInstance, FastifyRequest } from "fastify";
|
||||
import { z } from "zod";
|
||||
import { type Pool, transaktion } from "./db.js";
|
||||
@@ -38,7 +39,7 @@ export function registriereStammdaten(app: FastifyInstance, pool: Pool, einstell
|
||||
|
||||
/** Leistungen mit Kosten, VK und Stunden je Einheit (Liste und Katalog im Angebot) */
|
||||
app.get("/api/leistungen", async () => {
|
||||
const s = stammSaetze(await einstellungen());
|
||||
const s = stammSaetze(await einstellungen(), await aktuelleSaetze(pool, new Date().toISOString().slice(0, 10)));
|
||||
return nurLeistungen(await vorlagen(pool)).map((v) => {
|
||||
const r = rechneLeistung(v, s);
|
||||
return {
|
||||
@@ -56,7 +57,7 @@ export function registriereStammdaten(app: FastifyInstance, pool: Pool, einstell
|
||||
const { id } = IdParam.parse(req.params);
|
||||
const v = (await vorlagen(pool)).find((x) => String(x.id) === id);
|
||||
if (!v) return reply.status(404).send({ fehler: "Diese Leistung gibt es nicht (mehr)." });
|
||||
const s = stammSaetze(await einstellungen());
|
||||
const s = stammSaetze(await einstellungen(), await aktuelleSaetze(pool, new Date().toISOString().slice(0, 10)));
|
||||
const artikel = Object.fromEntries(await artikelNach(pool, (v.inhalt.ansaetze ?? []).map((z) => z.artikel_id).filter((x): x is string => !!x)));
|
||||
const angebote = (await pool.query(`select a.id, a.nummer, a.datum from angebot_position p join angebot a on a.id = p.angebot_id
|
||||
where p.aufmass -> 'vorlage' ->> 'id' = $1 order by a.datum desc, a.nummer desc`, [id])).rows;
|
||||
@@ -99,7 +100,7 @@ export function registriereStammdaten(app: FastifyInstance, pool: Pool, einstell
|
||||
ordner: z.string().trim().min(1).max(300).optional(),
|
||||
prozent: z.number().min(-90).max(500).optional(),
|
||||
}).parse(req.body ?? {});
|
||||
const s = stammSaetze(await einstellungen());
|
||||
const s = stammSaetze(await einstellungen(), await aktuelleSaetze(pool, new Date().toISOString().slice(0, 10)));
|
||||
const alle = new Map((await vorlagen(pool)).map((v) => [String(v.id), v]));
|
||||
const gewaehlt = q.ids.map((i) => alle.get(i)).filter((v): v is Mengenvorlage => !!v);
|
||||
const eigene = gewaehlt.filter((v) => !v.fest);
|
||||
|
||||
140
src/server/stundensaetze.ts
Normal file
140
src/server/stundensaetze.ts
Normal file
@@ -0,0 +1,140 @@
|
||||
// Stundensätze im Personalmodul (M15–M19, Henning 22.10.2026). Nur der Inhaber sieht Löhne und Sätze (U2);
|
||||
// die Namen der Lohnarten (/api/lohnarten) braucht auch das Büro für Personal und Kalkulation.
|
||||
import type { FastifyInstance, FastifyRequest } from "fastify";
|
||||
import { z } from "zod";
|
||||
import { type Client, type Pool, transaktion } from "./db.js";
|
||||
import { werName } from "./anmeldung.js";
|
||||
import { type Block, KOSTENARTEN_S, MITTELLOHN, type StundensatzDaten, type Umfeld, laufendImJahr, rechneStundensaetze, saetzeFuerAngebot } from "../domain/stundensatz.js";
|
||||
import { stundensaetzeAusExcel, stundensaetzeNachS2 } from "../domain/stundensatz-excel.js";
|
||||
import type { Cent } from "../domain/geld.js";
|
||||
|
||||
const schluessel = z.string().regex(/^[a-z0-9-]{1,40}$/).refine((s) => s !== MITTELLOHN, "„mittellohn“ ist vergeben");
|
||||
const kurz = z.string().trim().max(120);
|
||||
const zahl = z.number().min(0).max(1e7);
|
||||
const cent = z.number().int().min(0).max(10_000_000_000);
|
||||
const kleineId = z.string().min(1).max(40);
|
||||
|
||||
export const DatenSchema = z.object({
|
||||
tabellen: z.array(z.object({
|
||||
id: schluessel,
|
||||
name: kurz.min(1),
|
||||
hinweis: z.string().max(500).optional(),
|
||||
zeit: z.object({
|
||||
stundenTag: z.number().min(0).max(24), tageJahr: z.number().min(0).max(366), feiertage: z.number().min(0).max(366),
|
||||
ausfall: z.array(z.object({ id: kleineId, name: kurz, tage: z.number().min(0).max(366) })).max(30),
|
||||
unproduktiv: z.array(z.object({ id: kleineId, name: kurz, stunden: z.number().min(0).max(744), je: z.enum(["monat", "tag"]), als: z.enum(["zeit", "kosten"]) })).max(30),
|
||||
}),
|
||||
kosten: z.array(z.object({
|
||||
id: kleineId, block: z.number().int().min(1).max(5).transform((b) => b as Block),
|
||||
name: kurz, art: z.enum(KOSTENARTEN_S), betrag: cent.optional(), faktor: z.number().min(0.01).max(10).optional(), prozent: z.number().min(0).max(1000).optional(),
|
||||
stunden: z.number().min(0).max(744).optional(), laufend: z.array(z.uuid()).max(200).optional(), koepfe: z.boolean().optional(),
|
||||
anteil: z.number().min(0).max(1000).optional(), notiz: z.string().max(300).optional(),
|
||||
})).max(100),
|
||||
gewinn: z.number().min(0).max(100), lohnanteil: z.number().min(1).max(100), wagnis: z.number().min(0).max(50),
|
||||
})).min(1).max(30).refine((t) => new Set(t.map((x) => x.id)).size === t.length, "Jede Tabelle braucht einen eigenen Schlüssel"),
|
||||
koepfe: zahl.min(1).max(500).nullable(),
|
||||
bewertung: z.string().max(40),
|
||||
mittellohn: z.record(z.string().max(40), z.object({ an: z.boolean(), personen: z.number().min(0).max(500).nullable() })),
|
||||
});
|
||||
|
||||
const Datum = z.string().regex(/^\d{4}-\d{2}-\d{2}$/);
|
||||
const IdParam = z.object({ id: z.uuid() });
|
||||
|
||||
type Abfrage = Pick<Pool | Client, "query">;
|
||||
|
||||
/** Köpfe und Personen je Lohnart aus dem Personal (heute beschäftigt): der Inhaber ohne Rolle zählt als Chef,
|
||||
* Angestellte ohne Rolle als Geselle. Laufende Kosten als Jahressumme im angegebenen Jahr. */
|
||||
export async function umfeldLaden(c: Abfrage, jahr: number, heute: string): Promise<Umfeld & { liste: { id: string; bezeichnung: string; kategorie: string | null; jahr: Cent }[] }> {
|
||||
const leute = (await c.query(`select coalesce(funktion, case when angestellt then 'geselle' else 'chef' end) as lohnart, count(*)::int as n from mitarbeiter
|
||||
where (eintritt is null or eintritt <= $1) and (austritt is null or austritt >= $1) group by 1`, [heute])).rows;
|
||||
const personen = Object.fromEntries(leute.map((r) => [r.lohnart as string, r.n as number]));
|
||||
const lk = (await c.query("select id, bezeichnung, kategorie, betrag, rhythmus, start, ende from laufende_kosten order by kategorie nulls last, bezeichnung")).rows;
|
||||
const liste = lk.map((l) => ({ id: l.id as string, bezeichnung: l.bezeichnung as string, kategorie: (l.kategorie ?? null) as string | null, jahr: laufendImJahr({ ...l, betrag: Number(l.betrag) }, jahr) }));
|
||||
return { koepfe: Math.max(1, leute.reduce((s, r) => s + (r.n as number), 0)), personen, laufend: Object.fromEntries(liste.map((l) => [l.id, l.jahr])), liste };
|
||||
}
|
||||
|
||||
/** Version, die an diesem Tag gilt */
|
||||
async function geltende(c: Abfrage, datum: string) {
|
||||
return (await c.query("select id, name, gilt_ab, daten from stundensatz_version where gilt_ab <= $1 order by gilt_ab desc limit 1", [datum])).rows[0] as
|
||||
{ id: string; name: string; gilt_ab: string; daten: StundensatzDaten } | undefined;
|
||||
}
|
||||
|
||||
export interface AngebotsSaetze { stundensaetze: Record<string, Cent>; lohnarten: { id: string; name: string }[]; stundensatz_version: { id: string; name: string; gilt_ab: string } }
|
||||
|
||||
/** Sätze für ein neues Angebot (A36) aus der Version, die am Datum gilt; ohne Version null (dann die Einstellungen) */
|
||||
export async function aktuelleSaetze(c: Abfrage, datum: string): Promise<AngebotsSaetze | null> {
|
||||
const v = await geltende(c, datum);
|
||||
if (!v) return null;
|
||||
const u = await umfeldLaden(c, Number(v.gilt_ab.slice(0, 4)), datum);
|
||||
return { ...saetzeFuerAngebot(rechneStundensaetze(v.daten, u)), stundensatz_version: { id: v.id, name: v.name, gilt_ab: v.gilt_ab } };
|
||||
}
|
||||
|
||||
export function registriereStundensaetze(app: FastifyInstance, pool: Pool): void {
|
||||
const wer = (req: FastifyRequest) => werName(req);
|
||||
const heute = () => new Date().toISOString().slice(0, 10);
|
||||
const zeile = (r: Record<string, any>) => ({ id: r.id, name: r.name, gilt_ab: r.gilt_ab, daten: r.daten as StundensatzDaten, geaendert_am: r.geaendert_am });
|
||||
|
||||
app.get("/api/stundensaetze", async () => {
|
||||
const versionen = (await pool.query("select * from stundensatz_version order by gilt_ab")).rows.map(zeile);
|
||||
const gilt = await geltende(pool, heute());
|
||||
const jahre = [...new Set(versionen.map((v) => Number(v.gilt_ab.slice(0, 4))).concat(Number(heute().slice(0, 4))))];
|
||||
const umfeld: Record<number, Awaited<ReturnType<typeof umfeldLaden>>> = {};
|
||||
for (const j of jahre) umfeld[j] = await umfeldLaden(pool, j, heute());
|
||||
const personal = (await pool.query(`select k.name, m.funktion, m.angestellt from mitarbeiter m join kontakt k on k.id = m.kontakt_id
|
||||
where (m.eintritt is null or m.eintritt <= $1) and (m.austritt is null or m.austritt >= $1) order by k.name`, [heute()])).rows;
|
||||
return { versionen, gilt: gilt?.id ?? null, umfeld, personal, heute: heute() };
|
||||
});
|
||||
|
||||
// Lohnarten für Rolle im Personal und Auswahl in der Kalkulation: Tabellen der heute geltenden Version
|
||||
app.get("/api/lohnarten", async () => {
|
||||
const v = await geltende(pool, heute());
|
||||
const tabellen = v?.daten.tabellen.map((t) => ({ id: t.id, name: t.name })) ?? [];
|
||||
return tabellen.length ? tabellen : [{ id: "planer", name: "Planer" }, { id: "geselle", name: "Geselle" }, { id: "helfer", name: "Helfer" }];
|
||||
});
|
||||
|
||||
const Neu = z.object({ name: kurz.min(1), gilt_ab: Datum, daten: DatenSchema });
|
||||
app.post("/api/stundensaetze", async (req, reply) => {
|
||||
const q = Neu.parse(req.body);
|
||||
const r = await transaktion(pool, wer(req), async (c) => {
|
||||
if ((await c.query("select 1 from stundensatz_version where gilt_ab = $1", [q.gilt_ab])).rowCount) return null;
|
||||
return (await c.query("insert into stundensatz_version (name, gilt_ab, daten) values ($1, $2, $3) returning *", [q.name, q.gilt_ab, q.daten])).rows[0];
|
||||
});
|
||||
if (!r) return reply.status(409).send({ fehler: "An diesem Tag beginnt schon eine Version. Bitte ein anderes Datum wählen." });
|
||||
return reply.status(201).send(zeile(r));
|
||||
});
|
||||
|
||||
// M19: erste Fassung aus Hennings Excel (gilt ab 26.05.2026) und die Fassung nach S2 (gilt ab heute)
|
||||
app.post("/api/stundensaetze/excel", async (req, reply) => {
|
||||
const r = await transaktion(pool, wer(req), async (c) => {
|
||||
if ((await c.query("select 1 from stundensatz_version limit 1")).rowCount) return null;
|
||||
const excel = stundensaetzeAusExcel();
|
||||
await c.query("insert into stundensatz_version (name, gilt_ab, daten) values ($1, $2, $3)", ["Excel 26.05.2026", "2026-05-26", excel]);
|
||||
const ab = heute() > "2026-05-26" ? heute() : "2026-05-27";
|
||||
return (await c.query("insert into stundensatz_version (name, gilt_ab, daten) values ($1, $2, $3) returning *",
|
||||
["Akquise und Verwaltung als Kosten", ab, stundensaetzeNachS2(excel)])).rows[0];
|
||||
});
|
||||
if (!r) return reply.status(409).send({ fehler: "Es gibt schon Stundensätze." });
|
||||
return reply.status(201).send(zeile(r));
|
||||
});
|
||||
|
||||
const Aenderung = z.object({ name: kurz.min(1).optional(), gilt_ab: Datum.optional(), daten: DatenSchema.optional() });
|
||||
app.patch("/api/stundensaetze/:id", async (req, reply) => {
|
||||
const { id } = IdParam.parse(req.params);
|
||||
const q = Aenderung.parse(req.body);
|
||||
const r = await transaktion(pool, wer(req), async (c) => {
|
||||
if (q.gilt_ab && (await c.query("select 1 from stundensatz_version where gilt_ab = $1 and id <> $2", [q.gilt_ab, id])).rowCount) return "doppelt" as const;
|
||||
return (await c.query(`update stundensatz_version set name = coalesce($2, name), gilt_ab = coalesce($3, gilt_ab), daten = coalesce($4, daten)
|
||||
where id = $1 returning *`, [id, q.name ?? null, q.gilt_ab ?? null, q.daten ?? null])).rows[0];
|
||||
});
|
||||
if (r === "doppelt") return reply.status(409).send({ fehler: "An diesem Tag beginnt schon eine Version. Bitte ein anderes Datum wählen." });
|
||||
if (!r) return reply.status(404).send({ fehler: "Nicht gefunden" });
|
||||
return zeile(r);
|
||||
});
|
||||
|
||||
app.delete("/api/stundensaetze/:id", async (req, reply) => {
|
||||
const { id } = IdParam.parse(req.params);
|
||||
const r = await transaktion(pool, wer(req), (c) => c.query("delete from stundensatz_version where id = $1", [id]));
|
||||
if (!r.rowCount) return reply.status(404).send({ fehler: "Nicht gefunden" });
|
||||
return reply.status(204).send();
|
||||
});
|
||||
}
|
||||
@@ -25,7 +25,7 @@ const blatt = z.object({
|
||||
// Zeitansatz oder Material einer Vorlage: wird beim Einfügen eine Kostenzeile der Position
|
||||
const ansatz = z.object({
|
||||
kostenart: z.enum(["lohn", "material", "geraet", "fahrt", "subunternehmer", "sonstiges"]),
|
||||
lohnart: z.enum(["planer", "geselle", "helfer"]).nullable().optional(),
|
||||
lohnart: z.string().regex(/^[a-z0-9-]{1,40}$/).nullable().optional(),
|
||||
beschreibung: z.string().max(300).nullable().optional(),
|
||||
bezug: kurzeFormel.nullable().optional(),
|
||||
menge: z.number().min(0).max(1e9),
|
||||
@@ -147,7 +147,10 @@ export const TABELLEN: Tabelle[] = [
|
||||
gewinn_prozent: z.number().min(0).max(50).optional(),
|
||||
ausfall_prozent: z.number().min(0).max(50).optional(),
|
||||
saetze: z.object({
|
||||
stundensaetze: z.object({ planer: cent.min(0), geselle: cent.min(0), helfer: cent.min(0) }).partial().optional(),
|
||||
stundensaetze: z.record(z.string().regex(/^[a-z0-9-]{1,40}$/), cent.min(0)).optional(),
|
||||
// Lohnarten aus den Stundensatz-Tabellen und die Version, aus der die Sätze stammen (M17)
|
||||
lohnarten: z.array(z.object({ id: z.string().regex(/^[a-z0-9-]{1,40}$/), name: z.string().max(120) })).max(40).optional(),
|
||||
stundensatz_version: z.object({ id: z.string().max(40), name: z.string().max(120), gilt_ab: datum }).nullable().optional(),
|
||||
zuschlaege: z.object({ lohn: z.number().min(0).max(500), material: z.number().min(0).max(500), geraet: z.number().min(0).max(500), fahrt: z.number().min(0).max(500), subunternehmer: z.number().min(0).max(500), sonstiges: z.number().min(0).max(500) }).partial().optional(),
|
||||
kilometersatz: z.number().int().min(0).optional(),
|
||||
mengen: z.object({ verschnitt: z.number().min(0).max(100), oeffnung_ab: z.number().min(0).max(100) }).partial().optional(),
|
||||
@@ -198,7 +201,7 @@ export const TABELLEN: Tabelle[] = [
|
||||
schema: z.object({
|
||||
position_id: id,
|
||||
kostenart: z.enum(["lohn", "material", "geraet", "fahrt", "subunternehmer", "sonstiges"]),
|
||||
lohnart: z.enum(["planer", "geselle", "helfer"]).nullable().optional(),
|
||||
lohnart: z.string().regex(/^[a-z0-9-]{1,40}$/).nullable().optional(),
|
||||
beschreibung: optText,
|
||||
menge: z.number().min(0).max(1e9).optional(),
|
||||
einheit: optText,
|
||||
@@ -425,7 +428,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(),
|
||||
funktion: z.string().regex(/^[a-z0-9-]{1,40}$/).nullable().optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
@@ -477,4 +480,6 @@ export const NUR_SICHERUNG: { name: string; pfad: string; sortierung: string }[]
|
||||
{ name: "jahresplan", pfad: "jahresplaene", sortierung: "jahr, basis desc, angelegt_am" },
|
||||
{ name: "finanz_monat", pfad: "finanz_monate", sortierung: "jahr, monat" },
|
||||
{ name: "bwa_zuordnung", pfad: "bwa_zuordnungen", sortierung: "zeile" },
|
||||
// Stundensätze im Personalmodul (M15–M19)
|
||||
{ name: "stundensatz_version", pfad: "stundensatz_versionen", sortierung: "gilt_ab" },
|
||||
];
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
// Jede Änderung wird sofort gespeichert und neu gerechnet; nach dem Versand ist das Angebot festgeschrieben (A19).
|
||||
|
||||
import { formatEuro, parseEuro } from "../domain/geld.js";
|
||||
import { EINHEITEN, KOSTENARTEN, KOSTENART_NAME, LOHNARTEN, LOHNART_NAME, POSITIONSARTEN, POSITIONSART_NAME, umgebungVon } from "../domain/kalkulation.js";
|
||||
import { EINHEITEN, KOSTENARTEN, KOSTENART_NAME, POSITIONSARTEN, POSITIONSART_NAME, lohnartOptionen, lohnartenVon, standardLohnart, umgebungVon } from "../domain/kalkulation.js";
|
||||
import { benenneUm, zahlDeutsch } from "../domain/formel.js";
|
||||
import { type Blatt, alsBlatt, leeresBlatt, textMitWerten, werteBlatt } from "../domain/mengenblatt.js";
|
||||
import type { Mengenvorlage } from "../domain/mengenvorlagen.js";
|
||||
@@ -240,7 +240,7 @@ async function editor(id: string, gross: string | null): Promise<void> {
|
||||
}
|
||||
if (pfad === "saetze") {
|
||||
// Sätze dieses Angebots (A36): ganze Gruppe zurückschreiben
|
||||
const s: Zeile = { stundensaetze: { ...d.saetze.stundensaetze }, zuschlaege: { ...d.saetze.zuschlaege }, mengen: { ...d.saetze.mengen }, kilometersatz: d.saetze.kilometersatz, stand: d.angebot.saetze?.stand ?? heute() };
|
||||
const s: Zeile = { stundensaetze: { ...d.saetze.stundensaetze }, lohnarten: d.saetze.lohnarten, stundensatz_version: d.saetze.stundensatz_version ?? null, zuschlaege: { ...d.saetze.zuschlaege }, mengen: { ...d.saetze.mengen }, kilometersatz: d.saetze.kilometersatz, stand: d.angebot.saetze?.stand ?? heute() };
|
||||
if (zid === "km") s.kilometersatz = wert ?? 0;
|
||||
else s[zid][feld] = wert ?? 0;
|
||||
return api(`angebote/${id}`, "PATCH", { saetze: s });
|
||||
@@ -249,7 +249,7 @@ async function editor(id: string, gross: string | null): Promise<void> {
|
||||
if (pfad === "angebot-positionen" && feld === "art" && wert !== "alternativ") body = { ...body, grundposition_id: null };
|
||||
if (pfad === "angebot-kosten" && feld === "kostenart") {
|
||||
const kz = d.kosten.find((x: Zeile) => x.id === zid);
|
||||
body = { ...body, lohnart: wert === "lohn" ? kz?.lohnart ?? "geselle" : null,
|
||||
body = { ...body, lohnart: wert === "lohn" ? kz?.lohnart ?? standardLohnart(d.saetze) : null,
|
||||
...(wert === "lohn" ? { einheit: "h" } : wert === "fahrt" ? { einheit: "km" } : ["h", "km"].includes(kz?.einheit) ? { einheit: null } : {}) };
|
||||
}
|
||||
return api(`${pfad}/${pfad === "angebote" ? id : zid}`, "PATCH", body);
|
||||
@@ -515,6 +515,8 @@ async function editor(id: string, gross: string | null): Promise<void> {
|
||||
merkeTab(p.id, "kalk");
|
||||
return neuLaden(`„${art.bezeichnung}“ ist als Materialzeile in der Kalkulation.`);
|
||||
}
|
||||
if (a === "saetze-neu") { await api(`angebote/${id}/stundensaetze`, "POST"); return neuLaden("Die neuen Stundensätze gelten jetzt in diesem Angebot."); }
|
||||
if (a === "saetze-alt") { SAETZE_SO_LASSEN.add(`${id}:${d.neue_stundensaetze?.stundensatz_version.id}`); return zeichne(); }
|
||||
if (a === "vorlage") return await einfuegen("vorlage", z.aktiv ?? z.ziel, zid, b.dataset.in);
|
||||
if (a === "gross") { location.hash = `mengenblatt-${zid}`; return; }
|
||||
if (a === "als-vorlage") return await alsVorlage(zid);
|
||||
@@ -523,7 +525,7 @@ async function editor(id: string, gross: string | null): Promise<void> {
|
||||
const p = pos(zid)!;
|
||||
const blatt = p.mit_aufmass ? alsBlatt(p.aufmass) : null;
|
||||
const fahrt = art === "fahrt";
|
||||
const k = await api<Zeile>("angebot-kosten", "POST", { position_id: zid, kostenart: art, lohnart: art === "lohn" ? "geselle" : null, menge: art === "lohn" ? 0.1 : 1,
|
||||
const k = await api<Zeile>("angebot-kosten", "POST", { position_id: zid, kostenart: art, lohnart: art === "lohn" ? standardLohnart(d.saetze) : null, menge: art === "lohn" ? 0.1 : 1,
|
||||
beschreibung: fahrt ? "Fahrt zur Baustelle" : null,
|
||||
bezug: fahrt ? null : blatt?.menge?.trim() || null, einheit: art === "lohn" ? "h" : fahrt ? "km" : p.einheit ?? null, reihenfolge: kostenVon(zid).reduce((m, x) => Math.max(m, Number(x.reihenfolge) + 1), 0) });
|
||||
z.auf.add(`${zid}:${art}`);
|
||||
@@ -667,7 +669,7 @@ function handyHtml(d: Zeile, meldung: string): string {
|
||||
return `<div class="angebot-handy">
|
||||
<div class="kopf"><a class="neben zurueck" href="#projekt-${a.projekt_id}-dokumente" aria-label="Zurück zum Projekt">←</a>
|
||||
<h1>${esc(a.nummer)} <span class="nummer">${esc(a.projekt_name)}</span></h1>${angebotMarke(a)}</div>
|
||||
${meldung ? `<div class="${meldung.startsWith("! ") ? "warnung" : "erfolg"}" role="status">${esc(meldung.replace(/^! /, ""))}</div>` : ""}
|
||||
${meldung ? `<div class="${meldung.startsWith("! ") ? "warnung" : "erfolg"}" role="status">${esc(meldung.replace(/^! /, ""))}</div>` : ""}${neueSaetzeHtml(d)}
|
||||
<p class="hinweis ah-banner">Am Handy: ansehen, Mengen und Preise ändern, freigeben. Kalkulation und Vorlagen bearbeiten am PC.</p>
|
||||
<section class="karte ah-lv">${lv || '<p class="hinweis leer">Noch keine Positionen.</p>'}</section>
|
||||
<section class="karte stand-zahlen"><div><small>Netto</small><b>${euro(e.netto)}</b></div><div><small>Brutto</small><b>${euro(e.brutto)}</b></div>
|
||||
@@ -739,7 +741,7 @@ function kostenTabelle(d: Zeile, p: Zeile, frei: boolean, auf?: Set<string>): st
|
||||
<td>${feld(`angebot-kosten:${k.id}:menge`, zahlText(k.menge), { typ: "zahl", klasse: "zahl w-ansatz am-eingabe", titel: lohn ? "Std je Einheit" : fahrt ? "Einsatztage" : "Menge je Einheit", platz: fahrt ? "Tage" : "", spalte: `km-${p.id}` })}</td>
|
||||
<td>${mitPers ? feld(`angebot-kosten:${k.id}:personen`, zahlText(k.personen ?? 1), { typ: "zahl", klasse: "zahl w-pers am-eingabe", titel: fahrt ? "Fahrzeuge" : "Personen" }) : ""}</td>
|
||||
<td class="zahl"><b>${zahlDeutsch(z.menge_gesamt, lohn ? "h" : k.einheit)}</b>${lohn ? " h" : fahrt ? " km" : ""}</td>
|
||||
<td>${lohn ? auswahl(`angebot-kosten:${k.id}:lohnart`, LOHNARTEN.map((x) => [x, LOHNART_NAME[x]]), k.lohnart ?? "geselle", "Lohnart") : fahrt ? "" : feld(`angebot-kosten:${k.id}:einheit`, k.einheit ?? "", { klasse: "w-einheit", titel: "Einheit", platz: "Einheit", liste: "einheiten" })}</td>
|
||||
<td>${lohn ? auswahl(`angebot-kosten:${k.id}:lohnart`, lohnartOptionen(lohnartenVon(s), k.lohnart), k.lohnart ?? "geselle", "Lohnart") : fahrt ? "" : feld(`angebot-kosten:${k.id}:einheit`, k.einheit ?? "", { klasse: "w-einheit", titel: "Einheit", platz: "Einheit", liste: "einheiten" })}</td>
|
||||
<td>${feld(`angebot-kosten:${k.id}:ek`, euroFeld(k.ek), { typ: "euro", klasse: "zahl w-ek", leer: "null", titel: fahrt ? "Kosten je km" : "Einkaufspreis", platz: lohn ? euroFeld(s.stundensaetze[k.lohnart ?? "geselle"]) : fahrt ? euroFeld(s.kilometersatz ?? 50) : "0,00", spalte: `ke-${p.id}` })}</td>
|
||||
<td>${feld(`angebot-kosten:${k.id}:faktor`, zahlText(k.faktor), { typ: "zahl", klasse: "zahl w-faktor", titel: "Faktor" })}</td>
|
||||
<td class="zahl">${betrag(z.kosten * menge)}</td>
|
||||
@@ -959,7 +961,8 @@ function kiHtml(z: Zustand, leistungen: Zeile[]): string {
|
||||
function vorgabenHtml(d: Zeile, frei: boolean): string {
|
||||
const a = d.angebot, s = d.saetze;
|
||||
const feld = feldBau(frei);
|
||||
return `<div class="vorgabe"><span class="t">Stundensätze (EK)</span>${LOHNARTEN.map((x) => `<label>${LOHNART_NAME[x]}${feld(`saetze:stundensaetze:${x}`, euroFeld(s.stundensaetze[x]), { typ: "euro", klasse: "zahl w-euro" })}</label>`).join("")}
|
||||
const v = s.stundensatz_version;
|
||||
return `<div class="vorgabe"><span class="t">Stundensätze (EK)</span>${lohnartenVon(s).map((x) => `<label>${esc(x.name)}${feld(`saetze:stundensaetze:${x.id}`, euroFeld(s.stundensaetze[x.id]), { typ: "euro", klasse: "zahl w-euro" })}</label>`).join("")}
|
||||
<span class="t">Zuschläge</span>${KOSTENARTEN.map((x) => `<label>${KOSTENART_NAME[x]}<span class="mit-einheit">${feld(`saetze:zuschlaege:${x}`, zahlText(s.zuschlaege[x]), { typ: "zahl", klasse: "zahl w-kurz" })} %</span></label>`).join("")}
|
||||
<span class="t">Wagnis und Gewinn</span>
|
||||
<label>Wagnis<span class="mit-einheit">${feld("angebote:x:wagnis_prozent", zahlText(a.wagnis_prozent), { typ: "zahl", klasse: "zahl w-kurz" })} %</span></label>
|
||||
@@ -969,7 +972,22 @@ function vorgabenHtml(d: Zeile, frei: boolean): string {
|
||||
<span class="t">Mengen</span>
|
||||
<label title="Im Mengenblatt als VERSCHNITT">Verschnitt<span class="mit-einheit">${feld("saetze:mengen:verschnitt", zahlText(s.mengen?.verschnitt), { typ: "zahl", klasse: "zahl w-kurz" })} %</span></label>
|
||||
<label title="Im Mengenblatt als ÖFFNUNG_AB">Öffnungen abziehen ab<span class="mit-einheit">${feld("saetze:mengen:oeffnung_ab", zahlText(s.mengen?.oeffnung_ab), { typ: "zahl", klasse: "zahl w-kurz" })} m²</span></label></div>
|
||||
<p class="hinweis-k">Beim Anlegen am ${dat(a.saetze?.stand) || dat(a.datum)} aus den Einstellungen übernommen, hier je Angebot änderbar.</p>`;
|
||||
<p class="hinweis-k">${v ? `Stundensätze aus „${esc(v.name)}“ (gilt ab ${dat(v.gilt_ab)}), Vollkosten: der Lohnzuschlag enthält nur noch, was du dazuschlagen willst; Wagnis und Gewinn kommen oben dazu.`
|
||||
: `Beim Anlegen am ${dat(a.saetze?.stand) || dat(a.datum)} aus den Einstellungen übernommen.`} Hier je Angebot änderbar.</p>`;
|
||||
}
|
||||
|
||||
/** A36: gelten heute andere Stundensätze, fragt das Angebot, ob es sie übernehmen soll */
|
||||
const SAETZE_SO_LASSEN = new Set<string>();
|
||||
function neueSaetzeHtml(d: Zeile): string {
|
||||
const n = d.neue_stundensaetze;
|
||||
if (!n || SAETZE_SO_LASSEN.has(`${d.angebot.id}:${n.stundensatz_version.id}`)) return "";
|
||||
const alt = d.saetze.stundensaetze as Record<string, number>;
|
||||
const wichtig = (n.lohnarten as { id: string; name: string }[]).filter((x) => alt[x.id] !== n.stundensaetze[x.id])
|
||||
.sort((a, b) => Number(b.id === "mittellohn") - Number(a.id === "mittellohn") || Number(alt[b.id] != null) - Number(alt[a.id] != null)).slice(0, 3)
|
||||
.map((x) => `${esc(x.name)} ${betrag(n.stundensaetze[x.id])} €${alt[x.id] != null ? ` statt ${betrag(alt[x.id]!)} €` : ""}`).join(", ");
|
||||
return `<div class="hinweis-band neue-saetze" role="status"><span>Seit ${dat(n.stundensatz_version.gilt_ab)} gelten neue Stundensätze („${esc(n.stundensatz_version.name)}“)${wichtig ? `: ${wichtig}` : ""}.
|
||||
${d.saetze.stundensatz_version ? "" : " Der Lohnzuschlag wird dann 0 %, weil der Satz die Gemeinkosten schon enthält."}</span>
|
||||
<button class="haupt" data-a="saetze-neu">Übernehmen</button><button class="neben" data-a="saetze-alt">So lassen</button></div>`;
|
||||
}
|
||||
|
||||
const pruefungListe = (d: Zeile) => (d.pruefung.length
|
||||
@@ -1063,7 +1081,7 @@ function titelleiste(d: Zeile, meldung: string): string {
|
||||
return `<div class="kopf angebot-kopf am-kopf"><a class="neben zurueck" href="#projekt-${a.projekt_id}-dokumente" aria-label="Zurück zum Projekt">←</a>
|
||||
<h1>${esc(BELEGART[a.belegart])} <span class="nummer">${esc(a.nummer)} · ${esc(a.projekt_name)}</span></h1>${angebotMarke(a)}
|
||||
<span class="kopf-knoepfe">${menue([["version", "", "Neue Version (Kopie)"], ...(a.status !== "angenommen" ? [["loeschen", "", "Löschen"] as [string, string, string]] : [])])}${knoepfe}</span></div>
|
||||
${meldung ? `<div class="${meldung.startsWith("! ") ? "warnung" : "erfolg"}" role="status">${esc(meldung.replace(/^! /, ""))}</div>` : ""}`;
|
||||
${meldung ? `<div class="${meldung.startsWith("! ") ? "warnung" : "erfolg"}" role="status">${esc(meldung.replace(/^! /, ""))}</div>` : ""}${neueSaetzeHtml(d)}`;
|
||||
}
|
||||
|
||||
/** Briefkopf wie im Ausdruck: Empfänger, Datum, Bindefrist, Betreff, Leistungsort, Einleitung */
|
||||
|
||||
@@ -890,7 +890,7 @@ async function daten(): Promise<void> {
|
||||
const kalkFelder: Feld[] = [
|
||||
{ name: "planer", titel: "Stundensatz Planer (EK je Stunde)", art: "euro" },
|
||||
{ name: "geselle", titel: "Stundensatz Geselle (EK je Stunde)", art: "euro" },
|
||||
{ name: "helfer", titel: "Stundensatz Helfer (EK je Stunde)", art: "euro", hilfe: "Gilt für neue Angebote. Die genauen Sätze kommen aus deiner Stundensatz-Tabelle." },
|
||||
{ name: "helfer", titel: "Stundensatz Helfer (EK je Stunde)", art: "euro", hilfe: "Nur solange unter Personal → Stundensätze keine Version gilt; dann kommen die Sätze von dort und der Lohnzuschlag neuer Angebote ist 0 %." },
|
||||
{ name: "z_lohn", titel: "Zuschlag Lohn (%)", art: "zahl" }, { name: "z_material", titel: "Zuschlag Material (%)", art: "zahl" },
|
||||
{ name: "z_geraet", titel: "Zuschlag Gerät (%)", art: "zahl" }, { name: "z_subunternehmer", titel: "Zuschlag Subunternehmer (%)", art: "zahl" },
|
||||
{ name: "z_fahrt", titel: "Zuschlag Fahrt (%)", art: "zahl" }, { name: "z_sonstiges", titel: "Zuschlag Sonstiges (%)", art: "zahl" },
|
||||
@@ -1121,7 +1121,7 @@ async function zeige(): Promise<void> {
|
||||
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 personalTeil = /^personal-(kolonnen|subunternehmer|urlaub|zeiten|stundensaetze)$/.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;
|
||||
@@ -1173,6 +1173,7 @@ async function start(): Promise<void> {
|
||||
sitzung = s;
|
||||
abgemeldet.melden = () => { location.hash = ""; location.reload(); };
|
||||
document.body.classList.toggle("rolle-mitarbeiter", s.benutzer.rolle === "mitarbeiter");
|
||||
document.body.classList.toggle("rolle-inhaber", s.benutzer.rolle === "inhaber");
|
||||
REITER = reiterFuer(s);
|
||||
nav.innerHTML = REITER.map(([id, titel]) => `<button data-r="${id}">${symbol(id)}<span>${titel}</span></button>`).join("");
|
||||
werLeiste(s);
|
||||
|
||||
@@ -6,7 +6,7 @@ import { benenneUm, FUNKTIONEN, zahlDeutsch } from "../domain/formel.js";
|
||||
import { type Auswertung, type Blatt, alsBlatt, werteBlatt } from "../domain/mengenblatt.js";
|
||||
import { type Ansatz, type Mengenvorlage } from "../domain/mengenvorlagen.js";
|
||||
import { formatEuro, parseEuro } from "../domain/geld.js";
|
||||
import { KOSTENARTEN, KOSTENART_NAME, LOHNARTEN, LOHNART_NAME, umgebungVon } from "../domain/kalkulation.js";
|
||||
import { KOSTENARTEN, KOSTENART_NAME, VORLAGE_LOHNARTEN, lohnartOptionen, umgebungVon } from "../domain/kalkulation.js";
|
||||
import { type Zeile, api, bestaetigen, dialog, esc, hinweis, inhalt, istHandy, optionenHtml } from "./ui.js";
|
||||
|
||||
export const zahlText = (v: unknown) => (v === null || v === undefined || v === "" ? "" : String(Number(v)).replace(".", ","));
|
||||
@@ -284,7 +284,7 @@ function ansaetzeHtml(v: Mengenvorlage, a: Auswertung, frei: boolean): string {
|
||||
} catch (e) { fehler = (e as Error).message; }
|
||||
const k = (f: string) => `vb:ansaetze.${i}.${f}`;
|
||||
return `<tr class="kz-${z.kostenart}${z.aktiv === false ? " aus" : ""}"><td><select data-k="${k("kostenart")}" data-typ="roh" aria-label="Art"${frei ? "" : " disabled"}>${optionenHtml(ANSATZ_ARTEN, z.kostenart)}</select></td>
|
||||
<td class="kz-text">${lohn ? `<select data-k="${k("lohnart")}" data-typ="roh" aria-label="Lohnart"${frei ? "" : " disabled"}>${optionenHtml(LOHNARTEN.map((x) => [x, LOHNART_NAME[x]]), z.lohnart ?? "geselle")}</select>` : ""}${feld(k("beschreibung"), z.beschreibung, { titel: "Tätigkeit / Material", frei, platz: lohn ? "Tätigkeit" : "Material" })}</td>
|
||||
<td class="kz-text">${lohn ? `<select data-k="${k("lohnart")}" data-typ="roh" aria-label="Lohnart"${frei ? "" : " disabled"}>${optionenHtml(lohnartOptionen(VORLAGE_LOHNARTEN, z.lohnart), z.lohnart ?? "geselle")}</select>` : ""}${feld(k("beschreibung"), z.beschreibung, { titel: "Tätigkeit / Material", frei, platz: lohn ? "Tätigkeit" : "Material" })}</td>
|
||||
<td>${feld(k("bezug"), z.bezug, { klasse: "am-formel", titel: "Bezug", frei, platz: "Menge", liste: "am-kuerzel", fehler })}</td>
|
||||
<td>${feld(k("menge"), zahlText(z.menge), { klasse: "am-eingabe zahl w-menge", titel: lohn ? "Std je Einheit des Bezugs" : "Menge je Einheit des Bezugs", frei })}</td>
|
||||
<td>${lohn ? feld(k("personen"), zahlText(z.personen ?? 1), { klasse: "am-eingabe zahl w-kurz", titel: "Personen", frei }) : feld(k("faktor"), zahlText(z.faktor ?? 1), { klasse: "zahl w-kurz", titel: "Faktor", frei })}</td>
|
||||
|
||||
@@ -7,6 +7,7 @@ import { ABWESENHEIT_TEXT, modellText, type AbwesenheitArt } from "../domain/per
|
||||
import { type Feld, type Zeile, api, dat, dialog, esc, heute, inhalt, seite } from "./ui.js";
|
||||
import { liste as tabelle } from "./liste.js";
|
||||
import { entscheiden } from "./urlaub.js";
|
||||
import { stundensaetzeTeil } from "./stundensaetze.js";
|
||||
|
||||
const WT = ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"];
|
||||
const zahl = (h: number | null | undefined) => (h == null ? "" : String(Math.round(h * 100) / 100).replace(".", ","));
|
||||
@@ -26,10 +27,17 @@ function heuteText(t: Zeile | undefined): string {
|
||||
return `${zahl(t.soll)} Std.`;
|
||||
}
|
||||
|
||||
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"]];
|
||||
// Rolle = Lohnart der Stundensätze (M17): die Tabellen der heute geltenden Version, sonst Planer, Geselle, Helfer
|
||||
const FUNKTION: Record<string, string> = { chef: "Chef", planer: "Planer", geselle: "Geselle", helfer: "Helfer" };
|
||||
let FUNKTIONEN = Object.entries(FUNKTION).filter(([k]) => k !== "chef") as [string, string][];
|
||||
async function rollenLaden(): Promise<void> {
|
||||
const l = await api<{ id: string; name: string }[]>("lohnarten").catch(() => null);
|
||||
if (!l) return;
|
||||
for (const x of l) FUNKTION[x.id] = x.name;
|
||||
FUNKTIONEN = l.map((x) => [x.id, x.name]);
|
||||
}
|
||||
// Personal mit Reitern wie die Projektseite (Henning, 20.10.2026); Stundensätze nur für den Inhaber (U2)
|
||||
const TEILE: [string, string][] = [["mitarbeiter", "Mitarbeiter"], ["kolonnen", "Kolonnen"], ["subunternehmer", "Subunternehmer"], ["urlaub", "Urlaub"], ["zeiten", "Zeiten"], ["stundensaetze", "Stundensätze"]];
|
||||
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) */
|
||||
@@ -38,7 +46,8 @@ const tagesStunden = (stunden: number[] | undefined, vorgabe: number) => (stunde
|
||||
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>`;
|
||||
const inhaber = document.body.classList.contains("rolle-inhaber");
|
||||
kopf.innerHTML = `<nav class="teile">${TEILE.filter(([t]) => inhaber || t !== "stundensaetze").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}`;
|
||||
@@ -58,7 +67,9 @@ export async function personalSeite(teil = "mitarbeiter"): Promise<void> {
|
||||
if (teil === "subunternehmer") return subunternehmerTeil();
|
||||
if (teil === "urlaub") return urlaubTeil();
|
||||
if (teil === "zeiten") return zeitenTeil();
|
||||
const [liste, tp, kolonnen, mitglieder] = await Promise.all([
|
||||
if (teil === "stundensaetze") return stundensaetzeTeil(teileLeiste);
|
||||
const [, liste, tp, kolonnen, mitglieder] = await Promise.all([
|
||||
rollenLaden(),
|
||||
api<Zeile[]>(`personal?heute=${heute()}`), api<Zeile>("terminplan"), api<Zeile[]>("kolonnen"), api<Zeile[]>("kolonnen-mitglieder"),
|
||||
]);
|
||||
seite("Personal", { text: "Neuer Mitarbeiter", aktion: neuerMitarbeiter });
|
||||
@@ -485,6 +496,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);
|
||||
await rollenLaden();
|
||||
const [kontakt, liste, alleStamm, modelle, abw, konten, verf, kolonnen, mitglieder] = await Promise.all([
|
||||
api<Zeile>(`kontakte/${kontaktId}`),
|
||||
api<Zeile[]>(`personal?heute=${heute()}`),
|
||||
|
||||
@@ -5,7 +5,7 @@
|
||||
import { type Auswertung, alsBlatt, werteBlatt } from "../domain/mengenblatt.js";
|
||||
import type { Ansatz, Mengenvorlage } from "../domain/mengenvorlagen.js";
|
||||
import { formatEuro, parseEuro } from "../domain/geld.js";
|
||||
import { KOSTENARTEN, KOSTENART_NAME, LOHNARTEN, LOHNART_NAME, umgebungVon } from "../domain/kalkulation.js";
|
||||
import { KOSTENARTEN, KOSTENART_NAME, lohnartOptionen, lohnartenVon, umgebungVon } from "../domain/kalkulation.js";
|
||||
import { zahlDeutsch } from "../domain/formel.js";
|
||||
import { dateiText } from "../domain/kodierung.js";
|
||||
import { type Datanorm, ekNetto, leseDatanorm } from "../domain/datanorm.js";
|
||||
@@ -269,7 +269,7 @@ export async function leistungSeite(id: string): Promise<void> {
|
||||
<td>${feld(k("bezug"), z.bezug, { titel: fahrt ? "Strecke einfach in km" : "Bezug (Kürzel aus dem Mengenblatt, leer = je Einheit)", klasse: `am-formel w-bezug${r?.fehler ? " mit-fehler" : ""}`, platz: fahrt ? "km" : `je ${einheit}`, liste: "sd-kuerzel" })}${r?.fehler ? `<span class="am-fehler">${esc(r.fehler)}</span>` : ""}</td>
|
||||
<td>${feld(k("menge"), zahlText(z.menge), { titel: lohn ? "Std je Einheit" : fahrt ? "Einsatztage" : "Menge je Einheit", klasse: "zahl w-ansatz am-eingabe", typ: "zahl" })}</td>
|
||||
<td>${mitPers ? feld(k("personen"), zahlText(z.personen ?? 1), { titel: fahrt ? "Fahrzeuge" : "Personen", klasse: "zahl w-pers am-eingabe", typ: "zahl" }) : ""}</td>
|
||||
<td>${lohn ? `<select data-k="${k("lohnart")}" aria-label="Lohnart"${frei ? "" : " disabled"}>${optionenHtml(LOHNARTEN.map((x) => [x, LOHNART_NAME[x]]), z.lohnart ?? "geselle")}</select>`
|
||||
<td>${lohn ? `<select data-k="${k("lohnart")}" aria-label="Lohnart"${frei ? "" : " disabled"}>${optionenHtml(lohnartOptionen(lohnartenVon(s), z.lohnart), z.lohnart ?? "geselle")}</select>`
|
||||
: fahrt ? "km" : feld(k("einheit"), z.einheit, { titel: "Einheit", klasse: "w-einheit", liste: "sd-einheiten" })}</td>
|
||||
<td>${feld(k("ek"), z.artikel_id ? euroFeld(art?.ek_je_einheit ?? z.ek) : euroFeld(z.ek), { titel: z.artikel_id ? "EK aus dem Materialstamm (ändern löst den Artikel)" : "EK je Einheit", klasse: "zahl w-ek", typ: "euro",
|
||||
platz: lohn ? euroFeld(s.stundensaetze[z.lohnart ?? "geselle"]) : fahrt ? euroFeld(s.kilometersatz ?? 50) : "0,00" })}</td>
|
||||
|
||||
404
src/web/stundensaetze.ts
Normal file
404
src/web/stundensaetze.ts
Normal file
@@ -0,0 +1,404 @@
|
||||
// Personal → Stundensätze (M15–M19, Henning 22.10.2026, Entwurf angebote/stundensaetze/entwurf): links die
|
||||
// Rechentabellen je Lohnart mit ihrem Satz und „+ Tabelle hinzufügen“, rechts die geöffnete Tabelle wie Hennings
|
||||
// Excel-Blatt (1 Zeit, 2 Kosten, 3 Stundensatz), darunter der Mittellohn mit Schaltern je Lohnart.
|
||||
// Versionen mit „gilt ab“: ein Angebot nimmt die Version, die an seinem Datum gilt, und schreibt die Sätze fest.
|
||||
// Nur für den Inhaber (Löhne, U2).
|
||||
|
||||
import { type Zeile, api, bestaetigen, dat, dialog, esc, heute, huelle, inhalt, lies, merke } from "./ui.js";
|
||||
import { formatEuro, parseEuro } from "../domain/geld.js";
|
||||
import { feiertageSH } from "../domain/kalender.js";
|
||||
import { plusTage, wochentag } from "../domain/datum.js";
|
||||
import { BLOCK_NAME, BLOECKE, type Block, KOSTENARTEN_S, KOSTENART_S_NAME, type Kostenzeile, type Rechentabelle, type StundensatzDaten, type StundensatzErgebnis,
|
||||
type TabellenErgebnis, type Umfeld, rechneStundensaetze, schluesselFuer } from "../domain/stundensatz.js";
|
||||
|
||||
interface Version { id: string; name: string; gilt_ab: string; daten: StundensatzDaten }
|
||||
type UmfeldMitListe = Umfeld & { liste: { id: string; bezeichnung: string; kategorie: string | null; jahr: number }[] };
|
||||
|
||||
let d: Zeile;
|
||||
let versionen: Version[] = [];
|
||||
let v: Version | null = null;
|
||||
let offen: string | null = null;
|
||||
let speichernNach: ReturnType<typeof setTimeout> | undefined;
|
||||
let teile: (aktiv: string) => void = () => {};
|
||||
|
||||
const zahl = (n: number, stellen = 2) => (Number.isFinite(n) ? n.toLocaleString("de-DE", { maximumFractionDigits: stellen }) : "–");
|
||||
const eur = (c: number) => (Number.isFinite(c) ? formatEuro(Math.round(c)) : "–");
|
||||
const eurWert = (c: number | undefined) => (c ? formatEuro(c, false) : "");
|
||||
const zahlWert = (n: number | undefined | null) => (n == null ? "" : n.toLocaleString("de-DE", { maximumFractionDigits: 4, useGrouping: false }));
|
||||
const neueId = () => `n${Date.now().toString(36)}${Math.random().toString(36).slice(2, 5)}`;
|
||||
const leseZahl = (t: string) => {
|
||||
const s = t.trim().replace(/\./g, "").replace(",", ".");
|
||||
if (!s) return 0;
|
||||
const n = Number(s);
|
||||
if (!Number.isFinite(n) || n < 0) throw new Error("Bitte eine Zahl eingeben.");
|
||||
return n;
|
||||
};
|
||||
|
||||
const umfeld = (): UmfeldMitListe => d.umfeld[Number(v!.gilt_ab.slice(0, 4))] ?? d.umfeld[Number(heute().slice(0, 4))];
|
||||
const rechne = (): StundensatzErgebnis => rechneStundensaetze(v!.daten, umfeld());
|
||||
const tabelle = (): Rechentabelle => v!.daten.tabellen.find((t) => t.id === offen) ?? v!.daten.tabellen[0]!;
|
||||
|
||||
export async function stundensaetzeTeil(kopf: (aktiv: string) => void): Promise<void> {
|
||||
teile = kopf;
|
||||
d = await api<Zeile>("stundensaetze");
|
||||
versionen = d.versionen;
|
||||
v = versionen.find((x) => x.id === lies("ss-version")) ?? versionen.find((x) => x.id === d.gilt) ?? versionen[versionen.length - 1] ?? null;
|
||||
inhalt.innerHTML = '<div class="kopf"><h1>Personal</h1></div>';
|
||||
teile("stundensaetze");
|
||||
if (!v) return leerZeigen();
|
||||
if (!v.daten.tabellen.some((t) => t.id === offen)) offen = lies("ss-tabelle") && v.daten.tabellen.some((t) => t.id === lies("ss-tabelle")) ? lies("ss-tabelle") : v.daten.tabellen[0]!.id;
|
||||
const leiste = document.createElement("div");
|
||||
leiste.className = "leiste ss-leiste";
|
||||
inhalt.append(leiste);
|
||||
leiste.innerHTML = `<div class="jp-versionen" role="group" aria-label="Version"><span class="hinweis">Version:</span>${versionen.map((x) =>
|
||||
`<button class="chip-knopf${x.id === v?.id ? " an" : ""}" data-version="${x.id}" aria-pressed="${x.id === v?.id}">${esc(x.name)} <small>ab ${dat(x.gilt_ab)}</small>${x.id === d.gilt ? ' <span class="jp-gilt">gilt heute</span>' : ""}</button>`).join("")}
|
||||
<button class="chip-knopf" data-a="neue-version" title="Kopie dieser Version mit eigenem „gilt ab“">+ neue Version</button>
|
||||
<button class="verweis" data-a="version-bearbeiten" aria-label="Version umbenennen, Datum ändern oder löschen">⋯</button></div>
|
||||
<span class="hinweis ss-gespeichert" aria-live="polite"></span>`;
|
||||
leiste.onclick = (ev) => void leisteKlick(ev);
|
||||
const raster = document.createElement("div");
|
||||
raster.className = "ss-raster";
|
||||
inhalt.append(raster);
|
||||
zeichne();
|
||||
}
|
||||
|
||||
function leerZeigen(): void {
|
||||
const k = document.createElement("section");
|
||||
k.className = "karte ss-leer";
|
||||
k.innerHTML = `<h2>Noch keine Stundensätze</h2>
|
||||
<p>Das Programm rechnet je Lohnart wie deine Excel-Tabelle: Zeit, Kosten, Stundensatz. Am einfachsten beginnst du mit deiner Excel vom 26.05.2026.</p>
|
||||
<p class="hinweis">Es entstehen zwei Versionen: <b>genau deine Excel</b> (Chef 80,38 €, Planer 107,81 €) und <b>ab heute</b> die Fassung nach unserer Absprache: Akquise und Verwaltung zählen als Kosten zum Lohnkostensatz des Gesellen statt als Zeitabzug. Geselle und Helfer starten als Kopie von Chef.</p>
|
||||
<div class="knoepfe-links"><button class="haupt" data-a="excel">Mit meiner Excel beginnen</button></div>`;
|
||||
inhalt.append(k);
|
||||
k.querySelector<HTMLElement>('[data-a="excel"]')!.onclick = async () => {
|
||||
const neu = await api<Version>("stundensaetze/excel", "POST");
|
||||
merke("ss-version", neu.id);
|
||||
void stundensaetzeTeil(teile);
|
||||
};
|
||||
}
|
||||
|
||||
async function leisteKlick(ev: Event): Promise<void> {
|
||||
const b = (ev.target as HTMLElement).closest<HTMLElement>("[data-version], [data-a]");
|
||||
if (!b || !v) return;
|
||||
await speichernJetzt();
|
||||
if (b.dataset.version) { merke("ss-version", b.dataset.version); return stundensaetzeTeil(teile); }
|
||||
if (b.dataset.a === "neue-version") {
|
||||
const vorschlag = (() => { let t = heute(); while (versionen.some((x) => x.gilt_ab === t)) t = plusTage(t, 1); return t; })();
|
||||
const e = await dialog("Neue Version", [
|
||||
{ name: "name", titel: "Name", pflicht: true, hilfe: "z. B. „Lohnerhöhung 2027“" },
|
||||
{ name: "gilt_ab", titel: "Gilt ab", art: "datum", pflicht: true, hilfe: "Angebote ab diesem Tag bekommen diese Sätze. Ältere Angebote behalten ihre." },
|
||||
], { name: `Version ${versionen.length + 1}`, gilt_ab: vorschlag }, false);
|
||||
if (e?.aktion !== "speichern") return;
|
||||
const neu = await api<Version>("stundensaetze", "POST", { name: e.daten.name, gilt_ab: e.daten.gilt_ab, daten: v.daten });
|
||||
merke("ss-version", neu.id);
|
||||
return stundensaetzeTeil(teile);
|
||||
}
|
||||
if (b.dataset.a === "version-bearbeiten") {
|
||||
const e = await dialog("Version bearbeiten", [
|
||||
{ name: "name", titel: "Name", pflicht: true }, { name: "gilt_ab", titel: "Gilt ab", art: "datum", pflicht: true },
|
||||
], { name: v.name, gilt_ab: v.gilt_ab }, versionen.length > 1);
|
||||
if (!e) return;
|
||||
if (e.aktion === "loeschen") { await api(`stundensaetze/${v.id}`, "DELETE"); merke("ss-version", null); }
|
||||
else await api(`stundensaetze/${v.id}`, "PATCH", { name: e.daten.name, gilt_ab: e.daten.gilt_ab });
|
||||
return stundensaetzeTeil(teile);
|
||||
}
|
||||
}
|
||||
|
||||
// ---------- Zeichnen ----------
|
||||
|
||||
/** Werte, die sich beim Tippen ändern: data-w="…" */
|
||||
function werte(e: StundensatzErgebnis): Record<string, string> {
|
||||
const w: Record<string, string> = {};
|
||||
for (const t of e.tabellen) w[`l.${t.id}`] = eur(t.satz);
|
||||
w["ml.satz"] = e.mittellohn.satz == null ? "–" : eur(e.mittellohn.satz);
|
||||
w["ml.lohn"] = e.mittellohn.lohnkostensatz == null ? "–" : eur(e.mittellohn.lohnkostensatz);
|
||||
w["ml.personen"] = zahl(e.mittellohn.personen);
|
||||
w["ml.std"] = zahl(e.mittellohn.std, 0);
|
||||
for (const z of e.mittellohn.zeilen) { w[`ml.${z.id}.std`] = zahl(z.std, 0); w[`ml.${z.id}.satz`] = eur(z.satz); }
|
||||
w["ub.jahr"] = eur(e.umsatzbedarf.jahr); w["ub.monat"] = eur(e.umsatzbedarf.monat);
|
||||
w["bewertung"] = eur(e.bewertungssatz);
|
||||
w["koepfe"] = zahl(e.koepfe);
|
||||
const t = e.tabellen.find((x) => x.id === tabelle().id)!;
|
||||
const z = t.zeit;
|
||||
Object.assign(w, {
|
||||
"z.brutto": zahl(z.bruttoStd), "z.feiertage": `−${zahl(z.feiertageStd)}`, "z.jahresStd": zahl(z.jahresStd), "z.jahresTage": zahl(z.jahresTage),
|
||||
"z.ausfallStd": `−${zahl(z.ausfallStd)}`, "z.ausfallTage": `−${zahl(z.ausfallTage)}`, "z.anwesend": zahl(z.anwesenheitTage),
|
||||
"z.produktiv": zahl(z.produktiv), "z.produktivTage": zahl(z.produktivTage), "z.tageJahr": zahl(tabelle().zeit.tageJahr), "z.feiertageTage": `−${zahl(tabelle().zeit.feiertage)}`,
|
||||
});
|
||||
for (const a of z.ausfall) { w[`a.${a.id}.std`] = `−${zahl(a.std)}`; w[`a.${a.id}.tage`] = `−${zahl(a.tage)}`; }
|
||||
for (const u of z.unproduktiv) { w[`u.${u.id}.std`] = u.als === "zeit" ? `−${zahl(u.std)}` : zahl(u.std); w[`u.${u.id}.tage`] = u.als === "zeit" ? `−${zahl(u.tage)}` : "→ Kosten"; }
|
||||
for (const k of t.zeilen) {
|
||||
w[`k.${k.id}.jahr`] = eur(k.jahr); w[`k.${k.id}.monat`] = eur(k.monat); w[`k.${k.id}.std`] = eur(k.jeStd); w[`k.${k.id}.anteil`] = `${zahl(k.anteil, 1)} %`;
|
||||
w[`k.${k.id}.rechnung`] = k.rechnung;
|
||||
}
|
||||
for (const b of t.bloecke) { w[`b.${b.block}.jahr`] = eur(b.bis); w[`b.${b.block}.monat`] = eur(b.bis / 12); w[`b.${b.block}.std`] = eur(b.bisJeStd); }
|
||||
Object.assign(w, {
|
||||
"t.gewinn": eur(t.gewinn), "t.summe": eur(t.summe), "t.summeMonat": eur(t.summe / 12), "t.satz": eur(t.satz), "t.lohnkostensatz": eur(t.lohnkostensatz),
|
||||
"t.gemein": eur(t.gemeinkostenanteil), "t.umsatz": eur(t.umsatzbedarf), "t.umsatzMonat": eur(t.umsatzbedarf / 12), "t.name": t.name,
|
||||
});
|
||||
return w;
|
||||
}
|
||||
|
||||
let W: Record<string, string> = {};
|
||||
const w = (k: string, klasse = "") => `<span data-w="${k}"${klasse ? ` class="${klasse}"` : ""}>${esc(W[k] ?? "")}</span>`;
|
||||
const ein = (f: string, wert: string, o: { t?: string; klasse?: string; titel: string; platz?: string } ) =>
|
||||
`<input data-f="${f}" data-t="${o.t ?? "zahl"}" value="${esc(wert)}" class="${o.klasse ?? "zahl w-kurz"}" aria-label="${esc(o.titel)}" title="${esc(o.titel)}"${o.platz ? ` placeholder="${esc(o.platz)}"` : ""}${o.t === "text" ? "" : ' inputmode="decimal"'}>`;
|
||||
const wahl = (f: string, optionen: [string, string][], wert: string, titel: string) =>
|
||||
`<select data-f="${f}" data-t="text" aria-label="${esc(titel)}">${optionen.map(([x, t]) => `<option value="${esc(x)}"${x === wert ? " selected" : ""}>${esc(t)}</option>`).join("")}</select>`;
|
||||
|
||||
function zeichne(): void {
|
||||
const raster = inhalt.querySelector<HTMLElement>(".ss-raster")!;
|
||||
const e = rechne();
|
||||
W = werte(e);
|
||||
const t = tabelle(), te = e.tabellen.find((x) => x.id === t.id)!;
|
||||
raster.innerHTML = `<aside class="karte ss-links">${linksHtml(e)}</aside>
|
||||
<div class="ss-rechts"><section class="karte ss-tabelle">${tabelleHtml(t, te, e)}</section>
|
||||
<section class="karte ss-mittellohn">${mittellohnHtml(e)}</section>
|
||||
<section class="karte ss-angebot"><h2>So kommt es ins Angebot</h2>
|
||||
<p>In der Kalkulation einer Position wählst du bei Lohn: <b>Mittellohn</b> · ${v!.daten.tabellen.map((x) => esc(x.name)).join(" · ")}. Der Satz ist der Vollkostensatz und geht als Lohn-EK ins Angebot; der Lohnzuschlag neuer Angebote ist deshalb 0 %, Wagnis und Gewinn kommen wie bisher je Angebot dazu.</p>
|
||||
<p class="hinweis">Ein Angebot schreibt die Sätze beim Anlegen fest. Gilt später eine neue Version, fragt der Entwurf, ob er sie übernehmen soll.</p></section></div>`;
|
||||
verbinden(raster);
|
||||
}
|
||||
|
||||
function linksHtml(e: StundensatzErgebnis): string {
|
||||
return `<h2>Rechentabellen</h2><div class="ss-liste" role="list">${e.tabellen.map((t) =>
|
||||
`<button role="listitem" class="ss-eintrag${t.id === tabelle().id ? " an" : ""}" data-tab="${t.id}" aria-current="${t.id === tabelle().id}"><span>${esc(t.name)}</span><b>${w(`l.${t.id}`)}</b></button>`).join("")}</div>
|
||||
<button class="ss-neu" data-a="tabelle-neu">+ Tabelle hinzufügen<small>z. B. Vorarbeiter, Azubi</small></button>
|
||||
<h2 class="ss-abstand">Ergebnis</h2>
|
||||
<div class="ss-ergebnis"><span>Mittellohn</span><b>${w("ml.satz")}</b></div>
|
||||
<div class="ss-ergebnis klein"><span>Umsatzbedarf im Jahr</span><b>${w("ub.jahr")}</b></div>
|
||||
<div class="ss-ergebnis klein"><span>je Monat</span><b>${w("ub.monat")}</b></div>
|
||||
<p class="hinweis">Jede Tabelle ist aufgebaut wie dein Excel-Blatt; eine neue startet als Kopie einer vorhandenen.</p>`;
|
||||
}
|
||||
|
||||
function tabelleHtml(t: Rechentabelle, te: TabellenErgebnis, e: StundensatzErgebnis): string {
|
||||
const z = t.zeit;
|
||||
const kal = kalender(Number(v!.gilt_ab.slice(0, 4)));
|
||||
const ausfall = z.ausfall.map((a) => `<tr><td>${ein(`a.${a.id}.name`, a.name, { t: "text", klasse: "ss-name", titel: "Bezeichnung" })}</td>
|
||||
<td>${ein(`a.${a.id}.tage`, zahlWert(a.tage), { titel: `${a.name}: Tage im Jahr` })} Tage/Jahr</td><td class="zahl">${w(`a.${a.id}.std`)}</td><td class="zahl">${w(`a.${a.id}.tage`)}</td>
|
||||
<td><button class="verweis ss-weg" data-weg="a.${a.id}" aria-label="${esc(a.name)} entfernen">×</button></td></tr>`).join("");
|
||||
const unprod = z.unproduktiv.map((u) => `<tr class="${u.als === "kosten" ? "ss-als-kosten" : ""}"><td>${ein(`u.${u.id}.name`, u.name, { t: "text", klasse: "ss-name", titel: "Bezeichnung" })}</td>
|
||||
<td><span class="ss-ansatz">${ein(`u.${u.id}.stunden`, zahlWert(u.stunden), { titel: `${u.name}: Stunden` })} Std ${wahl(`u.${u.id}.je`, [["monat", "je Monat"], ["tag", "je Tag"]], u.je, "Stunden je Monat oder je Arbeitstag")}
|
||||
${wahl(`u.${u.id}.als`, [["zeit", "als Zeit abziehen"], ["kosten", "als Kosten ansetzen"]], u.als, "Als Zeit abziehen oder als Kosten ansetzen")}</span></td>
|
||||
<td class="zahl">${w(`u.${u.id}.std`)}</td><td class="zahl">${w(`u.${u.id}.tage`)}</td>
|
||||
<td><button class="verweis ss-weg" data-weg="u.${u.id}" aria-label="${esc(u.name)} entfernen">×</button></td></tr>`).join("");
|
||||
const kosten = BLOECKE.map((b) => {
|
||||
const zeilen = te.zeilen.filter((x) => x.block === b).map((x) => {
|
||||
const k = t.kosten.find((y) => y.id === x.id);
|
||||
if (!k) return `<tr class="ss-auszeit"><td>${esc(x.name)}</td><td class="hinweis">${w(`k.${x.id}.rechnung`)} <small>(aus 1 Zeit)</small></td>
|
||||
<td class="zahl">${w(`k.${x.id}.jahr`)}</td><td class="zahl optional">${w(`k.${x.id}.monat`)}</td><td class="zahl">${w(`k.${x.id}.std`)}</td><td class="zahl optional">${w(`k.${x.id}.anteil`)}</td><td></td></tr>`;
|
||||
return `<tr><td>${ein(`k.${k.id}.name`, k.name, { t: "text", klasse: "ss-name", titel: "Bezeichnung" })}</td><td>${ansatzHtml(k)}</td>
|
||||
<td class="zahl">${w(`k.${k.id}.jahr`)}</td><td class="zahl optional">${w(`k.${k.id}.monat`)}</td><td class="zahl">${w(`k.${k.id}.std`)}</td><td class="zahl optional">${w(`k.${k.id}.anteil`)}</td>
|
||||
<td><button class="verweis ss-weg" data-weg="k.${k.id}" aria-label="${esc(k.name)} entfernen">×</button></td></tr>`;
|
||||
}).join("");
|
||||
return `<tr class="ss-block"><th colspan="7">${b} ${esc(BLOCK_NAME[b])}</th></tr>${zeilen}
|
||||
<tr><td colspan="7"><button class="verweis" data-neu-kosten="${b}">+ Kostenzeile</button></td></tr>
|
||||
<tr class="ss-zwischen"><td>Zwischensumme ${b}</td><td></td><td class="zahl">${w(`b.${b}.jahr`)}</td><td class="zahl optional">${w(`b.${b}.monat`)}</td><td class="zahl">${w(`b.${b}.std`)}</td><td class="optional"></td><td></td></tr>
|
||||
${b === 3 ? `<tr class="ss-info"><td colspan="4">= Lohnkosten je Std (ohne Betriebskosten)</td><td class="zahl">${w("t.lohnkostensatz")}</td><td colspan="2" class="optional"></td></tr>` : ""}`;
|
||||
}).join("");
|
||||
return `<div class="ss-kopf"><h2>Rechentabelle ${ein("t.name", t.name, { t: "text", klasse: "ss-titel", titel: "Name der Lohnart" })}</h2>
|
||||
${v!.daten.tabellen.length > 1 ? `<button class="neben" data-a="tabelle-weg">Tabelle löschen</button>` : ""}</div>
|
||||
${t.hinweis ? `<p class="hinweis ss-hinweis">${esc(t.hinweis)} <button class="verweis" data-a="hinweis-weg">erledigt</button></p>` : ""}
|
||||
<div class="ss-rolle"><table class="ss-t ss-zeit"><thead><tr><th>1 Zeit</th><th>Ansatz</th><th class="zahl">Std</th><th class="zahl">Tage</th><th></th></tr></thead><tbody>
|
||||
<tr><td>Arbeitstage im Jahr</td><td>${ein("z.tageJahr", zahlWert(z.tageJahr), { titel: "Arbeitstage im Jahr (5 Tage × 52 Wochen = 260)" })} Tage × ${ein("z.stundenTag", zahlWert(z.stundenTag), { titel: "Stunden je Tag" })} Std/Tag</td>
|
||||
<td class="zahl">${w("z.brutto")}</td><td class="zahl">${w("z.tageJahr")}</td><td></td></tr>
|
||||
<tr><td>− Feiertage SH</td><td>${ein("z.feiertage", zahlWert(z.feiertage), { titel: "Feiertage im Jahr" })} Tage
|
||||
<small class="hinweis" title="Werktage Mo–Fr und Feiertage, die auf Mo–Fr fallen">Kalender ${kal.jahr}: ${kal.werktage} Werktage, ${kal.feiertage} Feiertage auf Mo–Fr <button class="verweis" data-a="kalender">übernehmen</button></small></td>
|
||||
<td class="zahl">${w("z.feiertage")}</td><td class="zahl">${w("z.feiertageTage")}</td><td></td></tr>
|
||||
<tr class="ss-zwischen"><td>= Jahresarbeitszeit</td><td></td><td class="zahl">${w("z.jahresStd")}</td><td class="zahl">${w("z.jahresTage")}</td><td></td></tr>
|
||||
${ausfall}<tr><td colspan="5"><button class="verweis" data-a="ausfall-neu">+ Ausfallzeit</button></td></tr>
|
||||
<tr class="ss-zwischen"><td>= Anwesenheit</td><td></td><td class="zahl">${w("z.ausfallStd")}</td><td class="zahl">${w("z.anwesend")}</td><td></td></tr>
|
||||
${unprod}<tr><td colspan="5"><button class="verweis" data-a="unprod-neu">+ unproduktive Zeit</button></td></tr>
|
||||
<tr class="ss-ergebniszeile"><td><b>= produktive Stunden</b></td><td></td><td class="zahl"><b>${w("z.produktiv")}</b></td><td class="zahl">${w("z.produktivTage")}</td><td></td></tr>
|
||||
</tbody></table></div>
|
||||
<div class="ss-rolle"><table class="ss-t ss-kosten"><thead><tr><th>2 Kosten</th><th>Ansatz</th><th class="zahl">€ / Jahr</th><th class="zahl optional">€ / Monat</th><th class="zahl">€ / Std</th><th class="zahl optional">Anteil</th><th></th></tr></thead><tbody>
|
||||
${kosten}
|
||||
<tr><td>kalkulatorischer Gewinn</td><td>${ein("t.gewinn", zahlWert(t.gewinn), { titel: "Gewinn in % der Kosten" })} %</td><td class="zahl">${w("t.gewinn")}</td><td class="optional"></td><td></td><td class="optional"></td><td></td></tr>
|
||||
<tr class="ss-ergebniszeile"><td colspan="2"><b>3 Stundensatz ${w("t.name")} (Vollkosten)</b><small class="hinweis"> ${w("t.summe")} im Jahr ÷ ${w("z.produktiv")} produktive Std</small></td>
|
||||
<td class="zahl">${w("t.summe")}</td><td class="zahl optional">${w("t.summeMonat")}</td><td class="zahl ss-gross">${w("t.satz")}</td><td colspan="2" class="optional"></td></tr>
|
||||
<tr class="ss-info"><td colspan="4">davon Lohnkosten / Gemeinkostenanteil</td><td class="zahl">${w("t.lohnkostensatz")} / ${w("t.gemein")}</td><td colspan="2" class="optional"></td></tr>
|
||||
</tbody></table></div>
|
||||
<p class="ss-umsatz">Umsatzbedarf für eine Person: Lohnanteil am Umsatz ${ein("t.lohnanteil", zahlWert(t.lohnanteil), { titel: "Lohnanteil am Umsatz in %" })} %, davon Wagnis ${ein("t.wagnis", zahlWert(t.wagnis), { titel: "Wagnis in %" })} %
|
||||
→ <b>${w("t.umsatz")}</b> im Jahr, ${w("t.umsatzMonat")} im Monat</p>
|
||||
<p class="hinweis">Sachkosten „÷ Köpfe“ werden auf ${w("koepfe")} Köpfe verteilt (unten beim Mittellohn änderbar). Akquise und Verwaltung „als Kosten“ zählen mit ${w("bewertung")} je Std, dem Lohnkostensatz von ${esc(v!.daten.tabellen.find((x) => x.id === v!.daten.bewertung)?.name ?? "–")}.</p>`;
|
||||
}
|
||||
|
||||
function ansatzHtml(k: Kostenzeile): string {
|
||||
const f = (feld: string) => `k.${k.id}.${feld}`;
|
||||
const betrag = (titel: string) => `${ein(f("betrag"), eurWert(k.betrag), { t: "euro", klasse: "zahl w-euro", titel, platz: "0,00" })} €`;
|
||||
const werte = {
|
||||
netto: `${betrag("Monatslohn netto")} ÷ ${ein(f("faktor"), zahlWert(k.faktor ?? 1), { titel: "Faktor netto zu brutto (0,7)" })}`,
|
||||
monat: `${betrag("Betrag je Monat")} /Monat`,
|
||||
jahr: `${betrag("Betrag je Jahr")} /Jahr`,
|
||||
prozent: `${ein(f("prozent"), zahlWert(k.prozent ?? 0), { titel: "Prozent der Lohnsumme" })} %`,
|
||||
stunden: `${ein(f("stunden"), zahlWert(k.stunden ?? 0), { titel: "Stunden je Monat" })} Std × ${betrag("Euro je Stunde")}`,
|
||||
laufend: `<button class="neben klein" data-laufend="${k.id}">${(k.laufend ?? []).length ? `${(k.laufend ?? []).length} gewählt` : "wählen …"}</button>`,
|
||||
}[k.art];
|
||||
return `<div class="ss-ansatz">${wahl(f("art"), KOSTENARTEN_S.map((x) => [x, KOSTENART_S_NAME[x]]), k.art, "Art der Kosten")} ${werte}</div>
|
||||
<div class="ss-ansatz klein"><label><input type="checkbox" data-f="${f("koepfe")}" data-t="bool"${k.koepfe ? " checked" : ""}> ÷ Köpfe</label>
|
||||
<span>Anteil ${ein(f("anteil"), zahlWert(k.anteil ?? 100), { titel: "Anteil in %" })} %</span>
|
||||
${ein(f("notiz"), k.notiz ?? "", { t: "text", klasse: "ss-notiz", titel: "Notiz", platz: "Notiz" })}</div>
|
||||
<small class="hinweis">${w(`k.${k.id}.rechnung`)}</small>`;
|
||||
}
|
||||
|
||||
function mittellohnHtml(e: StundensatzErgebnis): string {
|
||||
const dv = v!.daten;
|
||||
const zeilen = e.mittellohn.zeilen.map((z) => {
|
||||
const m = dv.mittellohn[z.id];
|
||||
return `<tr class="${z.an ? "" : "aus"}"><td><label class="ss-schalter"><input type="checkbox" data-f="m.${z.id}.an" data-t="bool"${z.an ? " checked" : ""} aria-label="${esc(z.name)} im Mittellohn"><i></i></label></td>
|
||||
<td>${esc(z.name)}</td><td class="zahl">${ein(`m.${z.id}.personen`, zahlWert(m?.personen ?? null), { titel: `Personen ${z.name}`, platz: zahl(z.gezaehlt) })}</td>
|
||||
<td class="zahl">${w(`ml.${z.id}.std`)}</td><td class="zahl">${w(`ml.${z.id}.satz`)}</td></tr>`;
|
||||
}).join("");
|
||||
return `<h2>Mittellohn <small class="hinweis">für die Baustelle: wer mitarbeitet</small></h2>
|
||||
<div class="ss-rolle"><table class="ss-t"><thead><tr><th>mit</th><th>Lohnart</th><th class="zahl">Personen</th><th class="zahl">prod. Std/Jahr</th><th class="zahl">Satz € / Std</th></tr></thead><tbody>${zeilen}
|
||||
<tr class="ss-ergebniszeile"><td></td><td><b>Mittellohn</b> <small class="hinweis">gewichtet nach Stunden</small></td><td class="zahl">${w("ml.personen")}</td><td class="zahl">${w("ml.std")}</td><td class="zahl ss-gross">${w("ml.satz")}</td></tr>
|
||||
<tr class="ss-info"><td></td><td colspan="3">davon Lohnkosten ohne Gemeinkosten</td><td class="zahl">${w("ml.lohn")}</td></tr></tbody></table></div>
|
||||
<p class="hinweis">Der Schalter nimmt die Lohnart in den Mittellohn auf oder heraus. Personen zählt das Programm aus dem Personal (grau); eine Zahl hier gilt für die Planung. Inhaber ohne Rolle zählt als Chef, Angestellte ohne Rolle als Geselle.</p>
|
||||
<div class="ss-einstellungen"><label>Sachkosten „÷ Köpfe“ verteilen auf ${ein("v.koepfe", zahlWert(dv.koepfe), { titel: "Köpfe im Betrieb", platz: zahl(umfeld().koepfe) })} Köpfe</label>
|
||||
<label>Akquise und Verwaltung „als Kosten“ bewerten mit dem Lohnkostensatz von ${wahl("v.bewertung", dv.tabellen.map((t) => [t.id, t.name]), dv.bewertung, "Tabelle für die Bewertung")}</label></div>`;
|
||||
}
|
||||
|
||||
/** Werktage Mo–Fr und Feiertage SH auf Mo–Fr in einem Jahr */
|
||||
function kalender(jahr: number) {
|
||||
let werktage = 0;
|
||||
for (let t = `${jahr}-01-01`; t <= `${jahr}-12-31`; t = plusTage(t, 1)) if (wochentag(t) <= 5) werktage++;
|
||||
return { jahr, werktage, feiertage: feiertageSH(jahr).filter((f) => wochentag(f.datum) <= 5).length };
|
||||
}
|
||||
|
||||
// ---------- Eingaben ----------
|
||||
|
||||
function setze(feld: string, typ: string, roh: string | boolean): void {
|
||||
const dv = v!.daten, t = tabelle();
|
||||
const [art, id, name] = feld.split(".");
|
||||
const wert = typ === "bool" ? roh : typ === "text" ? String(roh) : typ === "euro" ? (String(roh).trim() ? parseEuro(String(roh)) : 0) : leseZahl(String(roh));
|
||||
if (typeof wert === "number" && wert < 0) throw new Error("Bitte keine negativen Zahlen.");
|
||||
const satz = (o: object, k: string, x: unknown) => { (o as Record<string, unknown>)[k] = x; };
|
||||
if (art === "t") satz(t, id!, id === "name" ? String(wert).trim() || t.name : wert);
|
||||
if (art === "z") satz(t.zeit, id!, wert);
|
||||
if (art === "a") { const a = t.zeit.ausfall.find((x) => x.id === id); if (a) satz(a, name!, wert); }
|
||||
if (art === "u") { const u = t.zeit.unproduktiv.find((x) => x.id === id); if (u) satz(u, name!, wert); }
|
||||
if (art === "k") {
|
||||
const k = t.kosten.find((x) => x.id === id);
|
||||
if (!k) return;
|
||||
if (name === "art") { k.art = wert as Kostenzeile["art"]; if (k.art === "netto" && !k.faktor) k.faktor = 0.7; }
|
||||
else if (name === "notiz") k.notiz = String(wert).trim() || undefined;
|
||||
else satz(k, name!, wert);
|
||||
}
|
||||
if (art === "m") {
|
||||
const m = (dv.mittellohn[id!] ??= { an: false, personen: null });
|
||||
if (name === "an") m.an = !!wert;
|
||||
else m.personen = String(roh).trim() ? (wert as number) : null;
|
||||
}
|
||||
if (art === "v" && id === "koepfe") dv.koepfe = String(roh).trim() && (wert as number) >= 1 ? (wert as number) : null;
|
||||
if (art === "v" && id === "bewertung") dv.bewertung = String(wert);
|
||||
}
|
||||
|
||||
function verbinden(raster: HTMLElement): void {
|
||||
raster.addEventListener("input", (ev) => {
|
||||
const el = ev.target as HTMLInputElement;
|
||||
if (!el.dataset.f || el.type === "checkbox" || el.tagName === "SELECT") return;
|
||||
try {
|
||||
setze(el.dataset.f, el.dataset.t ?? "zahl", el.value);
|
||||
el.classList.remove("ungueltig"); el.removeAttribute("aria-invalid");
|
||||
} catch { el.classList.add("ungueltig"); el.setAttribute("aria-invalid", "true"); return; }
|
||||
W = werte(rechne());
|
||||
raster.querySelectorAll<HTMLElement>("[data-w]").forEach((x) => { const n = W[x.dataset.w!]; if (n != null && x.textContent !== n) x.textContent = n; });
|
||||
speichernSpaeter();
|
||||
});
|
||||
raster.addEventListener("change", (ev) => {
|
||||
const el = ev.target as HTMLInputElement;
|
||||
if (!el.dataset.f) return;
|
||||
if (el.type === "checkbox" || el.tagName === "SELECT") {
|
||||
setze(el.dataset.f, el.dataset.t ?? "text", el.type === "checkbox" ? el.checked : el.value);
|
||||
speichernSpaeter();
|
||||
zeichne();
|
||||
}
|
||||
});
|
||||
raster.addEventListener("click", (ev) => void klick(ev));
|
||||
}
|
||||
|
||||
async function klick(ev: Event): Promise<void> {
|
||||
const b = (ev.target as HTMLElement).closest<HTMLElement>("[data-tab], [data-a], [data-weg], [data-neu-kosten], [data-laufend]");
|
||||
if (!b) return;
|
||||
const dv = v!.daten, t = tabelle();
|
||||
if (b.dataset.tab) { offen = b.dataset.tab; merke("ss-tabelle", offen); return zeichne(); }
|
||||
if (b.dataset.weg) {
|
||||
const [art, id] = b.dataset.weg.split(".");
|
||||
if (art === "a") t.zeit.ausfall = t.zeit.ausfall.filter((x) => x.id !== id);
|
||||
if (art === "u") t.zeit.unproduktiv = t.zeit.unproduktiv.filter((x) => x.id !== id);
|
||||
if (art === "k") t.kosten = t.kosten.filter((x) => x.id !== id);
|
||||
}
|
||||
if (b.dataset.neuKosten) t.kosten.push({ id: neueId(), block: Number(b.dataset.neuKosten) as Block, name: "", art: Number(b.dataset.neuKosten) === 2 ? "prozent" : "jahr", betrag: 0, prozent: 0 });
|
||||
if (b.dataset.laufend) { if (!(await laufendWaehlen(t.kosten.find((x) => x.id === b.dataset.laufend)!))) return; }
|
||||
const a = b.dataset.a;
|
||||
if (a === "ausfall-neu") t.zeit.ausfall.push({ id: neueId(), name: "", tage: 0 });
|
||||
if (a === "unprod-neu") t.zeit.unproduktiv.push({ id: neueId(), name: "", stunden: 0, je: "monat", als: "zeit" });
|
||||
if (a === "hinweis-weg") delete t.hinweis;
|
||||
if (a === "kalender") { const k = kalender(Number(v!.gilt_ab.slice(0, 4))); t.zeit.tageJahr = k.werktage; t.zeit.feiertage = k.feiertage; }
|
||||
if (a === "tabelle-neu") {
|
||||
const e = await dialog("Tabelle hinzufügen", [
|
||||
{ name: "name", titel: "Lohnart", pflicht: true, hilfe: "z. B. Vorarbeiter, Azubi, 2. Geselle" },
|
||||
{ name: "von", titel: "Kopie von", art: "auswahl", optionen: dv.tabellen.map((x) => [x.id, x.name]) },
|
||||
], { von: t.id }, false);
|
||||
if (e?.aktion !== "speichern") return;
|
||||
const quelle = dv.tabellen.find((x) => x.id === e.daten.von) ?? t;
|
||||
const neu: Rechentabelle = { ...structuredClone(quelle), id: schluesselFuer(e.daten.name, dv.tabellen.map((x) => x.id)), name: e.daten.name, hinweis: `Kopie von ${quelle.name}. Bitte Lohn und Zeiten anpassen.` };
|
||||
dv.tabellen.push(neu);
|
||||
dv.mittellohn[neu.id] = { an: false, personen: null };
|
||||
offen = neu.id;
|
||||
}
|
||||
if (a === "tabelle-weg") {
|
||||
const benutzt = dv.bewertung === t.id;
|
||||
if (!(await bestaetigen(`Tabelle „${t.name}“ löschen?`, { hinweis: "Angebote, die diese Lohnart schon haben, behalten ihren Satz.", ja: "Löschen" }))) return;
|
||||
dv.tabellen = dv.tabellen.filter((x) => x.id !== t.id);
|
||||
delete dv.mittellohn[t.id];
|
||||
if (benutzt) dv.bewertung = dv.tabellen.find((x) => x.id === "geselle")?.id ?? dv.tabellen[0]!.id;
|
||||
offen = dv.tabellen[0]!.id;
|
||||
}
|
||||
speichernSpaeter();
|
||||
zeichne();
|
||||
}
|
||||
|
||||
/** Auswahl laufender Kosten für eine Kostenzeile „aus laufenden Kosten“ */
|
||||
function laufendWaehlen(k: Kostenzeile): Promise<boolean> {
|
||||
return new Promise((fertig) => {
|
||||
const liste = umfeld().liste;
|
||||
const gewaehlt = new Set(k.laufend ?? []);
|
||||
huelle.innerHTML = `<form class="dialog ss-laufend"><h2>Laufende Kosten für „${esc(k.name || "Kostenzeile")}“</h2>
|
||||
${liste.length ? `<div class="ss-laufend-liste">${liste.map((l) => `<label><input type="checkbox" value="${l.id}"${gewaehlt.has(l.id) ? " checked" : ""}>
|
||||
<span>${esc(l.bezeichnung)}${l.kategorie ? ` <small class="hinweis">${esc(l.kategorie)}</small>` : ""}</span><b>${eur(l.jahr)}</b></label>`).join("")}</div>`
|
||||
: '<p class="hinweis">Unter Betrieb → laufende Kosten steht noch nichts.</p>'}
|
||||
<p class="hinweis">Summe im Jahr ${v!.gilt_ab.slice(0, 4)}; einmalige Kosten zählen nicht. „÷ Köpfe“ und „Anteil“ gelten danach.</p>
|
||||
<div class="knoepfe"><button type="button" class="neben" data-a="abbrechen">Abbrechen</button><button type="submit" class="haupt">Übernehmen</button></div></form>`;
|
||||
huelle.hidden = false;
|
||||
const form = huelle.querySelector("form")!;
|
||||
const zu = (ja: boolean) => { huelle.hidden = true; huelle.innerHTML = ""; fertig(ja); };
|
||||
form.querySelector<HTMLElement>('[data-a="abbrechen"]')!.onclick = () => zu(false);
|
||||
form.onsubmit = (ev) => {
|
||||
ev.preventDefault();
|
||||
k.laufend = [...form.querySelectorAll<HTMLInputElement>("input:checked")].map((x) => x.value);
|
||||
zu(true);
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
// ---------- Speichern ----------
|
||||
|
||||
function speichernSpaeter(): void {
|
||||
clearTimeout(speichernNach);
|
||||
document.querySelector(".ss-gespeichert")?.replaceChildren("Speichert …");
|
||||
speichernNach = setTimeout(() => void speichernJetzt(), 700);
|
||||
}
|
||||
|
||||
async function speichernJetzt(): Promise<void> {
|
||||
if (!speichernNach || !v) return;
|
||||
clearTimeout(speichernNach);
|
||||
speichernNach = undefined;
|
||||
try {
|
||||
await api(`stundensaetze/${v.id}`, "PATCH", { daten: v.daten });
|
||||
document.querySelector(".ss-gespeichert")?.replaceChildren("Gespeichert");
|
||||
} catch (e) {
|
||||
document.querySelector(".ss-gespeichert")?.replaceChildren(`Nicht gespeichert: ${(e as Error).message}`);
|
||||
}
|
||||
}
|
||||
window.addEventListener("hashchange", () => void speichernJetzt());
|
||||
@@ -1754,3 +1754,73 @@ button.speichern-gruen:hover { background: var(--ein); }
|
||||
}
|
||||
.handy-reiter.nur-handy { display: none; }
|
||||
@media (max-width: 640px) { .handy-reiter.nur-handy { display: flex; } }
|
||||
|
||||
/* ---------- Personal → Stundensätze (M15–M19) ---------- */
|
||||
.ss-leiste { display: flex; flex-wrap: wrap; align-items: center; gap: 10px; justify-content: space-between; }
|
||||
.ss-leiste .chip-knopf small { font-weight: 400; color: var(--leise); }
|
||||
.ss-raster { display: grid; grid-template-columns: 230px minmax(0, 1fr); gap: 16px; align-items: start; }
|
||||
.ss-rechts { display: grid; gap: 16px; min-width: 0; }
|
||||
.ss-raster .karte h2 { font-size: 16px; margin: 0 0 8px; }
|
||||
.ss-links { position: sticky; top: 12px; }
|
||||
.ss-liste { display: grid; gap: 4px; }
|
||||
.ss-eintrag { display: flex; justify-content: space-between; gap: 8px; padding: 8px 10px; border: 1px solid transparent; border-radius: 8px; background: none; color: var(--text); font: inherit; cursor: pointer; text-align: left; }
|
||||
.ss-eintrag:hover { background: var(--titel-bg); }
|
||||
.ss-eintrag.an { border-color: var(--akzent); background: var(--akzent-hell); }
|
||||
.ss-eintrag b, .ss-ergebnis b { font-variant-numeric: tabular-nums; white-space: nowrap; }
|
||||
.ss-neu { display: grid; width: 100%; margin-top: 8px; padding: 8px; border: 1px dashed var(--akzent); border-radius: 8px; background: none; color: var(--akzent); font: inherit; cursor: pointer; }
|
||||
.ss-neu small { color: var(--leise); font-size: 12px; }
|
||||
.ss-abstand { margin-top: 16px !important; }
|
||||
.ss-ergebnis { display: flex; justify-content: space-between; gap: 8px; flex-wrap: wrap; padding: 8px 10px; border: 1px solid var(--linie); border-radius: 8px; margin-bottom: 4px; }
|
||||
.ss-ergebnis b { color: var(--akzent); font-size: 18px; }
|
||||
.ss-ergebnis.klein { border: 0; padding: 2px 10px; }
|
||||
.ss-ergebnis.klein b { font-size: 14px; color: var(--text); }
|
||||
.ss-kopf { display: flex; justify-content: space-between; align-items: center; gap: 10px; flex-wrap: wrap; }
|
||||
.ss-kopf h2 { display: flex; align-items: center; gap: 6px; }
|
||||
input.ss-titel { font: inherit; font-weight: 700; width: 12em; padding: 2px 6px; }
|
||||
.ss-hinweis { background: var(--markiert); border-radius: 8px; padding: 6px 10px; }
|
||||
.ss-rolle { overflow-x: auto; margin-top: 10px; }
|
||||
table.ss-t { width: 100%; border-collapse: collapse; font-size: 13.5px; }
|
||||
table.ss-t th, table.ss-t td { padding: 5px 6px; border-bottom: 1px solid var(--linie); text-align: left; vertical-align: middle; }
|
||||
table.ss-t th { font-size: 12.5px; color: var(--leise); font-weight: 600; }
|
||||
table.ss-t th.zahl, table.ss-t td.zahl { text-align: right; font-variant-numeric: tabular-nums; white-space: nowrap; }
|
||||
table.ss-t tr.ss-block th { padding-top: 12px; color: var(--text); font-size: 13.5px; border-bottom: 2px solid var(--linie); }
|
||||
table.ss-t tr.ss-zwischen td { font-weight: 600; background: var(--titel-bg); }
|
||||
table.ss-t tr.ss-info td { color: var(--leise); font-size: 12.5px; }
|
||||
table.ss-t tr.ss-ergebniszeile td { border-top: 2px solid var(--text); border-bottom: 0; padding-top: 8px; }
|
||||
table.ss-t tr.ss-auszeit td, table.ss-t tr.ss-als-kosten td { color: var(--leise); }
|
||||
table.ss-t tr.aus td { color: var(--leise); }
|
||||
table.ss-t input { font: inherit; padding: 3px 5px; border: 1px solid var(--eingabe-linie); background: var(--eingabe-bg); color: var(--eingabe-text); border-radius: 5px; }
|
||||
table.ss-t input.zahl { text-align: right; }
|
||||
table.ss-t input.w-kurz { width: 4.5em; }
|
||||
table.ss-t input.w-euro { width: 7em; }
|
||||
table.ss-t input.ss-name { width: 100%; min-width: 14em; background: transparent; border-color: transparent; color: var(--text); }
|
||||
table.ss-t input.ss-name:hover, table.ss-t input.ss-name:focus { border-color: var(--linie); }
|
||||
table.ss-t input.ss-notiz { width: 9em; background: transparent; border-color: transparent; color: var(--leise); }
|
||||
table.ss-t select { font: inherit; font-size: 12.5px; padding: 2px 4px; }
|
||||
.ss-ansatz { display: flex; flex-wrap: wrap; align-items: center; gap: 4px 6px; }
|
||||
.ss-ansatz.klein { font-size: 12px; color: var(--leise); margin-top: 3px; }
|
||||
.ss-ansatz.klein input.w-kurz { width: 3.6em; }
|
||||
.ss-gross, .ss-gross span { font-size: 18px; font-weight: 700; color: var(--akzent); }
|
||||
.ss-umsatz { margin: 12px 0 4px; }
|
||||
.ss-umsatz input { font: inherit; width: 3.6em; text-align: right; padding: 2px 4px; border: 1px solid var(--eingabe-linie); background: var(--eingabe-bg); color: var(--eingabe-text); border-radius: 5px; }
|
||||
.ss-einstellungen { display: grid; gap: 8px; margin-top: 8px; }
|
||||
.ss-einstellungen input { font: inherit; width: 4em; text-align: right; padding: 2px 4px; border: 1px solid var(--eingabe-linie); background: var(--eingabe-bg); color: var(--eingabe-text); border-radius: 5px; }
|
||||
.ss-schalter { position: relative; display: inline-block; width: 34px; height: 19px; }
|
||||
.ss-schalter input { position: absolute; inset: 0; opacity: 0; margin: 0; cursor: pointer; }
|
||||
.ss-schalter i { position: absolute; inset: 0; border-radius: 99px; background: var(--linie); pointer-events: none; transition: background .15s; }
|
||||
.ss-schalter i::after { content: ""; position: absolute; top: 2px; left: 2px; width: 15px; height: 15px; border-radius: 50%; background: var(--fl); transition: left .15s; }
|
||||
.ss-schalter input:checked + i { background: var(--akzent); }
|
||||
.ss-schalter input:checked + i::after { left: 17px; }
|
||||
.ss-schalter input:focus-visible + i { outline: 2px solid var(--akzent); outline-offset: 2px; }
|
||||
.ss-weg { text-decoration: none !important; color: var(--leise) !important; font-size: 16px; }
|
||||
.ss-leer { max-width: 640px; }
|
||||
.ss-laufend-liste { display: grid; gap: 4px; max-height: 50vh; overflow: auto; margin-bottom: 8px; }
|
||||
.ss-laufend-liste label { display: grid; grid-template-columns: auto 1fr auto; gap: 8px; align-items: center; padding: 4px 0; border-bottom: 1px solid var(--linie); }
|
||||
.neue-saetze { display: flex; flex-wrap: wrap; gap: 8px; align-items: center; background: var(--markiert); border: 1px solid var(--eingabe-linie); border-radius: 10px; padding: 8px 12px; margin-bottom: 12px; }
|
||||
.neue-saetze span { flex: 1 1 280px; }
|
||||
@media (max-width: 900px) {
|
||||
.ss-raster { grid-template-columns: 1fr; }
|
||||
.ss-links { position: static; }
|
||||
table.ss-t .optional { display: none; }
|
||||
}
|
||||
table.ss-t input.ungueltig, .ss-umsatz input.ungueltig, .ss-einstellungen input.ungueltig { background: var(--warnung-bg); color: var(--warnung-text); border-color: var(--warn); }
|
||||
|
||||
Reference in New Issue
Block a user