Stufe 5: Jahresplanung mit Versionen, 12 Monaten, Plan/Ist und BWA-Import (0.22.0)
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:
305
src/server/jahresplan.ts
Normal file
305
src/server/jahresplan.ts
Normal file
@@ -0,0 +1,305 @@
|
||||
// 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 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: 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;
|
||||
}
|
||||
Reference in New Issue
Block a user