Rechentabellen je Lohnart wie Hennings Excel (Zeit, Kosten, Vollkostensatz), Mittellohn mit Schaltern, Versionen mit gilt ab. Excel-Fassung centgenau (80,38 / 107,81 EUR), Fassung nach S2 mit Akquise/Verwaltung als Kosten. Angebote schreiben die geltenden Sätze fest, Lohnzuschlag 0 %, Nachfrage bei neuer Version. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
307 lines
21 KiB
TypeScript
307 lines
21 KiB
TypeScript
// Jahresfinanzplanung und BWA (Stufe 5, Henning 21.10.2026). Nur für den Inhaber (Rollen im Heft).
|
||
// Ein Jahr hat Versionen: die Basis bleibt, eine Version „gilt“ und speist Liquidität, Übersicht und Plan/Ist.
|
||
import { aktuelleSaetze } from "./stundensaetze.js";
|
||
import type { FastifyInstance, FastifyRequest } from "fastify";
|
||
import { z } from "zod";
|
||
import { type Client, type Pool, transaktion } from "./db.js";
|
||
import type { Einstellungen } from "./einstellungen.js";
|
||
import { werName } from "./anmeldung.js";
|
||
import { type PlanDaten, PLANZEILEN, type Planzeile, SAISON_HANDWERK, leererPlan, rechne, vorschlaege, knappText } from "../domain/jahresplan.js";
|
||
import { BwaFehler, istWerte, liesBwa, planIst, zuordnungVorschlag } from "../domain/bwa.js";
|
||
import type { Daten, LaufendeKosten } from "../domain/liquiditaet.js";
|
||
import { laufendJeMonat } from "../domain/lage.js";
|
||
import { type Datum, plusTage, wochentag } from "../domain/datum.js";
|
||
|
||
const cent = z.number().int().min(0).max(10_000_000_000);
|
||
const monat = z.number().int().min(1).max(12);
|
||
const PlanSchema = z.object({
|
||
mitarbeiter: z.array(z.object({
|
||
id: z.string().min(1).max(40), name: z.string().trim().min(1).max(100), art: z.enum(["inhaber", "angestellt"]),
|
||
stunden: z.number().min(0).max(4000), brutto: cent, faktor: z.number().min(1).max(3).default(1.25),
|
||
eintritt: monat.default(1), austritt: monat.default(12), neu: z.boolean().default(false),
|
||
})).max(50).default([]),
|
||
investitionen: z.array(z.object({
|
||
id: z.string().min(1).max(40), name: z.string().trim().min(1).max(100), betrag: cent, monat: monat.default(1),
|
||
art: z.enum(["kauf", "kredit", "leasing"]).default("kauf"), anzahlung: cent.default(0), laufzeit: z.number().int().min(0).max(360).default(60),
|
||
zins: z.number().min(0).max(30).default(5), rate: cent.default(0), nutzungsdauer: z.number().min(0).max(50).default(6),
|
||
})).max(50).default([]),
|
||
annahmen: z.object({
|
||
stundensatz: cent, materialEinkauf: cent, materialAufschlag: z.number().min(0).max(500), subEinkauf: cent, subAufschlag: z.number().min(0).max(500),
|
||
laufendMonat: cent, preissteigerung: z.number().min(-50).max(100), werbungMonat: cent, afaBisher: cent, tilgungBisher: cent, steuerQuartal: cent,
|
||
kontostandStart: z.number().int().min(-10_000_000_000).max(10_000_000_000), mindestgrenze: cent,
|
||
}),
|
||
saison: z.array(z.number().min(0).max(100)).length(12),
|
||
});
|
||
|
||
const Jahr = z.coerce.number().int().min(2000).max(2100);
|
||
|
||
/** erster Freitag eines Monats */
|
||
export function ersterFreitag(jahr: number, m: number): Datum {
|
||
const erster = `${jahr}-${String(m).padStart(2, "0")}-01`;
|
||
return plusTage(erster, (5 - wochentag(erster) + 7) % 7);
|
||
}
|
||
|
||
const MONATSNAMEN = ["Januar", "Februar", "März", "April", "Mai", "Juni", "Juli", "August", "September", "Oktober", "November", "Dezember"];
|
||
|
||
/**
|
||
* Finanzsitzung als wiederkehrende Aufgabe (Roos: monatlich, Henning: erster Freitag = Bürotag). Das Programm legt
|
||
* sie für den laufenden Monat an, sobald es einen Jahresplan gibt; erledigt oder gelöscht bleibt sie für diesen Monat weg.
|
||
*/
|
||
export async function finanzsitzungAnlegen(c: Client | Pool, heute: Datum): Promise<void> {
|
||
if (!(await c.query("select 1 from jahresplan limit 1")).rowCount) return;
|
||
const jahr = Number(heute.slice(0, 4)), m = Number(heute.slice(5, 7));
|
||
const serie = `finanzsitzung-${heute.slice(0, 7)}`;
|
||
const vor = m === 1 ? { m: 12, j: jahr - 1 } : { m: m - 1, j: jahr };
|
||
// eine gelöschte Aufgabe nicht wieder anlegen: der Monat steht dann im Protokoll
|
||
if ((await c.query("select 1 from protokoll where tabelle = 'aufgabe' and aktion = 'loeschen' and vorher->>'serie' = $1 limit 1", [serie])).rowCount) return;
|
||
await c.query(`insert into aufgabe (text, faellig_am, serie) values ($1, $2, $3) on conflict (serie) do nothing`,
|
||
[`Finanzsitzung: BWA ${MONATSNAMEN[vor.m - 1]} ${vor.j} durchgehen (Jahresplanung → Plan / Ist)`, ersterFreitag(jahr, m), serie]);
|
||
}
|
||
|
||
interface Hilfen {
|
||
einstellungen: () => Promise<Einstellungen>;
|
||
/** Projekte, Zahlungen und Kosten wie in der Liquidität */
|
||
liquiDaten: () => Promise<Daten>;
|
||
}
|
||
|
||
export function registriereJahresplan(app: FastifyInstance, pool: Pool, h: Hilfen): void {
|
||
const wer = (req: FastifyRequest) => werName(req);
|
||
const heute = () => new Date().toISOString().slice(0, 10);
|
||
|
||
async function laufend(): Promise<LaufendeKosten[]> {
|
||
return (await pool.query("select bezeichnung, kategorie, betrag, rhythmus, start, ende from laufende_kosten")).rows
|
||
.map((l) => ({ bezeichnung: l.bezeichnung, kategorie: l.kategorie ?? undefined, betrag: Number(l.betrag), rhythmus: l.rhythmus, start: l.start, ende: l.ende ?? undefined }));
|
||
}
|
||
|
||
/** Was der Plan aus dem Programm übernehmen kann: laufende Kosten (Personal getrennt), Kontostand, Mindestgrenze, BWA des Vorjahres */
|
||
async function vorlagen(jahr: number) {
|
||
const e = await h.einstellungen();
|
||
const lk = await laufend();
|
||
// im Planjahr laufende Posten, jeder Rhythmus auf den Monat umgerechnet (einmalige zählen nicht)
|
||
const imJahr = (k: LaufendeKosten) => k.rhythmus !== "einmalig" && k.start <= `${jahr}-12-31` && (!k.ende || k.ende >= `${jahr}-01-01`);
|
||
const jeMonat = (k: LaufendeKosten) => (imJahr(k) ? Math.round(k.betrag / ({ monatlich: 1, vierteljaehrlich: 3, jaehrlich: 12, einmalig: 1 } as const)[k.rhythmus]) : 0);
|
||
const istPersonal = (k: LaufendeKosten) => /personal|lohn|gehalt/i.test(`${k.kategorie ?? ""} ${k.bezeichnung}`);
|
||
const posten = lk.filter(imJahr).map((k) => ({ bezeichnung: k.bezeichnung, kategorie: k.kategorie ?? "", monat: jeMonat(k), personal: istPersonal(k) }));
|
||
const ohnePersonal = posten.filter((k) => !k.personal).reduce((x, k) => x + k.monat, 0);
|
||
const personal = posten.filter((k) => k.personal).reduce((x, k) => x + k.monat, 0);
|
||
const mindestgrenze = e.mindestgrenzeArt === "fest" ? e.mindestreserve : laufendJeMonat(lk, heute());
|
||
// BWA des Vorjahres: jüngster Monat mit kumulierten Werten, aufs Jahr hochgerechnet
|
||
const zu = await zuordnung();
|
||
const vj = (await pool.query("select monat, zeilen from finanz_monat where jahr = $1 and zeilen is not null order by monat desc limit 1", [jahr - 1])).rows[0];
|
||
let vorjahr = null;
|
||
if (vj) {
|
||
const ist = istWerte(vj.zeilen, zu, true);
|
||
const f = 12 / vj.monat;
|
||
vorjahr = { monate: vj.monat, umsatz: Math.round(ist.umsatz! * f), material: Math.round(ist.material! * f), laufendMonat: Math.round((ist.laufend! / vj.monat)),
|
||
werbungMonat: Math.round(ist.werbung! / vj.monat), afa: Math.round(ist.afa! * f), tilgungMonat: Math.round(ist.tilgung! / vj.monat),
|
||
steuerQuartal: Math.round((ist.steuer! / vj.monat) * 3), unternehmerlohnMonat: Math.round(ist.unternehmerlohn! / vj.monat) };
|
||
}
|
||
// Saison aus dem Vorjahr: Erlöse je Monat aus den eingelesenen BWA (Monatswerte)
|
||
const monate = (await pool.query("select monat, zeilen from finanz_monat where jahr = $1 and zeilen is not null order by monat", [jahr - 1])).rows;
|
||
const saisonVorjahr = monate.map((r) => ({ monat: r.monat as number, umsatz: istWerte(r.zeilen, zu, false).umsatz! }));
|
||
const personalListe = (await pool.query(`select k.name, m.angestellt, m.lohn_cent, m.eintritt, m.austritt from mitarbeiter m join kontakt k on k.id = m.kontakt_id
|
||
where m.austritt is null or m.austritt >= $1 order by m.angestellt, k.name`, [`${jahr}-01-01`])).rows;
|
||
return { laufend: { ohnePersonal, personal, posten }, kontostand: e.startsaldo, mindestgrenze, vorjahr, saisonVorjahr, personal: personalListe,
|
||
stundensatzEk: (await aktuelleSaetze(pool, heute()))?.stundensaetze.mittellohn ?? e.kalkulation.stundensaetze.geselle };
|
||
}
|
||
|
||
async function zuordnung(): Promise<Map<number, Planzeile>> {
|
||
return new Map((await pool.query("select zeile, planzeile from bwa_zuordnung")).rows.map((r) => [r.zeile as number, r.planzeile as Planzeile]));
|
||
}
|
||
|
||
/** neuer Plan: Annahmen aus laufenden Kosten, Kontostand, Mindestgrenze und, wenn da, der BWA des Vorjahres */
|
||
async function startPlan(jahr: number): Promise<PlanDaten> {
|
||
const v = await vorlagen(jahr);
|
||
const d = leererPlan({
|
||
laufendMonat: v.laufend.ohnePersonal, kontostandStart: v.kontostand, mindestgrenze: v.mindestgrenze,
|
||
...(v.vorjahr ? { materialEinkauf: v.vorjahr.material, werbungMonat: v.vorjahr.werbungMonat, afaBisher: v.vorjahr.afa,
|
||
tilgungBisher: v.vorjahr.tilgungMonat, steuerQuartal: v.vorjahr.steuerQuartal } : {}),
|
||
});
|
||
d.mitarbeiter.push({ id: "inhaber", name: "Inhaber", art: "inhaber", stunden: 900, brutto: v.laufend.personal || v.vorjahr?.unternehmerlohnMonat || 0, faktor: 1, eintritt: 1, austritt: 12, neu: false });
|
||
v.personal.filter((p) => p.angestellt).forEach((p, i) => {
|
||
const ein = p.eintritt && p.eintritt.slice(0, 4) === String(jahr) ? Number(p.eintritt.slice(5, 7)) : 1;
|
||
const aus = p.austritt && p.austritt.slice(0, 4) === String(jahr) ? Number(p.austritt.slice(5, 7)) : 12;
|
||
// Stundenlohn aus Personal × 173 Stunden im Monat
|
||
d.mitarbeiter.push({ id: `m${i + 1}`, name: p.name, art: "angestellt", stunden: 1400, brutto: Math.round(Number(p.lohn_cent ?? 0) * 173), faktor: 1.25, eintritt: ein, austritt: aus, neu: false });
|
||
});
|
||
if (v.saisonVorjahr.length === 12) d.saison = saisonAus(v.saisonVorjahr.map((x) => x.umsatz));
|
||
return d;
|
||
}
|
||
|
||
const zeile = (r: Record<string, any>) => ({ id: r.id, jahr: r.jahr, name: r.name, basis: r.basis, gilt: r.gilt, daten: r.daten as PlanDaten, geaendert_am: r.geaendert_am });
|
||
|
||
const beauftragt = async (jahr: number) => beauftragtJeMonat(await h.liquiDaten(), jahr);
|
||
|
||
app.get("/api/jahresplan", async (req) => {
|
||
const q = z.object({ jahr: Jahr.optional() }).parse(req.query);
|
||
const jahre = (await pool.query("select distinct jahr from jahresplan order by jahr")).rows.map((r) => r.jahr as number);
|
||
const jetzt = Number(heute().slice(0, 4));
|
||
// ohne Angabe: das nächste Jahr ab Oktober, sonst das laufende
|
||
const jahr = q.jahr ?? (jahre.includes(jetzt) && heute().slice(5, 7) < "10" ? jetzt : jahre.find((j) => j > jetzt) ?? (heute().slice(5, 7) >= "10" ? jetzt + 1 : jetzt));
|
||
await finanzsitzungAnlegen(pool, heute());
|
||
const versionen = (await pool.query("select * from jahresplan where jahr = $1 order by basis desc, angelegt_am", [jahr])).rows.map(zeile);
|
||
return { jahr, jahre, versionen, vorlagen: await vorlagen(jahr), beauftragt: await beauftragt(jahr) };
|
||
});
|
||
|
||
app.post("/api/jahresplan", async (req, reply) => {
|
||
const q = z.object({ jahr: Jahr, name: z.string().trim().min(1).max(80).optional(), von: z.uuid().optional(), daten: PlanSchema.optional() }).parse(req.body);
|
||
const daten = q.daten ?? (q.von ? (await pool.query("select daten from jahresplan where id = $1", [q.von])).rows[0]?.daten : await startPlan(q.jahr));
|
||
if (!daten) return reply.status(404).send({ fehler: "Version nicht gefunden" });
|
||
const neu = await transaktion(pool, wer(req), async (c) => {
|
||
const erste = !(await c.query("select 1 from jahresplan where jahr = $1", [q.jahr])).rowCount;
|
||
const r = (await c.query("insert into jahresplan (jahr, name, basis, gilt, daten) values ($1, $2, $3, $3, $4) returning *",
|
||
[q.jahr, q.name ?? (erste ? "Basis" : "Neue Version"), erste, PlanSchema.parse(daten)])).rows[0];
|
||
await finanzsitzungAnlegen(c, heute());
|
||
return r;
|
||
});
|
||
return reply.status(201).send(zeile(neu));
|
||
});
|
||
|
||
app.patch("/api/jahresplan/:id", async (req, reply) => {
|
||
const { id } = z.object({ id: z.uuid() }).parse(req.params);
|
||
const q = z.object({ name: z.string().trim().min(1).max(80).optional(), daten: PlanSchema.optional(), gilt: z.literal(true).optional() }).parse(req.body);
|
||
const r = await transaktion(pool, wer(req), async (c) => {
|
||
const alt = (await c.query("select * from jahresplan where id = $1", [id])).rows[0];
|
||
if (!alt) return null;
|
||
if (q.gilt) await c.query("update jahresplan set gilt = false where jahr = $1 and gilt and id <> $2", [alt.jahr, id]);
|
||
return (await c.query("update jahresplan set name = coalesce($2, name), daten = coalesce($3, daten), gilt = gilt or coalesce($4, false) where id = $1 returning *",
|
||
[id, q.name ?? null, q.daten ?? null, q.gilt ?? null])).rows[0];
|
||
});
|
||
return r ? zeile(r) : reply.status(404).send({ fehler: "Nicht gefunden" });
|
||
});
|
||
|
||
app.delete("/api/jahresplan/:id", async (req, reply) => {
|
||
const { id } = z.object({ id: z.uuid() }).parse(req.params);
|
||
const r = await transaktion(pool, wer(req), async (c) => {
|
||
const alt = (await c.query("select * from jahresplan where id = $1", [id])).rows[0];
|
||
if (!alt) return 404;
|
||
if (alt.basis) return 409;
|
||
await c.query("delete from jahresplan where id = $1", [id]);
|
||
if (alt.gilt) await c.query("update jahresplan set gilt = true where jahr = $1 and basis", [alt.jahr]);
|
||
return 204;
|
||
});
|
||
if (r === 409) return reply.status(409).send({ fehler: "Die Basis bleibt immer erhalten." });
|
||
return r === 204 ? reply.status(204).send() : reply.status(404).send({ fehler: "Nicht gefunden" });
|
||
});
|
||
|
||
/** Vorschläge, um die Lücke zum Gewinnziel zu schließen; ein Klick legt die Version an */
|
||
app.get("/api/jahresplan/:id/vorschlaege", async (req, reply) => {
|
||
const { id } = z.object({ id: z.uuid() }).parse(req.params);
|
||
const p = (await pool.query("select daten from jahresplan where id = $1", [id])).rows[0];
|
||
if (!p) return reply.status(404).send({ fehler: "Nicht gefunden" });
|
||
return vorschlaege(PlanSchema.parse(p.daten)).map(({ daten: _, ...v }) => v);
|
||
});
|
||
|
||
// ---------- BWA und Plan/Ist ----------
|
||
|
||
app.post("/api/bwa", async (req, reply) => {
|
||
const q = z.object({ dateiname: z.string().max(200).default(""), inhalt: z.string().min(1).max(20_000_000) }).parse(req.body);
|
||
let b;
|
||
try { b = liesBwa(q.inhalt); } catch (err) {
|
||
if (err instanceof BwaFehler) return reply.status(400).send({ fehler: err.message });
|
||
throw err;
|
||
}
|
||
const neu = await transaktion(pool, wer(req), async (c) => {
|
||
await c.query(`insert into finanz_monat (jahr, monat, dateiname, bwa_art, eingelesen_am, zeilen) values ($1, $2, $3, $4, now(), $5)
|
||
on conflict (jahr, monat) do update set dateiname = $3, bwa_art = $4, eingelesen_am = now(), zeilen = $5`,
|
||
[b.jahr, b.monat, q.dateiname, b.art, JSON.stringify(b.zeilen)]);
|
||
const da = new Set((await c.query("select zeile from bwa_zuordnung")).rows.map((r) => r.zeile as number));
|
||
const neue = [];
|
||
for (const z of b.zeilen) {
|
||
if (da.has(z.zeile)) continue;
|
||
const p = zuordnungVorschlag(z);
|
||
await c.query("insert into bwa_zuordnung (zeile, bezeichnung, planzeile) values ($1, $2, $3)", [z.zeile, z.bezeichnung, p]);
|
||
if (!z.summe && (z.monat || z.kumuliert)) neue.push({ zeile: z.zeile, bezeichnung: z.bezeichnung, planzeile: p });
|
||
}
|
||
return neue;
|
||
});
|
||
return reply.status(201).send({ jahr: b.jahr, monat: b.monat, art: b.art, zeilen: b.zeilen.length, neu: neu });
|
||
});
|
||
|
||
app.delete("/api/bwa/:jahr/:monat", async (req) => {
|
||
const p = z.object({ jahr: Jahr, monat: z.coerce.number().int().min(1).max(12) }).parse(req.params);
|
||
await transaktion(pool, wer(req), (c) => c.query("update finanz_monat set zeilen = null, dateiname = null, bwa_art = null, eingelesen_am = null where jahr = $1 and monat = $2", [p.jahr, p.monat]));
|
||
return { ok: true };
|
||
});
|
||
|
||
app.put("/api/bwa/zuordnung/:zeile", async (req) => {
|
||
const { zeile: nr } = z.object({ zeile: z.coerce.number().int().min(0).max(99999) }).parse(req.params);
|
||
const { planzeile } = z.object({ planzeile: z.enum([...PLANZEILEN, "ignorieren"]) }).parse(req.body);
|
||
await transaktion(pool, wer(req), (c) => c.query(`insert into bwa_zuordnung (zeile, planzeile) values ($1, $2)
|
||
on conflict (zeile) do update set planzeile = $2`, [nr, planzeile]));
|
||
return { zeile: nr, planzeile };
|
||
});
|
||
|
||
app.put("/api/finanzmonat/:jahr/:monat", async (req) => {
|
||
const p = z.object({ jahr: Jahr, monat: z.coerce.number().int().min(1).max(12) }).parse(req.params);
|
||
const q = z.object({ notizen: z.record(z.string(), z.string().max(500)).optional(), erledigt: z.array(z.string().max(40)).max(30).optional() }).parse(req.body);
|
||
const r = await transaktion(pool, wer(req), async (c) => (await c.query(`insert into finanz_monat (jahr, monat, notizen, erledigt) values ($1, $2, coalesce($3, '{}'::jsonb), coalesce($4, '[]'::jsonb))
|
||
on conflict (jahr, monat) do update set notizen = coalesce($3, finanz_monat.notizen), erledigt = coalesce($4, finanz_monat.erledigt) returning notizen, erledigt`,
|
||
[p.jahr, p.monat, q.notizen ? JSON.stringify(q.notizen) : null, q.erledigt ? JSON.stringify(q.erledigt) : null])).rows[0]);
|
||
return r;
|
||
});
|
||
|
||
app.get("/api/jahresplan/planist", async (req) => {
|
||
const q = z.object({ jahr: Jahr, monat: z.coerce.number().int().min(1).max(12).optional(), kumuliert: z.enum(["0", "1"]).default("0") }).parse(req.query);
|
||
// ohne Plan für das Jahr zeigt die Seite nur die Ist-Werte (z. B. die BWA des laufenden Jahres)
|
||
const plan = (await pool.query("select * from jahresplan where jahr = $1 and gilt", [q.jahr])).rows[0];
|
||
const monate = (await pool.query("select monat, dateiname, bwa_art, eingelesen_am, zeilen is not null as bwa, notizen, erledigt from finanz_monat where jahr = $1 order by monat", [q.jahr])).rows;
|
||
const mitBwa = monate.filter((m) => m.bwa);
|
||
const m = q.monat ?? mitBwa.at(-1)?.monat ?? Math.max(1, Number(heute().slice(5, 7)) - 1);
|
||
const fm = (await pool.query("select * from finanz_monat where jahr = $1 and monat = $2", [q.jahr, m])).rows[0];
|
||
const zu = await zuordnung();
|
||
const kumuliert = q.kumuliert === "1";
|
||
const r = rechne(plan ? PlanSchema.parse(plan.daten) : leererPlan());
|
||
const ergebnis = planIst(r, fm?.zeilen ? istWerte(fm.zeilen, zu, kumuliert) : null, m, kumuliert);
|
||
const alleZeilen = (await pool.query("select zeile, bezeichnung, planzeile from bwa_zuordnung order by zeile")).rows;
|
||
const werte = new Map<number, { monat: number; kumuliert: number; summe: boolean; bezeichnung: string }>((fm?.zeilen ?? []).map((z: any) => [z.zeile, z]));
|
||
return {
|
||
jahr: q.jahr, monat: m, kumuliert, plan: plan ? { id: plan.id, name: plan.name } : null,
|
||
monate: monate.map(({ notizen: _n, erledigt: _e, ...x }) => x),
|
||
bwa: fm?.zeilen ? { dateiname: fm.dateiname, art: fm.bwa_art, eingelesen_am: fm.eingelesen_am } : null,
|
||
notizen: fm?.notizen ?? {}, erledigt: fm?.erledigt ?? [],
|
||
...ergebnis,
|
||
zuordnung: alleZeilen.filter((z) => !werte.get(z.zeile)?.summe).map((z) => ({ ...z, bezeichnung: werte.get(z.zeile)?.bezeichnung ?? z.bezeichnung,
|
||
monatswert: werte.get(z.zeile)?.monat ?? null, kumuliert: werte.get(z.zeile)?.kumuliert ?? null })),
|
||
sitzung: ersterFreitag(m === 12 ? q.jahr + 1 : q.jahr, m === 12 ? 1 : m + 1),
|
||
};
|
||
});
|
||
|
||
app.get("/api/jahresplan/stand", async () => jahresplanStand(pool, h.liquiDaten, heute()));
|
||
}
|
||
|
||
/** beauftragter Umsatz je Monat (netto, nach Rechnungstermin) aus Projekten ab „beauftragt“ */
|
||
function beauftragtJeMonat(d: Daten, jahr: number): number[] {
|
||
const m = Array(12).fill(0);
|
||
for (const e of d.einnahmen) if (e.termin.startsWith(`${jahr}-`)) m[Number(e.termin.slice(5, 7)) - 1] += e.netto;
|
||
return m;
|
||
}
|
||
|
||
/** Übersicht: wie viel Umsatz im Planjahr noch verkauft werden muss (Stufe-5-Abnahme) */
|
||
export async function jahresplanStand(pool: Pool, liquiDaten: () => Promise<Daten>, heute: Datum) {
|
||
const p = (await pool.query("select jahr, name, daten from jahresplan where gilt and jahr >= $1 order by jahr limit 1", [Number(heute.slice(0, 4))])).rows[0];
|
||
if (!p) return null;
|
||
const daten = PlanSchema.parse(p.daten);
|
||
const r = rechne(daten);
|
||
const b = beauftragtJeMonat(await liquiDaten(), p.jahr).reduce((x, y) => x + y, 0);
|
||
return { jahr: p.jahr as number, name: p.name as string, umsatz: r.treppe.umsatz, beauftragt: b, offen: Math.max(0, r.treppe.umsatz - b),
|
||
knapp: knappText(daten, r).satz, gewinnQuote: r.treppe.quoteGewinn };
|
||
}
|
||
|
||
/** gilt-Versionen der Jahre, die die Liquidität als Vorschau braucht */
|
||
export async function geltendePlaene(pool: Pool, vonJahr: number, bisJahr: number): Promise<{ jahr: number; daten: PlanDaten }[]> {
|
||
return (await pool.query("select jahr, daten from jahresplan where gilt and jahr between $1 and $2", [vonJahr, bisJahr])).rows
|
||
.map((r) => ({ jahr: r.jahr as number, daten: PlanSchema.parse(r.daten) }));
|
||
}
|
||
|
||
/** Saison in % aus Umsätzen je Monat, auf ganze Prozent, Summe 100 */
|
||
export function saisonAus(umsaetze: number[]): number[] {
|
||
const s = umsaetze.reduce((a, b) => a + Math.max(0, b), 0);
|
||
if (!s) return [...SAISON_HANDWERK];
|
||
const roh = umsaetze.map((u) => (Math.max(0, u) / s) * 100);
|
||
const ganz = roh.map(Math.floor);
|
||
let rest = 100 - ganz.reduce((a, b) => a + b, 0);
|
||
roh.map((x, i) => [x - Math.floor(x), i] as const).sort((a, b) => b[0] - a[0]).forEach(([, i]) => { if (rest-- > 0) ganz[i]! += 1; });
|
||
return ganz;
|
||
}
|