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