@@ -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 ! / v j . m o n a t ) ) ,
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 ;
}