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:
40
src/domain/arbeitszeit.ts
Normal file
40
src/domain/arbeitszeit.ts
Normal 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
64
src/domain/datum.ts
Normal 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
113
src/domain/geld.ts
Normal 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
123
src/domain/kalender.ts
Normal 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
173
src/domain/liquiditaet.ts
Normal 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 };
|
||||
});
|
||||
}
|
||||
44
src/domain/umsatzsteuer.ts
Normal file
44
src/domain/umsatzsteuer.ts
Normal 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));
|
||||
}
|
||||
168
src/server/app.ts
Normal file
168
src/server/app.ts
Normal file
@@ -0,0 +1,168 @@
|
||||
import Fastify, { type FastifyInstance, type FastifyRequest } from "fastify";
|
||||
import fastifyStatic from "@fastify/static";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import path from "node:path";
|
||||
import { existsSync } from "node:fs";
|
||||
import { z, ZodError } from "zod";
|
||||
import { type Pool, transaktion } from "./db.js";
|
||||
import { TABELLEN } from "./tabellen.js";
|
||||
import { EinstellungenSchema, type Einstellungen } from "./einstellungen.js";
|
||||
import { liquiditaet, type Daten } from "../domain/liquiditaet.js";
|
||||
import { VERSION } from "./version.js";
|
||||
|
||||
export interface Optionen {
|
||||
pool: Pool;
|
||||
webOrdner?: string;
|
||||
logger?: boolean;
|
||||
}
|
||||
|
||||
/** Benutzer kommt vom Proxy (Anmeldung); ohne Proxy, z. B. lokal, gilt "lokal". */
|
||||
function benutzer(req: FastifyRequest): string {
|
||||
const h = req.headers["x-benutzer"];
|
||||
return (Array.isArray(h) ? h[0] : h)?.trim() || "lokal";
|
||||
}
|
||||
|
||||
const IdParam = z.object({ id: z.uuid() });
|
||||
|
||||
export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
const app = Fastify({ logger: o.logger ?? false, bodyLimit: 50 * 1024 * 1024 });
|
||||
const { pool } = o;
|
||||
|
||||
app.setErrorHandler((err, _req, reply) => {
|
||||
if (err instanceof ZodError) {
|
||||
return reply.status(400).send({ fehler: "Eingabe ungültig", details: err.issues.map((i) => `${i.path.join(".")}: ${i.message}`) });
|
||||
}
|
||||
const pgCode = (err as { code?: string }).code;
|
||||
if (pgCode === "23503") return reply.status(409).send({ fehler: "Verknüpfter Datensatz fehlt oder wird noch verwendet" });
|
||||
if (pgCode === "23505") return reply.status(409).send({ fehler: "Eintrag gibt es schon" });
|
||||
if (pgCode === "23514" || pgCode === "22P02" || pgCode === "22007" || pgCode === "22008") {
|
||||
return reply.status(400).send({ fehler: "Eingabe ungültig" });
|
||||
}
|
||||
const status = (err as { statusCode?: number }).statusCode;
|
||||
if (status && status < 500) return reply.status(status).send({ fehler: (err as Error).message });
|
||||
app.log.error(err);
|
||||
return reply.status(500).send({ fehler: "Interner Fehler" });
|
||||
});
|
||||
|
||||
app.get("/api/status", async () => {
|
||||
await pool.query("select 1");
|
||||
return { ok: true, version: VERSION };
|
||||
});
|
||||
|
||||
for (const t of TABELLEN) {
|
||||
const felder = Object.keys(t.schema.shape);
|
||||
const teil = t.schema.partial();
|
||||
|
||||
app.get(`/api/${t.pfad}`, async () => (await pool.query(`select * from ${t.name} order by ${t.sortierung}`)).rows);
|
||||
|
||||
app.get(`/api/${t.pfad}/:id`, async (req, reply) => {
|
||||
const { id } = IdParam.parse(req.params);
|
||||
const r = await pool.query(`select * from ${t.name} where id = $1`, [id]);
|
||||
return r.rows[0] ?? reply.status(404).send({ fehler: "Nicht gefunden" });
|
||||
});
|
||||
|
||||
app.post(`/api/${t.pfad}`, async (req, reply) => {
|
||||
const daten = t.schema.parse(req.body) as Record<string, unknown>;
|
||||
const spalten = felder.filter((f) => daten[f] !== undefined);
|
||||
const row = await transaktion(pool, benutzer(req), async (c) =>
|
||||
(await c.query(
|
||||
spalten.length
|
||||
? `insert into ${t.name} (${spalten.join(", ")}) values (${spalten.map((_, i) => `$${i + 1}`).join(", ")}) returning *`
|
||||
: `insert into ${t.name} default values returning *`,
|
||||
spalten.map((s) => daten[s]),
|
||||
)).rows[0],
|
||||
);
|
||||
return reply.status(201).send(row);
|
||||
});
|
||||
|
||||
app.patch(`/api/${t.pfad}/:id`, async (req, reply) => {
|
||||
const { id } = IdParam.parse(req.params);
|
||||
const daten = teil.parse(req.body) as Record<string, unknown>;
|
||||
const spalten = felder.filter((f) => daten[f] !== undefined);
|
||||
if (spalten.length === 0) return reply.status(400).send({ fehler: "Keine Änderung angegeben" });
|
||||
const row = await transaktion(pool, benutzer(req), async (c) =>
|
||||
(await c.query(
|
||||
`update ${t.name} set ${spalten.map((s, i) => `${s} = $${i + 2}`).join(", ")} where id = $1 returning *`,
|
||||
[id, ...spalten.map((s) => daten[s])],
|
||||
)).rows[0],
|
||||
);
|
||||
return row ?? reply.status(404).send({ fehler: "Nicht gefunden" });
|
||||
});
|
||||
|
||||
app.delete(`/api/${t.pfad}/:id`, async (req, reply) => {
|
||||
const { id } = IdParam.parse(req.params);
|
||||
const n = await transaktion(pool, benutzer(req), async (c) => (await c.query(`delete from ${t.name} where id = $1`, [id])).rowCount);
|
||||
return n ? reply.status(204).send() : reply.status(404).send({ fehler: "Nicht gefunden" });
|
||||
});
|
||||
}
|
||||
|
||||
async function ladeEinstellungen(): Promise<Einstellungen> {
|
||||
const r = await pool.query<{ daten: unknown }>("select daten from einstellungen limit 1");
|
||||
return EinstellungenSchema.parse(r.rows[0]?.daten ?? {});
|
||||
}
|
||||
|
||||
app.get("/api/einstellungen", ladeEinstellungen);
|
||||
|
||||
app.put("/api/einstellungen", async (req) => {
|
||||
const neu = EinstellungenSchema.parse(req.body);
|
||||
await transaktion(pool, benutzer(req), (c) => c.query("update einstellungen set daten = $1", [neu]));
|
||||
return neu;
|
||||
});
|
||||
|
||||
const LiquiAnfrage = z.object({
|
||||
ansicht: z.enum(["woche", "monat"]).default("woche"),
|
||||
start: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
|
||||
anzahl: z.coerce.number().int().min(1).max(104).default(12),
|
||||
});
|
||||
|
||||
app.get("/api/liquiditaet", async (req) => {
|
||||
const q = LiquiAnfrage.parse(req.query);
|
||||
const e = await ladeEinstellungen();
|
||||
const [zahlungen, kosten, laufend] = await Promise.all([
|
||||
pool.query(`select z.*, p.nummer from zahlung z join projekt p on p.id = z.projekt_id`),
|
||||
pool.query(`select k.*, p.nummer from kosten k join projekt p on p.id = k.projekt_id`),
|
||||
pool.query(`select * from laufende_kosten`),
|
||||
]);
|
||||
const daten: Daten = {
|
||||
einnahmen: zahlungen.rows.map((z) => ({
|
||||
projekt: z.nummer, bezeichnung: z.bezeichnung, netto: z.netto,
|
||||
termin: z.rechnungsdatum ?? z.termin, bezahltAm: z.bezahlt_am ?? undefined,
|
||||
})),
|
||||
ausgaben: kosten.rows.map((k) => ({
|
||||
projekt: k.nummer, bezeichnung: k.bezeichnung, art: k.art, netto: k.netto, termin: k.termin, mitVorsteuer: k.mit_vorsteuer,
|
||||
})),
|
||||
laufend: laufend.rows.map((l) => ({
|
||||
bezeichnung: l.bezeichnung, kategorie: l.kategorie, betrag: l.betrag, rhythmus: l.rhythmus, start: l.start, ende: l.ende ?? undefined,
|
||||
})),
|
||||
};
|
||||
const start = q.start ?? new Date().toISOString().slice(0, 10);
|
||||
return liquiditaet(daten, { ansicht: q.ansicht, start, anzahl: q.anzahl, startsaldo: e.startsaldo, ziele: e.zahlungsziele, ust: e.ust });
|
||||
});
|
||||
|
||||
// D1: kompletter Stand als JSON-Datei
|
||||
app.get("/api/export", async (_req, reply) => {
|
||||
const daten: Record<string, unknown[]> = {};
|
||||
for (const t of TABELLEN) daten[t.pfad] = (await pool.query(`select * from ${t.name} order by ${t.sortierung}`)).rows;
|
||||
const stand = new Date().toISOString();
|
||||
reply.header("content-disposition", `attachment; filename="betrieb-${stand.slice(0, 10)}.json"`);
|
||||
return { programm: "betrieb", version: VERSION, stand, einstellungen: await ladeEinstellungen(), daten };
|
||||
});
|
||||
|
||||
app.get("/api/protokoll", async (req) => {
|
||||
const q = z.object({ datensatz: z.uuid().optional(), limit: z.coerce.number().int().min(1).max(500).default(100) }).parse(req.query);
|
||||
const r = q.datensatz
|
||||
? await pool.query("select * from protokoll where datensatz = $1 order by id desc limit $2", [q.datensatz, q.limit])
|
||||
: await pool.query("select * from protokoll order by id desc limit $1", [q.limit]);
|
||||
return r.rows;
|
||||
});
|
||||
|
||||
const web = o.webOrdner ?? path.join(path.dirname(fileURLToPath(import.meta.url)), "..", "web");
|
||||
if (existsSync(web)) {
|
||||
await app.register(fastifyStatic, { root: web, prefix: "/" });
|
||||
app.setNotFoundHandler((req, reply) =>
|
||||
req.url.startsWith("/api/") ? reply.status(404).send({ fehler: "Nicht gefunden" }) : reply.sendFile("index.html"),
|
||||
);
|
||||
}
|
||||
|
||||
return app;
|
||||
}
|
||||
34
src/server/db.ts
Normal file
34
src/server/db.ts
Normal file
@@ -0,0 +1,34 @@
|
||||
import pg from "pg";
|
||||
|
||||
// date als 'JJJJ-MM-TT' lassen, bigint (Cent) und numeric als Zahl liefern
|
||||
pg.types.setTypeParser(1082, (v) => v);
|
||||
pg.types.setTypeParser(20, (v) => {
|
||||
const n = Number(v);
|
||||
if (!Number.isSafeInteger(n)) throw new Error(`Betrag zu groß: ${v}`);
|
||||
return n;
|
||||
});
|
||||
pg.types.setTypeParser(1700, (v) => Number(v));
|
||||
|
||||
export type Pool = pg.Pool;
|
||||
export type Client = pg.PoolClient;
|
||||
|
||||
export function erstellePool(url: string): Pool {
|
||||
return new pg.Pool({ connectionString: url, max: 10 });
|
||||
}
|
||||
|
||||
/** Führt fn in einer Transaktion aus; der Benutzer landet im Änderungsprotokoll. */
|
||||
export async function transaktion<T>(pool: Pool, benutzer: string, fn: (c: Client) => Promise<T>): Promise<T> {
|
||||
const c = await pool.connect();
|
||||
try {
|
||||
await c.query("begin");
|
||||
await c.query("select set_config('betrieb.benutzer', $1, true)", [benutzer]);
|
||||
const ergebnis = await fn(c);
|
||||
await c.query("commit");
|
||||
return ergebnis;
|
||||
} catch (e) {
|
||||
await c.query("rollback");
|
||||
throw e;
|
||||
} finally {
|
||||
c.release();
|
||||
}
|
||||
}
|
||||
29
src/server/einstellungen.ts
Normal file
29
src/server/einstellungen.ts
Normal file
@@ -0,0 +1,29 @@
|
||||
import { z } from "zod";
|
||||
|
||||
export const EinstellungenSchema = z.object({
|
||||
arbeitstage: z.array(z.number().int().min(1).max(7)).default([1, 2, 3, 4]),
|
||||
stundenProTag: z.number().positive().default(8),
|
||||
produktivitaet: z.number().positive().max(1).default(1),
|
||||
rundung: z.enum(["auf", "kaufmaennisch", "halbe"]).default("auf"),
|
||||
zahlungsziele: z
|
||||
.object({
|
||||
kundenTage: z.number().int().min(0).default(14),
|
||||
materialTage: z.number().int().min(0).default(30),
|
||||
fremdTage: z.number().int().min(0).default(14),
|
||||
sonstigeTage: z.number().int().min(0).default(0),
|
||||
})
|
||||
.prefault({}),
|
||||
ust: z
|
||||
.object({
|
||||
satz: z.number().min(0).default(19),
|
||||
voranmeldung: z.enum(["monatlich", "vierteljaehrlich"]).default("monatlich"),
|
||||
dauerfristverlaengerung: z.boolean().default(false),
|
||||
versteuerung: z.enum(["soll", "ist"]).default("soll"),
|
||||
})
|
||||
.prefault({}),
|
||||
startsaldo: z.number().int().default(0),
|
||||
startsaldoDatum: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable().default(null),
|
||||
mindestreserve: z.number().int().default(0),
|
||||
});
|
||||
|
||||
export type Einstellungen = z.infer<typeof EinstellungenSchema>;
|
||||
23
src/server/index.ts
Normal file
23
src/server/index.ts
Normal file
@@ -0,0 +1,23 @@
|
||||
import { erstellePool } from "./db.js";
|
||||
import { migriere } from "./migrate.js";
|
||||
import { baueApp } from "./app.js";
|
||||
|
||||
const url = process.env.DATABASE_URL;
|
||||
if (!url) {
|
||||
console.error("DATABASE_URL fehlt");
|
||||
process.exit(1);
|
||||
}
|
||||
|
||||
const pool = erstellePool(url);
|
||||
await migriere(pool, (t) => console.log(t));
|
||||
const app = await baueApp({ pool, logger: true });
|
||||
const port = Number(process.env.PORT ?? 3000);
|
||||
await app.listen({ host: "0.0.0.0", port });
|
||||
|
||||
for (const signal of ["SIGINT", "SIGTERM"] as const) {
|
||||
process.on(signal, async () => {
|
||||
await app.close();
|
||||
await pool.end();
|
||||
process.exit(0);
|
||||
});
|
||||
}
|
||||
40
src/server/migrate.ts
Normal file
40
src/server/migrate.ts
Normal file
@@ -0,0 +1,40 @@
|
||||
import { readdir, readFile } from "node:fs/promises";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import path from "node:path";
|
||||
import type { Pool } from "./db.js";
|
||||
|
||||
const ORDNER = path.join(path.dirname(fileURLToPath(import.meta.url)), "migrations");
|
||||
|
||||
/**
|
||||
* Spielt alle noch fehlenden Migrationen in Namensreihenfolge ein, jede in eigener Transaktion.
|
||||
* Eine Sperre verhindert, dass zwei Container gleichzeitig migrieren.
|
||||
*/
|
||||
export async function migriere(pool: Pool, log: (text: string) => void = () => {}): Promise<string[]> {
|
||||
const c = await pool.connect();
|
||||
const neu: string[] = [];
|
||||
try {
|
||||
await c.query("select pg_advisory_lock(4711)");
|
||||
await c.query("create table if not exists schema_version (name text primary key, eingespielt_am timestamptz not null default now())");
|
||||
const vorhanden = new Set((await c.query<{ name: string }>("select name from schema_version")).rows.map((r) => r.name));
|
||||
const dateien = (await readdir(ORDNER)).filter((d) => d.endsWith(".sql")).sort();
|
||||
for (const datei of dateien) {
|
||||
if (vorhanden.has(datei)) continue;
|
||||
const sql = await readFile(path.join(ORDNER, datei), "utf8");
|
||||
await c.query("begin");
|
||||
try {
|
||||
await c.query(sql);
|
||||
await c.query("insert into schema_version (name) values ($1)", [datei]);
|
||||
await c.query("commit");
|
||||
} catch (e) {
|
||||
await c.query("rollback");
|
||||
throw new Error(`Migration ${datei} fehlgeschlagen: ${(e as Error).message}`);
|
||||
}
|
||||
log(`Migration ${datei} eingespielt`);
|
||||
neu.push(datei);
|
||||
}
|
||||
} finally {
|
||||
await c.query("select pg_advisory_unlock(4711)").catch(() => {});
|
||||
c.release();
|
||||
}
|
||||
return neu;
|
||||
}
|
||||
203
src/server/migrations/001_grundlage.sql
Normal file
203
src/server/migrations/001_grundlage.sql
Normal file
@@ -0,0 +1,203 @@
|
||||
-- Stufe 0: Grundlage. Objekte aus V70 mit fester ID; Verknüpfungen nur über IDs.
|
||||
-- Beträge in Cent (bigint), Datumsangaben als date.
|
||||
-- Jede Tabelle speichert, wer wann geändert hat; jede Änderung landet im Protokoll.
|
||||
|
||||
create table protokoll (
|
||||
id bigserial primary key,
|
||||
zeitpunkt timestamptz not null default now(),
|
||||
benutzer text not null,
|
||||
tabelle text not null,
|
||||
datensatz uuid not null,
|
||||
aktion text not null check (aktion in ('anlegen', 'aendern', 'loeschen')),
|
||||
vorher jsonb,
|
||||
nachher jsonb
|
||||
);
|
||||
create index protokoll_datensatz on protokoll (datensatz);
|
||||
|
||||
create function stempel_und_protokoll() returns trigger language plpgsql as $$
|
||||
declare
|
||||
wer text := coalesce(nullif(current_setting('betrieb.benutzer', true), ''), 'system');
|
||||
begin
|
||||
if tg_op = 'DELETE' then
|
||||
insert into protokoll (benutzer, tabelle, datensatz, aktion, vorher)
|
||||
values (wer, tg_table_name, old.id, 'loeschen', to_jsonb(old));
|
||||
return old;
|
||||
end if;
|
||||
new.geaendert_am := now();
|
||||
new.geaendert_von := wer;
|
||||
if tg_op = 'INSERT' then
|
||||
new.angelegt_am := now();
|
||||
insert into protokoll (benutzer, tabelle, datensatz, aktion, nachher)
|
||||
values (wer, tg_table_name, new.id, 'anlegen', to_jsonb(new));
|
||||
else
|
||||
new.angelegt_am := old.angelegt_am;
|
||||
insert into protokoll (benutzer, tabelle, datensatz, aktion, vorher, nachher)
|
||||
values (wer, tg_table_name, new.id, 'aendern', to_jsonb(old), to_jsonb(new));
|
||||
end if;
|
||||
return new;
|
||||
end $$;
|
||||
|
||||
create table kontakt (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
name text not null,
|
||||
firma text,
|
||||
rolle text not null default 'sonstige'
|
||||
check (rolle in ('bauherr', 'subunternehmer', 'lieferant', 'planer', 'mitarbeiter', 'sonstige')),
|
||||
telefon text,
|
||||
email text,
|
||||
gewerk text,
|
||||
notiz text,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
|
||||
create table projekt (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
nummer text not null unique,
|
||||
bezeichnung text not null,
|
||||
bauherr_id uuid references kontakt (id) on delete set null,
|
||||
status text not null default 'auftrag'
|
||||
check (status in ('anfrage', 'angebot', 'auftrag', 'ausfuehrung', 'abgerechnet', 'gewaehrleistung', 'abgeschlossen')),
|
||||
-- Projektpauschalen aus V70 (Einzelposten werden davon abgezogen)
|
||||
umsatz_netto bigint not null default 0,
|
||||
material_kosten bigint not null default 0,
|
||||
fremd_kosten bigint not null default 0,
|
||||
sonstige_kosten bigint not null default 0,
|
||||
vertragsart text check (vertragsart in ('vob', 'bgb')),
|
||||
abnahme_am date,
|
||||
farbe text,
|
||||
nextcloud_link text,
|
||||
reihenfolge integer not null default 0,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
|
||||
-- Abschnitte und Meilensteine sind gleichrangig unter dem Projekt
|
||||
create table abschnitt (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
projekt_id uuid not null references projekt (id) on delete cascade,
|
||||
name text not null,
|
||||
ist_meilenstein boolean not null default false,
|
||||
reihenfolge integer not null default 0,
|
||||
erledigt boolean not null default false,
|
||||
-- nur für Meilensteine ohne Vorgänge
|
||||
termin date,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
create index abschnitt_projekt on abschnitt (projekt_id);
|
||||
|
||||
create table vorgang (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
abschnitt_id uuid not null references abschnitt (id) on delete cascade,
|
||||
name text not null,
|
||||
start date not null,
|
||||
-- Dauer in Arbeitstagen; 0 = Meilenstein
|
||||
dauer numeric(6, 1) not null default 1 check (dauer >= 0),
|
||||
stunden numeric(8, 2),
|
||||
kontakt_id uuid references kontakt (id) on delete set null,
|
||||
reihenfolge integer not null default 0,
|
||||
fortschritt integer not null default 0 check (fortschritt between 0 and 100),
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
create index vorgang_abschnitt on vorgang (abschnitt_id);
|
||||
|
||||
-- Mehrere Vorgänger je Vorgang sind im Modell vorgesehen (T5)
|
||||
create table vorgang_vorgaenger (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
vorgang_id uuid not null references vorgang (id) on delete cascade,
|
||||
vorgaenger_id uuid not null references vorgang (id) on delete cascade,
|
||||
art text not null default 'EA' check (art in ('EA', 'AA', 'EE', 'AE')),
|
||||
verzoegerung integer not null default 0,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system',
|
||||
unique (vorgang_id, vorgaenger_id),
|
||||
check (vorgang_id <> vorgaenger_id)
|
||||
);
|
||||
|
||||
create table zahlung (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
projekt_id uuid not null references projekt (id) on delete cascade,
|
||||
vorgang_id uuid references vorgang (id) on delete set null,
|
||||
art text not null default 'abschlag' check (art in ('anzahlung', 'abschlag', 'nachtrag', 'schluss', 'einbehalt')),
|
||||
bezeichnung text not null,
|
||||
netto bigint not null,
|
||||
termin date not null,
|
||||
status text not null default 'geplant' check (status in ('geplant', 'gestellt', 'bezahlt')),
|
||||
rechnungsdatum date,
|
||||
bezahlt_am date,
|
||||
reihenfolge integer not null default 0,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
create index zahlung_projekt on zahlung (projekt_id);
|
||||
|
||||
create table kosten (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
projekt_id uuid not null references projekt (id) on delete cascade,
|
||||
art text not null check (art in ('material', 'fremd', 'sonstiges')),
|
||||
bezeichnung text not null,
|
||||
netto bigint not null,
|
||||
termin date not null,
|
||||
kontakt_id uuid references kontakt (id) on delete set null,
|
||||
mit_vorsteuer boolean not null default true,
|
||||
status text not null default 'geplant' check (status in ('geplant', 'bestellt', 'bezahlt')),
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
create index kosten_projekt on kosten (projekt_id);
|
||||
|
||||
create table laufende_kosten (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
bezeichnung text not null,
|
||||
kategorie text not null default 'Sonstiges',
|
||||
betrag bigint not null,
|
||||
rhythmus text not null default 'monatlich' check (rhythmus in ('einmalig', 'monatlich', 'vierteljaehrlich', 'jaehrlich')),
|
||||
start date not null,
|
||||
ende date,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
|
||||
create table aufgabe (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
text text not null,
|
||||
faellig_am date,
|
||||
langfristig boolean not null default false,
|
||||
projekt_id uuid references projekt (id) on delete set null,
|
||||
kontakt_id uuid references kontakt (id) on delete set null,
|
||||
erledigt_am timestamptz,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system'
|
||||
);
|
||||
|
||||
-- Genau eine Zeile mit allen Einstellungen
|
||||
create table einstellungen (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
einzeln boolean not null default true unique check (einzeln),
|
||||
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'
|
||||
);
|
||||
insert into einstellungen (daten) values ('{}');
|
||||
|
||||
do $$
|
||||
declare t text;
|
||||
begin
|
||||
foreach t in array array['kontakt', 'projekt', 'abschnitt', 'vorgang', 'vorgang_vorgaenger', 'zahlung',
|
||||
'kosten', 'laufende_kosten', 'aufgabe', 'einstellungen'] loop
|
||||
execute format('create trigger %I_protokoll before insert or update or delete on %I
|
||||
for each row execute function stempel_und_protokoll()', t, t);
|
||||
end loop;
|
||||
end $$;
|
||||
149
src/server/tabellen.ts
Normal file
149
src/server/tabellen.ts
Normal file
@@ -0,0 +1,149 @@
|
||||
// Eingabeprüfung für die Tabellen aus Stufe 0. Feldnamen = Spaltennamen.
|
||||
import { z } from "zod";
|
||||
|
||||
const datum = z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "Datum im Format JJJJ-MM-TT");
|
||||
const cent = z.number().int("Betrag in ganzen Cent");
|
||||
const id = z.uuid();
|
||||
const text = z.string().trim().min(1, "darf nicht leer sein");
|
||||
const optText = z.string().trim().nullable().optional();
|
||||
|
||||
export interface Tabelle {
|
||||
name: string;
|
||||
pfad: string;
|
||||
schema: z.ZodObject;
|
||||
sortierung: string;
|
||||
}
|
||||
|
||||
export const TABELLEN: Tabelle[] = [
|
||||
{
|
||||
name: "kontakt",
|
||||
pfad: "kontakte",
|
||||
sortierung: "name",
|
||||
schema: z.object({
|
||||
name: text,
|
||||
firma: optText,
|
||||
rolle: z.enum(["bauherr", "subunternehmer", "lieferant", "planer", "mitarbeiter", "sonstige"]).optional(),
|
||||
telefon: optText,
|
||||
email: optText,
|
||||
gewerk: optText,
|
||||
notiz: optText,
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "projekt",
|
||||
pfad: "projekte",
|
||||
sortierung: "reihenfolge, nummer",
|
||||
schema: z.object({
|
||||
nummer: text,
|
||||
bezeichnung: text,
|
||||
bauherr_id: id.nullable().optional(),
|
||||
status: z.enum(["anfrage", "angebot", "auftrag", "ausfuehrung", "abgerechnet", "gewaehrleistung", "abgeschlossen"]).optional(),
|
||||
umsatz_netto: cent.optional(),
|
||||
material_kosten: cent.optional(),
|
||||
fremd_kosten: cent.optional(),
|
||||
sonstige_kosten: cent.optional(),
|
||||
vertragsart: z.enum(["vob", "bgb"]).nullable().optional(),
|
||||
abnahme_am: datum.nullable().optional(),
|
||||
farbe: optText,
|
||||
nextcloud_link: optText,
|
||||
reihenfolge: z.number().int().optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "abschnitt",
|
||||
pfad: "abschnitte",
|
||||
sortierung: "projekt_id, reihenfolge",
|
||||
schema: z.object({
|
||||
projekt_id: id,
|
||||
name: text,
|
||||
ist_meilenstein: z.boolean().optional(),
|
||||
reihenfolge: z.number().int().optional(),
|
||||
erledigt: z.boolean().optional(),
|
||||
termin: datum.nullable().optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "vorgang",
|
||||
pfad: "vorgaenge",
|
||||
sortierung: "abschnitt_id, reihenfolge, start",
|
||||
schema: z.object({
|
||||
abschnitt_id: id,
|
||||
name: text,
|
||||
start: datum,
|
||||
dauer: z.number().min(0).optional(),
|
||||
stunden: z.number().min(0).nullable().optional(),
|
||||
kontakt_id: id.nullable().optional(),
|
||||
reihenfolge: z.number().int().optional(),
|
||||
fortschritt: z.number().int().min(0).max(100).optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "vorgang_vorgaenger",
|
||||
pfad: "verknuepfungen",
|
||||
sortierung: "vorgang_id",
|
||||
schema: z.object({
|
||||
vorgang_id: id,
|
||||
vorgaenger_id: id,
|
||||
art: z.enum(["EA", "AA", "EE", "AE"]).optional(),
|
||||
verzoegerung: z.number().int().optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "zahlung",
|
||||
pfad: "zahlungen",
|
||||
sortierung: "projekt_id, reihenfolge, termin",
|
||||
schema: z.object({
|
||||
projekt_id: id,
|
||||
vorgang_id: id.nullable().optional(),
|
||||
art: z.enum(["anzahlung", "abschlag", "nachtrag", "schluss", "einbehalt"]).optional(),
|
||||
bezeichnung: text,
|
||||
netto: cent,
|
||||
termin: datum,
|
||||
status: z.enum(["geplant", "gestellt", "bezahlt"]).optional(),
|
||||
rechnungsdatum: datum.nullable().optional(),
|
||||
bezahlt_am: datum.nullable().optional(),
|
||||
reihenfolge: z.number().int().optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "kosten",
|
||||
pfad: "kosten",
|
||||
sortierung: "projekt_id, termin",
|
||||
schema: z.object({
|
||||
projekt_id: id,
|
||||
art: z.enum(["material", "fremd", "sonstiges"]),
|
||||
bezeichnung: text,
|
||||
netto: cent,
|
||||
termin: datum,
|
||||
kontakt_id: id.nullable().optional(),
|
||||
mit_vorsteuer: z.boolean().optional(),
|
||||
status: z.enum(["geplant", "bestellt", "bezahlt"]).optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "laufende_kosten",
|
||||
pfad: "laufende-kosten",
|
||||
sortierung: "kategorie, bezeichnung",
|
||||
schema: z.object({
|
||||
bezeichnung: text,
|
||||
kategorie: text.optional(),
|
||||
betrag: cent,
|
||||
rhythmus: z.enum(["einmalig", "monatlich", "vierteljaehrlich", "jaehrlich"]).optional(),
|
||||
start: datum,
|
||||
ende: datum.nullable().optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "aufgabe",
|
||||
pfad: "aufgaben",
|
||||
sortierung: "erledigt_am nulls first, faellig_am nulls last, angelegt_am",
|
||||
schema: z.object({
|
||||
text: text,
|
||||
faellig_am: datum.nullable().optional(),
|
||||
langfristig: z.boolean().optional(),
|
||||
projekt_id: id.nullable().optional(),
|
||||
kontakt_id: id.nullable().optional(),
|
||||
erledigt_am: z.iso.datetime({ offset: true }).nullable().optional(),
|
||||
}),
|
||||
},
|
||||
];
|
||||
2
src/server/version.ts
Normal file
2
src/server/version.ts
Normal file
@@ -0,0 +1,2 @@
|
||||
// Wird beim Release aus dem Git-Tag gesetzt (Umgebungsvariable APP_VERSION im Image).
|
||||
export const VERSION = process.env.APP_VERSION ?? "entwicklung";
|
||||
357
src/web/app.ts
Normal file
357
src/web/app.ts
Normal file
@@ -0,0 +1,357 @@
|
||||
// Oberfläche Stufe 0. Die Reiter folgen V70; Terminplan und Projektdetails
|
||||
// kommen mit der Übernahme der V70-Oberfläche.
|
||||
|
||||
import { formatEuro, parseEuro } from "../domain/geld.js";
|
||||
import { formatDatum } from "../domain/datum.js";
|
||||
|
||||
type Zeile = Record<string, any>;
|
||||
|
||||
// ---------- Hilfen ----------
|
||||
|
||||
function esc(v: unknown): string {
|
||||
return String(v ?? "").replace(/[&<>"']/g, (c) => ({ "&": "&", "<": "<", ">": ">", '"': """, "'": "'" })[c]!);
|
||||
}
|
||||
|
||||
async function api<T = any>(pfad: string, methode = "GET", body?: unknown): Promise<T> {
|
||||
const r = await fetch(`/api/${pfad}`, {
|
||||
method: methode,
|
||||
headers: body === undefined ? {} : { "content-type": "application/json" },
|
||||
body: body === undefined ? undefined : JSON.stringify(body),
|
||||
});
|
||||
if (r.status === 204) return undefined as T;
|
||||
const j = await r.json().catch(() => ({}));
|
||||
if (!r.ok) throw new Error([j.fehler ?? `Fehler ${r.status}`, ...(j.details ?? [])].join("\n"));
|
||||
return j as T;
|
||||
}
|
||||
|
||||
const inhalt = document.getElementById("inhalt")!;
|
||||
const huelle = document.getElementById("dialog-huelle")!;
|
||||
const heute = () => new Date().toISOString().slice(0, 10);
|
||||
const euro = (c: number | null | undefined) => (c == null ? "" : formatEuro(c));
|
||||
const dat = (d: string | null | undefined) => (d ? formatDatum(d) : "");
|
||||
|
||||
// ---------- Eigene Dialoge (keine Browser-Abfragen) ----------
|
||||
|
||||
interface Feld {
|
||||
name: string;
|
||||
titel: string;
|
||||
art?: "text" | "euro" | "datum" | "auswahl" | "zahl" | "langtext";
|
||||
optionen?: [string, string][];
|
||||
pflicht?: boolean;
|
||||
}
|
||||
|
||||
function dialog(titel: string, felder: Feld[], werte: Zeile, mitLoeschen: boolean): Promise<{ aktion: "speichern"; daten: Zeile } | { aktion: "loeschen" } | null> {
|
||||
return new Promise((fertig) => {
|
||||
const feldHtml = felder
|
||||
.map((f) => {
|
||||
const v = werte[f.name];
|
||||
const id = `f-${f.name}`;
|
||||
let eingabe: string;
|
||||
if (f.art === "auswahl") {
|
||||
eingabe = `<select id="${id}">${f.optionen!.map(([w, t]) => `<option value="${esc(w)}"${w === (v ?? "") ? " selected" : ""}>${esc(t)}</option>`).join("")}</select>`;
|
||||
} else if (f.art === "langtext") {
|
||||
eingabe = `<textarea id="${id}" rows="3">${esc(v)}</textarea>`;
|
||||
} else {
|
||||
const typ = f.art === "datum" ? "date" : "text";
|
||||
const anzeige = f.art === "euro" && v != null ? formatEuro(v, false) : v;
|
||||
eingabe = `<input id="${id}" type="${typ}" value="${esc(anzeige)}"${f.art === "euro" || f.art === "zahl" ? ' inputmode="decimal"' : ""}>`;
|
||||
}
|
||||
return `<label for="${id}">${esc(f.titel)}${f.pflicht ? " *" : ""}</label>${eingabe}`;
|
||||
})
|
||||
.join("");
|
||||
huelle.innerHTML = `<form class="dialog"><h2>${esc(titel)}</h2>${feldHtml}<p class="fehler" id="dialog-fehler"></p>
|
||||
<div class="knoepfe">${mitLoeschen ? '<button type="button" class="neben links" data-a="loeschen">Löschen</button>' : ""}
|
||||
<button type="button" class="neben" data-a="abbrechen">Abbrechen</button><button type="submit" class="haupt">Speichern</button></div></form>`;
|
||||
huelle.hidden = false;
|
||||
const form = huelle.querySelector("form")!;
|
||||
const schliessen = (e: Parameters<typeof fertig>[0]) => {
|
||||
huelle.hidden = true;
|
||||
huelle.innerHTML = "";
|
||||
document.removeEventListener("keydown", taste);
|
||||
fertig(e);
|
||||
};
|
||||
const taste = (ev: KeyboardEvent) => ev.key === "Escape" && schliessen(null);
|
||||
document.addEventListener("keydown", taste);
|
||||
(form.querySelector("input,select,textarea") as HTMLElement | null)?.focus();
|
||||
form.addEventListener("click", (ev) => {
|
||||
const a = (ev.target as HTMLElement).dataset.a;
|
||||
if (a === "abbrechen") schliessen(null);
|
||||
if (a === "loeschen") bestaetigen("Wirklich löschen?").then((ja) => ja && schliessen({ aktion: "loeschen" }));
|
||||
});
|
||||
form.addEventListener("submit", (ev) => {
|
||||
ev.preventDefault();
|
||||
const daten: Zeile = {};
|
||||
try {
|
||||
for (const f of felder) {
|
||||
const roh = (form.querySelector(`#f-${f.name}`) as HTMLInputElement).value.trim();
|
||||
if (f.pflicht && !roh) throw new Error(`${f.titel} fehlt`);
|
||||
if (f.art === "euro") daten[f.name] = roh ? parseEuro(roh) : f.pflicht ? 0 : null;
|
||||
else if (f.art === "zahl") daten[f.name] = roh ? Number(roh.replace(",", ".")) : null;
|
||||
else daten[f.name] = roh || null;
|
||||
}
|
||||
} catch (e) {
|
||||
form.querySelector("#dialog-fehler")!.textContent = (e as Error).message;
|
||||
return;
|
||||
}
|
||||
schliessen({ aktion: "speichern", daten });
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
function bestaetigen(frage: string): Promise<boolean> {
|
||||
return new Promise((fertig) => {
|
||||
const box = document.createElement("div");
|
||||
box.className = "dialog";
|
||||
box.style.position = "fixed";
|
||||
box.innerHTML = `<h2>${esc(frage)}</h2><div class="knoepfe"><button class="neben" data-a="nein">Abbrechen</button><button class="haupt" data-a="ja">Ja</button></div>`;
|
||||
huelle.appendChild(box);
|
||||
box.addEventListener("click", (ev) => {
|
||||
const a = (ev.target as HTMLElement).dataset.a;
|
||||
if (!a) return;
|
||||
box.remove();
|
||||
fertig(a === "ja");
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
async function bearbeiten(pfad: string, titel: string, felder: Feld[], zeile: Zeile | null, vorgaben: Zeile = {}): Promise<boolean> {
|
||||
const e = await dialog(titel, felder, zeile ?? vorgaben, !!zeile);
|
||||
if (!e) return false;
|
||||
if (e.aktion === "loeschen") await api(`${pfad}/${zeile!.id}`, "DELETE");
|
||||
else if (zeile) await api(`${pfad}/${zeile.id}`, "PATCH", e.daten);
|
||||
else await api(pfad, "POST", { ...vorgaben, ...e.daten });
|
||||
return true;
|
||||
}
|
||||
|
||||
function tabelle(spalten: { titel: string; wert: (z: Zeile) => string; klasse?: string }[], zeilen: Zeile[], klick?: (z: Zeile) => void): HTMLTableElement {
|
||||
const t = document.createElement("table");
|
||||
t.innerHTML = `<thead><tr>${spalten.map((s) => `<th class="${s.klasse ?? ""}">${esc(s.titel)}</th>`).join("")}</tr></thead>
|
||||
<tbody>${zeilen.map((z, i) => `<tr data-i="${i}" class="${klick ? "klickbar" : ""}">${spalten.map((s) => `<td class="${s.klasse ?? ""}">${s.wert(z)}</td>`).join("")}</tr>`).join("")}</tbody>`;
|
||||
if (klick) t.addEventListener("click", (ev) => {
|
||||
const tr = (ev.target as HTMLElement).closest("tr[data-i]") as HTMLElement | null;
|
||||
if (tr) klick(zeilen[Number(tr.dataset.i)]!);
|
||||
});
|
||||
return t;
|
||||
}
|
||||
|
||||
function seite(titel: string, knopf?: { text: string; aktion: () => void }): HTMLElement {
|
||||
inhalt.innerHTML = `<h1>${esc(titel)}</h1>`;
|
||||
const leiste = document.createElement("div");
|
||||
leiste.className = "leiste";
|
||||
if (knopf) {
|
||||
const b = document.createElement("button");
|
||||
b.className = "haupt";
|
||||
b.textContent = knopf.text;
|
||||
b.onclick = knopf.aktion;
|
||||
leiste.appendChild(b);
|
||||
}
|
||||
inhalt.appendChild(leiste);
|
||||
return leiste;
|
||||
}
|
||||
|
||||
// ---------- Reiter ----------
|
||||
|
||||
const ROLLEN: [string, string][] = [
|
||||
["bauherr", "Bauherr"], ["subunternehmer", "Subunternehmer"], ["lieferant", "Lieferant"],
|
||||
["planer", "Planer"], ["mitarbeiter", "Mitarbeiter"], ["sonstige", "Sonstige"],
|
||||
];
|
||||
const KONTAKT_FELDER: Feld[] = [
|
||||
{ name: "name", titel: "Name", pflicht: true }, { name: "firma", titel: "Firma" },
|
||||
{ name: "rolle", titel: "Rolle", art: "auswahl", optionen: ROLLEN }, { name: "gewerk", titel: "Gewerk" },
|
||||
{ name: "telefon", titel: "Telefon" }, { name: "email", titel: "E-Mail" }, { name: "notiz", titel: "Notiz", art: "langtext" },
|
||||
];
|
||||
|
||||
async function kontakte(): Promise<void> {
|
||||
const neu = async () => (await bearbeiten("kontakte", "Neuer Kontakt", KONTAKT_FELDER, null)) && kontakte();
|
||||
seite("Kontakte", { text: "Neuer Kontakt", aktion: neu });
|
||||
const zeilen = await api<Zeile[]>("kontakte");
|
||||
const rolle = Object.fromEntries(ROLLEN);
|
||||
inhalt.appendChild(tabelle([
|
||||
{ titel: "Name", wert: (z) => esc(z.name) },
|
||||
{ titel: "Firma", wert: (z) => esc(z.firma), klasse: "optional" },
|
||||
{ titel: "Rolle", wert: (z) => esc(rolle[z.rolle]) },
|
||||
{ titel: "Telefon", wert: (z) => (z.telefon ? `<a href="tel:${esc(z.telefon)}">${esc(z.telefon)}</a>` : "") },
|
||||
{ titel: "E-Mail", wert: (z) => esc(z.email), klasse: "optional" },
|
||||
], zeilen, async (z) => (await bearbeiten("kontakte", "Kontakt bearbeiten", KONTAKT_FELDER, z)) && kontakte()));
|
||||
}
|
||||
|
||||
async function projekte(): Promise<void> {
|
||||
const kontaktListe = await api<Zeile[]>("kontakte");
|
||||
const felder: Feld[] = [
|
||||
{ name: "nummer", titel: "Nummer", pflicht: true }, { name: "bezeichnung", titel: "Baustelle", pflicht: true },
|
||||
{ name: "bauherr_id", titel: "Bauherr", art: "auswahl", optionen: [["", "–"], ...kontaktListe.map((k): [string, string] => [k.id, k.name])] },
|
||||
{ name: "umsatz_netto", titel: "Umsatz netto", art: "euro" }, { name: "material_kosten", titel: "Materialkosten", art: "euro" },
|
||||
{ name: "fremd_kosten", titel: "Fremdkosten", art: "euro" }, { name: "sonstige_kosten", titel: "Sonstige Kosten", art: "euro" },
|
||||
];
|
||||
const ohneNull = (z: Zeile | null) => z && { ...z, ...Object.fromEntries(["umsatz_netto", "material_kosten", "fremd_kosten", "sonstige_kosten"].map((k) => [k, z[k] ?? 0])) };
|
||||
const speichern = async (z: Zeile | null) => {
|
||||
if (await bearbeiten("projekte", z ? "Projekt bearbeiten" : "Neues Projekt", felder, z)) projekte();
|
||||
};
|
||||
seite("Projekte", { text: "Neues Projekt", aktion: () => speichern(null) });
|
||||
const zeilen = await api<Zeile[]>("projekte");
|
||||
const name = Object.fromEntries(kontaktListe.map((k) => [k.id, k.name]));
|
||||
const kostenSumme = (z: Zeile) => z.material_kosten + z.fremd_kosten + z.sonstige_kosten;
|
||||
inhalt.appendChild(tabelle([
|
||||
{ titel: "Nr.", wert: (z) => esc(z.nummer) },
|
||||
{ titel: "Baustelle", wert: (z) => esc(z.bezeichnung) },
|
||||
{ titel: "Bauherr", wert: (z) => esc(name[z.bauherr_id]), klasse: "optional" },
|
||||
{ titel: "Umsatz netto", wert: (z) => euro(z.umsatz_netto), klasse: "zahl" },
|
||||
{ titel: "Kosten", wert: (z) => euro(kostenSumme(z)), klasse: "zahl optional" },
|
||||
{ titel: "Rohertrag", wert: (z) => euro(z.umsatz_netto - kostenSumme(z)), klasse: "zahl" },
|
||||
], zeilen, (z) => speichern(ohneNull(z))));
|
||||
const gesamt = zeilen.reduce((s, z) => s + z.umsatz_netto - kostenSumme(z), 0);
|
||||
inhalt.insertAdjacentHTML("beforeend", `<p>Rohertrag gesamt: <strong>${euro(gesamt)}</strong></p>
|
||||
<p class="hinweis">Projektdetailseite, Einzelposten und Zahlungsplan folgen mit der V70-Übernahme.</p>`);
|
||||
}
|
||||
|
||||
async function terminplan(): Promise<void> {
|
||||
seite("Terminplan");
|
||||
inhalt.insertAdjacentHTML("beforeend", `<p class="hinweis">Der Gantt-Terminplan aus V70 wird als Nächstes übernommen. Arbeitstage (Mo–Do, Feiertage Schleswig-Holstein) und Stundenumrechnung sind bereits fertig und geprüft.</p>`);
|
||||
}
|
||||
|
||||
async function liquiditaetSeite(ansicht = "woche", anzahl = 8): Promise<void> {
|
||||
const leiste = seite("Liquidität");
|
||||
leiste.innerHTML = `<select id="l-ansicht"><option value="woche">Wochen</option><option value="monat">Monate</option></select>
|
||||
<select id="l-anzahl">${[4, 8, 12, 26, 52].map((n) => `<option>${n}</option>`).join("")}</select>`;
|
||||
const a = leiste.querySelector("#l-ansicht") as HTMLSelectElement;
|
||||
const n = leiste.querySelector("#l-anzahl") as HTMLSelectElement;
|
||||
a.value = ansicht;
|
||||
n.value = String(anzahl);
|
||||
a.onchange = n.onchange = () => liquiditaetSeite(a.value, Number(n.value));
|
||||
const perioden = await api<Zeile[]>(`liquiditaet?ansicht=${ansicht}&anzahl=${anzahl}&start=${heute()}`);
|
||||
inhalt.appendChild(tabelle([
|
||||
{ titel: ansicht === "woche" ? "Woche ab" : "Monat", wert: (p) => (ansicht === "woche" ? dat(p.von) : esc(p.von.slice(5, 7) + "/" + p.von.slice(0, 4))) },
|
||||
{ titel: "Einnahmen", wert: (p) => euro(p.einnahmen), klasse: "zahl" },
|
||||
{ titel: "Ausgaben", wert: (p) => euro(p.ausgaben), klasse: "zahl" },
|
||||
{ titel: "Saldo", wert: (p) => euro(p.saldo), klasse: "zahl optional" },
|
||||
{ titel: "Kontostand", wert: (p) => `<span class="${p.kontostand < 0 ? "fehler" : ""}">${euro(p.kontostand)}</span>`, klasse: "zahl" },
|
||||
], perioden, (p) => {
|
||||
const text = p.posten.map((x: Zeile) => `${dat(x.datum)} ${x.gruppe} ${x.projekt ?? ""} ${x.bezeichnung}: ${formatEuro(x.betrag)}`).join("\n") || "Keine Bewegungen";
|
||||
dialog(`${dat(p.von)} bis ${dat(p.bis)}`, [{ name: "t", titel: "Bewegungen", art: "langtext" }], { t: text }, false);
|
||||
}));
|
||||
}
|
||||
|
||||
const RHYTHMEN: [string, string][] = [["monatlich", "monatlich"], ["vierteljaehrlich", "vierteljährlich"], ["jaehrlich", "jährlich"], ["einmalig", "einmalig"]];
|
||||
const LK_FELDER: Feld[] = [
|
||||
{ name: "bezeichnung", titel: "Bezeichnung", pflicht: true }, { name: "kategorie", titel: "Kategorie" },
|
||||
{ name: "betrag", titel: "Betrag", art: "euro", pflicht: true }, { name: "rhythmus", titel: "Rhythmus", art: "auswahl", optionen: RHYTHMEN },
|
||||
{ name: "start", titel: "Erste Zahlung", art: "datum", pflicht: true }, { name: "ende", titel: "Endet am", art: "datum" },
|
||||
];
|
||||
|
||||
async function laufendeKosten(): Promise<void> {
|
||||
const neu = async () => (await bearbeiten("laufende-kosten", "Neue laufende Kosten", LK_FELDER, null, { start: heute(), rhythmus: "monatlich" })) && laufendeKosten();
|
||||
seite("Laufende Kosten", { text: "Neue Position", aktion: neu });
|
||||
const zeilen = await api<Zeile[]>("laufende-kosten");
|
||||
const r = Object.fromEntries(RHYTHMEN);
|
||||
inhalt.appendChild(tabelle([
|
||||
{ titel: "Kategorie", wert: (z) => esc(z.kategorie) }, { titel: "Bezeichnung", wert: (z) => esc(z.bezeichnung) },
|
||||
{ titel: "Rhythmus", wert: (z) => esc(r[z.rhythmus]) }, { titel: "Ab", wert: (z) => dat(z.start), klasse: "optional" },
|
||||
{ titel: "Betrag", wert: (z) => euro(z.betrag), klasse: "zahl" },
|
||||
], zeilen, async (z) => (await bearbeiten("laufende-kosten", "Laufende Kosten bearbeiten", LK_FELDER, z)) && laufendeKosten()));
|
||||
const monat = zeilen.filter((z) => z.rhythmus === "monatlich" && (!z.ende || z.ende >= heute())).reduce((s, z) => s + z.betrag, 0);
|
||||
inhalt.insertAdjacentHTML("beforeend", `<p>Monatlich: <strong>${euro(monat)}</strong></p>`);
|
||||
}
|
||||
|
||||
const AUFGABE_FELDER: Feld[] = [
|
||||
{ name: "text", titel: "Aufgabe", pflicht: true }, { name: "faellig_am", titel: "Fällig am", art: "datum" },
|
||||
];
|
||||
|
||||
function aufgabenTabelle(zeilen: Zeile[], neuLaden: () => void): HTMLTableElement {
|
||||
const t = tabelle([
|
||||
{ titel: "", wert: (z) => `<input type="checkbox" data-id="${z.id}"${z.erledigt_am ? " checked" : ""}>` },
|
||||
{ titel: "Aufgabe", wert: (z) => (z.erledigt_am ? `<s>${esc(z.text)}</s>` : esc(z.text)) },
|
||||
{ titel: "Fällig", wert: (z) => `<span class="${!z.erledigt_am && z.faellig_am && z.faellig_am < heute() ? "fehler" : ""}">${dat(z.faellig_am)}</span>` },
|
||||
], zeilen, async (z) => (await bearbeiten("aufgaben", "Aufgabe bearbeiten", AUFGABE_FELDER, z)) && neuLaden());
|
||||
t.addEventListener("click", async (ev) => {
|
||||
const box = ev.target as HTMLInputElement;
|
||||
if (box.type !== "checkbox") return;
|
||||
ev.stopPropagation();
|
||||
await api(`aufgaben/${box.dataset.id}`, "PATCH", { erledigt_am: box.checked ? new Date().toISOString() : null });
|
||||
neuLaden();
|
||||
}, true);
|
||||
return t;
|
||||
}
|
||||
|
||||
async function aufgaben(): Promise<void> {
|
||||
const neu = async () => (await bearbeiten("aufgaben", "Neue Aufgabe", AUFGABE_FELDER, null)) && aufgaben();
|
||||
seite("Aufgaben", { text: "Neue Aufgabe", aktion: neu });
|
||||
inhalt.appendChild(aufgabenTabelle(await api<Zeile[]>("aufgaben"), aufgaben));
|
||||
}
|
||||
|
||||
async function uebersicht(): Promise<void> {
|
||||
seite("Übersicht");
|
||||
const [alle, perioden] = await Promise.all([api<Zeile[]>("aufgaben"), api<Zeile[]>(`liquiditaet?ansicht=woche&anzahl=4&start=${heute()}`)]);
|
||||
const bisSonntag = new Date(Date.now() + 7 * 86400000).toISOString().slice(0, 10);
|
||||
const anstehend = alle.filter((a) => !a.erledigt_am && a.faellig_am && a.faellig_am <= bisSonntag);
|
||||
inhalt.insertAdjacentHTML("beforeend", `<h2>Anstehende Aufgaben</h2>`);
|
||||
inhalt.appendChild(anstehend.length ? aufgabenTabelle(anstehend, uebersicht) : Object.assign(document.createElement("p"), { className: "hinweis", textContent: "Nichts fällig in den nächsten 7 Tagen." }));
|
||||
inhalt.insertAdjacentHTML("beforeend", `<h2>Liquidität 4 Wochen</h2>`);
|
||||
inhalt.appendChild(tabelle([
|
||||
{ titel: "Woche ab", wert: (p) => dat(p.von) },
|
||||
{ titel: "Saldo", wert: (p) => euro(p.saldo), klasse: "zahl" },
|
||||
{ titel: "Kontostand", wert: (p) => `<span class="${p.kontostand < 0 ? "fehler" : ""}">${euro(p.kontostand)}</span>`, klasse: "zahl" },
|
||||
], perioden));
|
||||
}
|
||||
|
||||
async function daten(): Promise<void> {
|
||||
seite("Daten und Einstellungen");
|
||||
const e = await api<Zeile>("einstellungen");
|
||||
inhalt.insertAdjacentHTML("beforeend", `
|
||||
<p><a class="neben" href="/api/export" download>Kompletten Stand als JSON sichern</a></p>
|
||||
<p class="hinweis">Die Datenbank wird jede Nacht gesichert und in die Nextcloud kopiert. Der Import des V70-Stands folgt, sobald die V70-Datei vorliegt.</p>
|
||||
<h2>Einstellungen</h2>`);
|
||||
const felder: Feld[] = [
|
||||
{ name: "startsaldo", titel: "Kontostand (Startsaldo)", art: "euro" },
|
||||
{ name: "kundenTage", titel: "Zahlungsziel Kunden (Tage)", art: "zahl" },
|
||||
{ name: "materialTage", titel: "Zahlungsziel Material (Tage)", art: "zahl" },
|
||||
{ name: "fremdTage", titel: "Zahlungsziel Subunternehmer (Tage)", art: "zahl" },
|
||||
{ name: "versteuerung", titel: "Umsatzsteuer nach", art: "auswahl", optionen: [["soll", "Soll (vereinbarte Entgelte)"], ["ist", "Ist (vereinnahmte Entgelte)"]] },
|
||||
{ name: "voranmeldung", titel: "Voranmeldung", art: "auswahl", optionen: [["monatlich", "monatlich"], ["vierteljaehrlich", "vierteljährlich"]] },
|
||||
{ name: "stundenProTag", titel: "Stunden pro Arbeitstag", art: "zahl" },
|
||||
];
|
||||
const knopf = document.createElement("button");
|
||||
knopf.className = "neben";
|
||||
knopf.textContent = "Einstellungen bearbeiten";
|
||||
knopf.onclick = async () => {
|
||||
const r = await dialog("Einstellungen", felder, { ...e, ...e.zahlungsziele, ...e.ust }, false);
|
||||
if (r?.aktion !== "speichern") return;
|
||||
const d = r.daten;
|
||||
await api("einstellungen", "PUT", {
|
||||
...e, startsaldo: d.startsaldo ?? 0, stundenProTag: d.stundenProTag ?? e.stundenProTag,
|
||||
zahlungsziele: { ...e.zahlungsziele, kundenTage: d.kundenTage ?? 0, materialTage: d.materialTage ?? 0, fremdTage: d.fremdTage ?? 0 },
|
||||
ust: { ...e.ust, versteuerung: d.versteuerung, voranmeldung: d.voranmeldung },
|
||||
});
|
||||
daten();
|
||||
};
|
||||
inhalt.appendChild(knopf);
|
||||
}
|
||||
|
||||
const REITER: [string, string, () => Promise<void>][] = [
|
||||
["uebersicht", "Übersicht", uebersicht], ["projekte", "Projekte", projekte], ["terminplan", "Terminplan", terminplan],
|
||||
["liquiditaet", "Liquidität", () => liquiditaetSeite()], ["laufende-kosten", "Laufende Kosten", laufendeKosten],
|
||||
["kontakte", "Kontakte", kontakte], ["aufgaben", "Aufgaben", aufgaben], ["daten", "Daten", daten],
|
||||
];
|
||||
|
||||
const nav = document.getElementById("reiter")!;
|
||||
nav.innerHTML = REITER.map(([id, titel]) => `<button data-r="${id}">${titel}</button>`).join("");
|
||||
nav.addEventListener("click", (ev) => {
|
||||
const r = (ev.target as HTMLElement).dataset.r;
|
||||
if (r) location.hash = r;
|
||||
});
|
||||
|
||||
async function zeige(): Promise<void> {
|
||||
const id = location.hash.slice(1) || "uebersicht";
|
||||
const reiter = REITER.find(([r]) => r === id) ?? REITER[0]!;
|
||||
nav.querySelectorAll("button").forEach((b) => b.classList.toggle("aktiv", b.dataset.r === reiter[0]));
|
||||
try {
|
||||
await reiter[2]();
|
||||
} catch (e) {
|
||||
inhalt.insertAdjacentHTML("beforeend", `<p class="fehler">${esc((e as Error).message)}</p>`);
|
||||
}
|
||||
}
|
||||
window.addEventListener("hashchange", zeige);
|
||||
window.addEventListener("unhandledrejection", (ev) => {
|
||||
inhalt.insertAdjacentHTML("afterbegin", `<p class="fehler">${esc(ev.reason?.message ?? ev.reason)}</p>`);
|
||||
});
|
||||
zeige();
|
||||
api("status").then((s) => (document.getElementById("version")!.textContent = `Version ${s.version}`)).catch(() => {});
|
||||
19
src/web/index.html
Normal file
19
src/web/index.html
Normal file
@@ -0,0 +1,19 @@
|
||||
<!doctype html>
|
||||
<html lang="de">
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<title>Betrieb · Schaarschmidt Holzbau</title>
|
||||
<link rel="stylesheet" href="/styles.css">
|
||||
</head>
|
||||
<body>
|
||||
<header>
|
||||
<strong>Schaarschmidt Holzbau</strong>
|
||||
<nav id="reiter"></nav>
|
||||
<span id="version"></span>
|
||||
</header>
|
||||
<main id="inhalt"></main>
|
||||
<div id="dialog-huelle" hidden></div>
|
||||
<script type="module" src="/app.js"></script>
|
||||
</body>
|
||||
</html>
|
||||
37
src/web/styles.css
Normal file
37
src/web/styles.css
Normal file
@@ -0,0 +1,37 @@
|
||||
:root {
|
||||
--bg: #f6f5f2; --fl: #ffffff; --text: #1f1f1d; --leise: #6b6a65; --linie: #dedcd5;
|
||||
--akzent: #8a4b14; --akzent-text: #ffffff; --warn: #b42318;
|
||||
font-family: system-ui, -apple-system, "Segoe UI", sans-serif; font-size: 15px;
|
||||
}
|
||||
@media (prefers-color-scheme: dark) {
|
||||
:root { --bg: #1b1b1a; --fl: #262624; --text: #ecebe6; --leise: #a3a29b; --linie: #3a3936; --akzent: #d9893f; --akzent-text: #1b1b1a; --warn: #f97066; }
|
||||
}
|
||||
* { box-sizing: border-box; }
|
||||
body { margin: 0; background: var(--bg); color: var(--text); }
|
||||
header { display: flex; gap: 16px; align-items: center; flex-wrap: wrap; padding: 10px 16px; background: var(--fl); border-bottom: 1px solid var(--linie); }
|
||||
header nav { display: flex; gap: 4px; flex-wrap: wrap; flex: 1; }
|
||||
header nav button { background: none; border: 0; padding: 6px 10px; border-radius: 6px; color: var(--leise); cursor: pointer; font: inherit; }
|
||||
header nav button.aktiv { background: var(--bg); color: var(--text); font-weight: 600; }
|
||||
#version { color: var(--leise); font-size: 12px; }
|
||||
main { padding: 16px; max-width: 1200px; margin: 0 auto; }
|
||||
h1 { font-size: 20px; margin: 4px 0 16px; }
|
||||
.leiste { display: flex; gap: 8px; margin-bottom: 12px; align-items: center; }
|
||||
button.haupt { background: var(--akzent); color: var(--akzent-text); border: 0; border-radius: 6px; padding: 7px 14px; font: inherit; cursor: pointer; }
|
||||
button.neben { background: var(--fl); color: var(--text); border: 1px solid var(--linie); border-radius: 6px; padding: 6px 12px; font: inherit; cursor: pointer; }
|
||||
table { width: 100%; border-collapse: collapse; background: var(--fl); border: 1px solid var(--linie); border-radius: 8px; overflow: hidden; }
|
||||
th, td { text-align: left; padding: 7px 10px; border-bottom: 1px solid var(--linie); }
|
||||
th { font-size: 12px; color: var(--leise); font-weight: 600; }
|
||||
td.zahl, th.zahl { text-align: right; font-variant-numeric: tabular-nums; }
|
||||
tr.klickbar { cursor: pointer; }
|
||||
tr.klickbar:hover td { background: var(--bg); }
|
||||
.hinweis { color: var(--leise); }
|
||||
.fehler { color: var(--warn); }
|
||||
#dialog-huelle { position: fixed; inset: 0; background: rgb(0 0 0 / 0.35); display: grid; place-items: center; padding: 16px; }
|
||||
#dialog-huelle[hidden] { display: none; }
|
||||
.dialog { background: var(--fl); border-radius: 10px; padding: 18px; width: min(460px, 100%); box-shadow: 0 10px 30px rgb(0 0 0 / 0.25); }
|
||||
.dialog h2 { font-size: 17px; margin: 0 0 12px; }
|
||||
.dialog label { display: block; font-size: 12px; color: var(--leise); margin: 10px 0 3px; }
|
||||
.dialog input, .dialog select, .dialog textarea { width: 100%; padding: 7px 8px; border: 1px solid var(--linie); border-radius: 6px; background: var(--bg); color: var(--text); font: inherit; }
|
||||
.dialog .knoepfe { display: flex; justify-content: flex-end; gap: 8px; margin-top: 16px; }
|
||||
.dialog .knoepfe .links { margin-right: auto; }
|
||||
@media (max-width: 640px) { th.optional, td.optional { display: none; } }
|
||||
Reference in New Issue
Block a user