Stufe 0: Grundgerüst mit Rechenkern, Datenbank, Oberfläche und Docker-Betrieb

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:
Claude
2026-10-17 16:37:54 +00:00
commit 92d26baa4b
45 changed files with 6143 additions and 0 deletions

40
src/domain/arbeitszeit.ts Normal file
View File

@@ -0,0 +1,40 @@
// Umrechnung geplanter Stunden in Arbeitstage (Arbeitszeitkalkulation aus V70).
// Die genaue V70-Rundung wird mit der V70-Datei abgeglichen, sobald sie vorliegt.
export type Rundung = "auf" | "kaufmaennisch" | "halbe";
export interface Arbeitszeitkalkulation {
stundenProTag: number;
/** Anteil produktiver Zeit, 1 = 100 % */
produktivitaet: number;
rundung: Rundung;
}
export const STANDARD_KALKULATION: Arbeitszeitkalkulation = {
stundenProTag: 8,
produktivitaet: 1,
rundung: "auf",
};
const EPS = 1e-9;
/** Stunden (Dezimalzahl) in Arbeitstage; mindestens 1 Tag, sobald Stunden > 0 sind. */
export function stundenZuArbeitstagen(stunden: number, k: Arbeitszeitkalkulation = STANDARD_KALKULATION): number {
if (!(stunden >= 0)) throw new Error(`Ungültige Stunden: ${stunden}`);
if (!(k.stundenProTag > 0) || !(k.produktivitaet > 0)) throw new Error("Ungültige Arbeitszeitkalkulation");
if (stunden === 0) return 0;
const roh = stunden / (k.stundenProTag * k.produktivitaet);
let tage: number;
switch (k.rundung) {
case "auf":
tage = Math.ceil(roh - EPS);
break;
case "kaufmaennisch":
tage = Math.floor(roh + 0.5 + EPS);
break;
case "halbe":
tage = Math.ceil(roh * 2 - EPS) / 2;
break;
}
return Math.max(tage, k.rundung === "halbe" ? 0.5 : 1);
}

64
src/domain/datum.ts Normal file
View File

@@ -0,0 +1,64 @@
// Kalenderdaten als ISO-Text 'JJJJ-MM-TT'. Gerechnet wird immer in UTC,
// damit Sommer- und Winterzeit keine Tage verschieben.
export type Datum = string;
const ISO = /^(\d{4})-(\d{2})-(\d{2})$/;
export function zuDate(d: Datum): Date {
const m = ISO.exec(d);
if (!m) throw new Error(`Ungültiges Datum: ${d}`);
const date = new Date(Date.UTC(Number(m[1]), Number(m[2]) - 1, Number(m[3])));
if (vonDate(date) !== d) throw new Error(`Ungültiges Datum: ${d}`);
return date;
}
export function vonDate(date: Date): Datum {
return date.toISOString().slice(0, 10);
}
export function datum(jahr: number, monat: number, tag: number): Datum {
return vonDate(new Date(Date.UTC(jahr, monat - 1, tag)));
}
export function plusTage(d: Datum, tage: number): Datum {
const date = zuDate(d);
date.setUTCDate(date.getUTCDate() + tage);
return vonDate(date);
}
/** Gleicher Tag n Monate später; fehlt der Tag (31.), gilt der Monatsletzte. */
export function plusMonate(d: Datum, monate: number): Datum {
const date = zuDate(d);
const tag = date.getUTCDate();
const ziel = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + monate, 1));
const letzter = new Date(Date.UTC(ziel.getUTCFullYear(), ziel.getUTCMonth() + 1, 0)).getUTCDate();
ziel.setUTCDate(Math.min(tag, letzter));
return vonDate(ziel);
}
/** 1 = Montag … 7 = Sonntag */
export function wochentag(d: Datum): number {
const w = zuDate(d).getUTCDay();
return w === 0 ? 7 : w;
}
export function tageZwischen(von: Datum, bis: Datum): number {
return Math.round((zuDate(bis).getTime() - zuDate(von).getTime()) / 86_400_000);
}
export function montagDerWoche(d: Datum): Datum {
return plusTage(d, 1 - wochentag(d));
}
export function monatsErster(d: Datum): Datum {
return d.slice(0, 8) + "01";
}
export function jahrVon(d: Datum): number {
return Number(d.slice(0, 4));
}
export function formatDatum(d: Datum): string {
return `${d.slice(8, 10)}.${d.slice(5, 7)}.${d.slice(0, 4)}`;
}

113
src/domain/geld.ts Normal file
View File

@@ -0,0 +1,113 @@
// Beträge werden überall als ganze Cent gespeichert und gerechnet.
// Prozentrechnung läuft über BigInt, damit kein Rundungsfehler entsteht.
// Gerundet wird kaufmännisch (ab ,5 vom Betrag weg).
export type Cent = number;
function pruefeCent(c: Cent): void {
if (!Number.isSafeInteger(c)) throw new Error(`Kein ganzer Centbetrag: ${c}`);
}
/** Teilt zaehler/nenner (BigInt) und rundet kaufmännisch. */
function teileKaufmaennisch(zaehler: bigint, nenner: bigint): bigint {
const negativ = zaehler < 0n !== nenner < 0n;
const z = zaehler < 0n ? -zaehler : zaehler;
const n = nenner < 0n ? -nenner : nenner;
const q = (2n * z + n) / (2n * n);
return negativ ? -q : q;
}
/** Prozentsatz als exakte Zahl mit bis zu 4 Nachkommastellen, z. B. 19 oder 12,5. */
function prozentSkaliert(prozent: number): bigint {
const s = Math.round(prozent * 10_000);
if (Math.abs(s / 10_000 - prozent) > 1e-9) throw new Error(`Zu viele Nachkommastellen: ${prozent}`);
return BigInt(s);
}
/** Anteil in Prozent eines Betrags, kaufmännisch auf den Cent gerundet. */
export function prozentVon(betrag: Cent, prozent: number): Cent {
pruefeCent(betrag);
return Number(teileKaufmaennisch(BigInt(betrag) * prozentSkaliert(prozent), 1_000_000n));
}
export function summe(betraege: Cent[]): Cent {
let s = 0;
for (const b of betraege) {
pruefeCent(b);
s += b;
}
pruefeCent(s);
return s;
}
/** Brutto aus Netto: Umsatzsteuer je Position kaufmännisch gerundet. */
export function brutto(netto: Cent, ustSatz: number): Cent {
return netto + prozentVon(netto, ustSatz);
}
export function ustAusNetto(netto: Cent, ustSatz: number): Cent {
return prozentVon(netto, ustSatz);
}
/** Text wie "1.234,56", "1234,5", "-12" oder "12.50" in Cent. */
export function parseEuro(text: string): Cent {
let t = text.trim().replace(/\s|€/g, "");
if (t === "") throw new Error("Leerer Betrag");
const negativ = t.startsWith("-");
if (negativ || t.startsWith("+")) t = t.slice(1);
if (t.includes(",")) {
t = t.replace(/\./g, "").replace(",", ".");
} else if (/^\d{1,3}(\.\d{3})+$/.test(t)) {
t = t.replace(/\./g, "");
}
const m = /^(\d+)(?:\.(\d{0,2}))?$/.exec(t);
if (!m) throw new Error(`Ungültiger Betrag: ${text}`);
const cent = Number(m[1]) * 100 + Number((m[2] ?? "").padEnd(2, "0"));
pruefeCent(cent);
return negativ ? -cent : cent;
}
/** Cent als "1.234,56 €" */
export function formatEuro(c: Cent, mitZeichen = true): string {
pruefeCent(c);
const negativ = c < 0;
const abs = Math.abs(c);
const euro = Math.floor(abs / 100)
.toString()
.replace(/\B(?=(\d{3})+(?!\d))/g, ".");
const text = `${negativ ? "-" : ""}${euro},${(abs % 100).toString().padStart(2, "0")}`;
return mitZeichen ? `${text} €` : text;
}
export interface Rate {
/** Anteil an der Auftragssumme in Prozent … */
prozent?: number;
/** … oder ein fester Betrag in Cent */
betrag?: Cent;
}
/**
* Zahlungsplan (P9): Jede Rate als Prozent oder fester Betrag. Die letzte Rate
* (Schlussrechnung) bekommt immer den Rest, damit die Summe der Auftragssumme entspricht.
*/
export function zahlungsplanBetraege(auftragssumme: Cent, raten: Rate[]): Cent[] {
pruefeCent(auftragssumme);
if (raten.length === 0) return [];
const vorne = raten.slice(0, -1).map((r) => {
if (r.betrag !== undefined) {
pruefeCent(r.betrag);
return r.betrag;
}
if (r.prozent !== undefined) return prozentVon(auftragssumme, r.prozent);
throw new Error("Rate ohne Prozent oder Betrag");
});
return [...vorne, auftragssumme - summe(vorne)];
}
/** Standard-Zahlungsplan bei neuen Projekten (Henning, 17.10.2026), je Projekt änderbar. */
export const STANDARD_ZAHLUNGSPLAN: { bezeichnung: string; prozent: number }[] = [
{ bezeichnung: "Anzahlung bei Auftrag", prozent: 30 },
{ bezeichnung: "Abschlag nach Abbund und Richten", prozent: 40 },
{ bezeichnung: "Abschlag nach Fertigstellung der Restarbeiten", prozent: 20 },
{ bezeichnung: "Schlussrechnung nach Abnahme", prozent: 10 },
];

123
src/domain/kalender.ts Normal file
View File

@@ -0,0 +1,123 @@
// Feiertage Schleswig-Holstein und Arbeitstage des Betriebs.
// Regel aus V70: gearbeitet wird Montag bis Donnerstag. Freitag ist immer frei
// (Büro, Aufräumen, Reserve), Wochenende und Feiertage zählen nicht.
import { type Datum, datum, plusTage, wochentag, jahrVon } from "./datum.js";
export interface Feiertag {
datum: Datum;
name: string;
}
/** Ostersonntag nach der Gaußschen Osterformel (gregorianisch, anonymer Algorithmus). */
export function ostersonntag(jahr: number): Datum {
const a = jahr % 19;
const b = Math.floor(jahr / 100);
const c = jahr % 100;
const d = Math.floor(b / 4);
const e = b % 4;
const f = Math.floor((b + 8) / 25);
const g = Math.floor((b - f + 1) / 3);
const h = (19 * a + b - d - g + 15) % 30;
const i = Math.floor(c / 4);
const k = c % 4;
const l = (32 + 2 * e + 2 * i - h - k) % 7;
const m = Math.floor((a + 11 * h + 22 * l) / 451);
const monat = Math.floor((h + l - 7 * m + 114) / 31);
const tag = ((h + l - 7 * m + 114) % 31) + 1;
return datum(jahr, monat, tag);
}
const cache = new Map<number, Feiertag[]>();
/** Gesetzliche Feiertage in Schleswig-Holstein. Reformationstag gilt seit 2018. */
export function feiertageSH(jahr: number): Feiertag[] {
const vorhanden = cache.get(jahr);
if (vorhanden) return vorhanden;
const ostern = ostersonntag(jahr);
const liste: Feiertag[] = [
{ datum: datum(jahr, 1, 1), name: "Neujahr" },
{ datum: plusTage(ostern, -2), name: "Karfreitag" },
{ datum: plusTage(ostern, 1), name: "Ostermontag" },
{ datum: datum(jahr, 5, 1), name: "Tag der Arbeit" },
{ datum: plusTage(ostern, 39), name: "Christi Himmelfahrt" },
{ datum: plusTage(ostern, 50), name: "Pfingstmontag" },
{ datum: datum(jahr, 10, 3), name: "Tag der Deutschen Einheit" },
...(jahr >= 2018 ? [{ datum: datum(jahr, 10, 31), name: "Reformationstag" }] : []),
{ datum: datum(jahr, 12, 25), name: "1. Weihnachtstag" },
{ datum: datum(jahr, 12, 26), name: "2. Weihnachtstag" },
];
liste.sort((x, y) => x.datum.localeCompare(y.datum));
cache.set(jahr, liste);
return liste;
}
export function feiertag(d: Datum): Feiertag | undefined {
return feiertageSH(jahrVon(d)).find((f) => f.datum === d);
}
export interface Arbeitswoche {
/** Wochentage 1 = Montag … 7 = Sonntag, an denen gearbeitet wird */
tage: number[];
}
export const STANDARDWOCHE: Arbeitswoche = { tage: [1, 2, 3, 4] };
export function istArbeitstag(d: Datum, woche: Arbeitswoche = STANDARDWOCHE): boolean {
return woche.tage.includes(wochentag(d)) && !feiertag(d);
}
/** Bankarbeitstag (Mo–Fr ohne Feiertag), z. B. für Steuerfälligkeiten. Freitagsregel gilt hier nicht. */
export function istBankarbeitstag(d: Datum): boolean {
return wochentag(d) <= 5 && !feiertag(d);
}
/** Der Tag selbst, falls Arbeitstag, sonst der nächste Arbeitstag. */
export function naechsterArbeitstag(d: Datum, woche: Arbeitswoche = STANDARDWOCHE): Datum {
let x = d;
for (let i = 0; i < 400; i++) {
if (istArbeitstag(x, woche)) return x;
x = plusTage(x, 1);
}
throw new Error("Kein Arbeitstag gefunden");
}
export function naechsterBankarbeitstag(d: Datum): Datum {
let x = d;
while (!istBankarbeitstag(x)) x = plusTage(x, 1);
return x;
}
/**
* Verschiebt um n Arbeitstage (n darf negativ sein). Ausgangspunkt ist der Tag selbst;
* n = 0 liefert ihn unverändert.
*/
export function verschiebeArbeitstage(d: Datum, n: number, woche: Arbeitswoche = STANDARDWOCHE): Datum {
let x = d;
const schritt = n >= 0 ? 1 : -1;
let rest = Math.abs(n);
while (rest > 0) {
x = plusTage(x, schritt);
if (istArbeitstag(x, woche)) rest--;
}
return x;
}
/**
* Letzter Arbeitstag eines Vorgangs, der am Start (bzw. dem nächsten Arbeitstag) beginnt
* und `dauer` Arbeitstage dauert. Dauer 0 ist ein Meilenstein: Ende = Start.
*/
export function endeNachDauer(start: Datum, dauer: number, woche: Arbeitswoche = STANDARDWOCHE): Datum {
if (!Number.isInteger(dauer) || dauer < 0) throw new Error(`Ungültige Dauer: ${dauer}`);
const beginn = naechsterArbeitstag(start, woche);
if (dauer === 0) return beginn;
return verschiebeArbeitstage(beginn, dauer - 1, woche);
}
/** Anzahl Arbeitstage von `von` bis `bis`, beide eingeschlossen. 0, wenn bis vor von liegt. */
export function arbeitstageZwischen(von: Datum, bis: Datum, woche: Arbeitswoche = STANDARDWOCHE): number {
if (bis < von) return 0;
let n = 0;
for (let x = von; x <= bis; x = plusTage(x, 1)) if (istArbeitstag(x, woche)) n++;
return n;
}

173
src/domain/liquiditaet.ts Normal file
View File

@@ -0,0 +1,173 @@
// Liquiditätsvorschau je Woche oder Monat.
// Grundregeln aus V70: Zahlungsziele für Kunden und Material, Umsatzsteuer, laufende Kosten.
// Offene V70-Details (Projektpauschale minus Einzelzahlungen, Freitagsregel bei
// Zahlungsterminen) werden mit der V70-Datei abgeglichen und hier ergänzt.
import { type Datum, plusTage, plusMonate, montagDerWoche, monatsErster } from "./datum.js";
import { type Cent, ustAusNetto, summe } from "./geld.js";
import { type UstEinstellungen, STANDARD_UST, zeitraumVon, faelligkeit } from "./umsatzsteuer.js";
export type Gruppe = "Projekteinnahmen" | "Projektkosten" | "Laufende Kosten" | "Umsatzsteuer";
export type Kostenart = "material" | "fremd" | "sonstiges";
export type Rhythmus = "einmalig" | "monatlich" | "vierteljaehrlich" | "jaehrlich";
export interface Einnahme {
projekt?: string;
bezeichnung: string;
netto: Cent;
/** Rechnungs- bzw. geplanter Termin */
termin: Datum;
zahlungszielTage?: number;
bezahltAm?: Datum;
}
export interface Ausgabe {
projekt?: string;
bezeichnung: string;
art: Kostenart;
netto: Cent;
termin: Datum;
zahlungszielTage?: number;
/** false z. B. bei Subunternehmern im Reverse-Charge oder Kleinunternehmern */
mitVorsteuer?: boolean;
}
export interface LaufendeKosten {
bezeichnung: string;
kategorie?: string;
/** Betrag, der vom Konto abgeht */
betrag: Cent;
rhythmus: Rhythmus;
start: Datum;
ende?: Datum;
}
export interface Zahlungsziele {
kundenTage: number;
materialTage: number;
fremdTage: number;
sonstigeTage: number;
}
export const STANDARD_ZIELE: Zahlungsziele = { kundenTage: 14, materialTage: 30, fremdTage: 14, sonstigeTage: 0 };
export interface Vorschau {
ansicht: "woche" | "monat";
start: Datum;
anzahl: number;
startsaldo: Cent;
ziele?: Zahlungsziele;
ust?: UstEinstellungen;
}
export interface Posten {
datum: Datum;
gruppe: Gruppe;
projekt?: string;
bezeichnung: string;
/** positiv = Eingang, negativ = Ausgang */
betrag: Cent;
}
export interface Periode {
von: Datum;
bis: Datum;
einnahmen: Cent;
ausgaben: Cent;
saldo: Cent;
kontostand: Cent;
posten: Posten[];
}
function zielFuer(art: Kostenart, z: Zahlungsziele): number {
return art === "material" ? z.materialTage : art === "fremd" ? z.fremdTage : z.sonstigeTage;
}
const MONATE_JE_RHYTHMUS: Record<Exclude<Rhythmus, "einmalig">, number> = {
monatlich: 1,
vierteljaehrlich: 3,
jaehrlich: 12,
};
/** Alle Termine einer laufenden Kostenposition zwischen von und bis (eingeschlossen). */
export function termineLaufend(k: LaufendeKosten, von: Datum, bis: Datum): Datum[] {
if (k.rhythmus === "einmalig") return k.start >= von && k.start <= bis ? [k.start] : [];
const schritt = MONATE_JE_RHYTHMUS[k.rhythmus];
const ende = k.ende && k.ende < bis ? k.ende : bis;
const termine: Datum[] = [];
for (let i = 0; ; i++) {
const t = plusMonate(k.start, i * schritt);
if (t > ende) break;
if (t >= von) termine.push(t);
}
return termine;
}
export function periodenGrenzen(v: Pick<Vorschau, "ansicht" | "start" | "anzahl">): { von: Datum; bis: Datum }[] {
const grenzen: { von: Datum; bis: Datum }[] = [];
let von = v.ansicht === "woche" ? montagDerWoche(v.start) : monatsErster(v.start);
for (let i = 0; i < v.anzahl; i++) {
const naechste = v.ansicht === "woche" ? plusTage(von, 7) : plusMonate(von, 1);
grenzen.push({ von, bis: plusTage(naechste, -1) });
von = naechste;
}
return grenzen;
}
export interface Daten {
einnahmen: Einnahme[];
ausgaben: Ausgabe[];
laufend: LaufendeKosten[];
}
/** Alle Zahlungsbewegungen mit ihrem Zahltag, ohne Zeitraumfilter (außer laufende Kosten). */
export function bewegungen(d: Daten, v: Vorschau, bis: Datum): Posten[] {
const ziele = v.ziele ?? STANDARD_ZIELE;
const ust = v.ust ?? STANDARD_UST;
const posten: Posten[] = [];
const ustJeZeitraum = new Map<string, Cent>();
const buche = (zeitraum: string, betrag: Cent) => ustJeZeitraum.set(zeitraum, (ustJeZeitraum.get(zeitraum) ?? 0) + betrag);
for (const e of d.einnahmen) {
const steuer = ustAusNetto(e.netto, ust.satz);
const zahltag = e.bezahltAm ?? plusTage(e.termin, e.zahlungszielTage ?? ziele.kundenTage);
posten.push({ datum: zahltag, gruppe: "Projekteinnahmen", projekt: e.projekt, bezeichnung: e.bezeichnung, betrag: e.netto + steuer });
buche(zeitraumVon(ust.versteuerung === "ist" ? zahltag : e.termin, ust.voranmeldung), steuer);
}
for (const a of d.ausgaben) {
const vorsteuer = a.mitVorsteuer === false ? 0 : ustAusNetto(a.netto, ust.satz);
const zahltag = plusTage(a.termin, a.zahlungszielTage ?? zielFuer(a.art, ziele));
posten.push({ datum: zahltag, gruppe: "Projektkosten", projekt: a.projekt, bezeichnung: a.bezeichnung, betrag: -(a.netto + vorsteuer) });
if (vorsteuer) buche(zeitraumVon(a.termin, ust.voranmeldung), -vorsteuer);
}
for (const k of d.laufend) {
for (const t of termineLaufend(k, v.start < k.start ? v.start : k.start, bis)) {
posten.push({ datum: t, gruppe: "Laufende Kosten", bezeichnung: k.bezeichnung, betrag: -k.betrag });
}
}
for (const [zeitraum, zahllast] of [...ustJeZeitraum].sort()) {
if (zahllast === 0) continue;
posten.push({
datum: faelligkeit(zeitraum, ust),
gruppe: "Umsatzsteuer",
bezeichnung: `${zahllast > 0 ? "USt-Vorauszahlung" : "USt-Erstattung"} ${zeitraum}`,
betrag: -zahllast,
});
}
return posten;
}
export function liquiditaet(d: Daten, v: Vorschau): Periode[] {
const grenzen = periodenGrenzen(v);
if (grenzen.length === 0) return [];
const alle = bewegungen(d, v, grenzen[grenzen.length - 1]!.bis);
let kontostand = v.startsaldo;
return grenzen.map(({ von, bis }) => {
const posten = alle.filter((p) => p.datum >= von && p.datum <= bis).sort((a, b) => a.datum.localeCompare(b.datum));
const einnahmen = summe(posten.filter((p) => p.betrag > 0).map((p) => p.betrag));
const ausgaben = summe(posten.filter((p) => p.betrag < 0).map((p) => p.betrag));
const saldo = einnahmen + ausgaben;
kontostand += saldo;
return { von, bis, einnahmen, ausgaben, saldo, kontostand, posten };
});
}

View File

@@ -0,0 +1,44 @@
// Fälligkeit der Umsatzsteuer-Vorauszahlung.
// Fällig am 10. nach Ablauf des Voranmeldungszeitraums, mit Dauerfristverlängerung
// einen Monat später. Fällt der Tag auf Wochenende oder Feiertag, gilt der nächste
// Werktag (§ 108 Abs. 3 AO). Die Freitagsregel des Betriebs gilt hier nicht.
import { type Datum, datum, jahrVon } from "./datum.js";
import { naechsterBankarbeitstag } from "./kalender.js";
export type Voranmeldung = "monatlich" | "vierteljaehrlich";
export type Versteuerung = "soll" | "ist";
export interface UstEinstellungen {
satz: number;
voranmeldung: Voranmeldung;
dauerfristverlaengerung: boolean;
/** Soll: nach Rechnungsdatum. Ist: nach Zahlungseingang (offene Entscheidung E5). */
versteuerung: Versteuerung;
}
export const STANDARD_UST: UstEinstellungen = {
satz: 19,
voranmeldung: "monatlich",
dauerfristverlaengerung: false,
versteuerung: "soll",
};
/** Schlüssel des Voranmeldungszeitraums, z. B. "2026-03" oder "2026-Q1". */
export function zeitraumVon(d: Datum, v: Voranmeldung): string {
const monat = Number(d.slice(5, 7));
return v === "monatlich" ? d.slice(0, 7) : `${jahrVon(d)}-Q${Math.ceil(monat / 3)}`;
}
export function faelligkeit(zeitraum: string, e: Pick<UstEinstellungen, "dauerfristverlaengerung">): Datum {
let jahr = Number(zeitraum.slice(0, 4));
let letzterMonat: number;
if (zeitraum.includes("Q")) letzterMonat = Number(zeitraum.slice(6)) * 3;
else letzterMonat = Number(zeitraum.slice(5, 7));
let monat = letzterMonat + 1 + (e.dauerfristverlaengerung ? 1 : 0);
while (monat > 12) {
monat -= 12;
jahr++;
}
return naechsterBankarbeitstag(datum(jahr, monat, 10));
}