Angebote mit Kalkulation: Leistungsverzeichnis, Kostenzeilen, Versandprüfung, Annehmen macht den Auftrag (0.16.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:
294
src/domain/kalkulation.ts
Normal file
294
src/domain/kalkulation.ts
Normal file
@@ -0,0 +1,294 @@
|
||||
// Angebotskalkulation (Stufe 3a, A2, A19, A28, A32, A37): je Position Kostenzeilen für Lohn, Material, Gerät und
|
||||
// Sonstiges. Kosten je Einheit = Menge × EK × Faktor; Verkauf = Kosten × (1 + Zuschlag) × (1 + Wagnis + Gewinn +
|
||||
// Zahlungsausfall). Der Einheitspreis wird auf den Cent gerundet, Gesamt = Menge × EP, Netto = Summe der Positionen,
|
||||
// die zählen. So gibt es keine Rundungsabweichung wie in Plancraft: Zuschlag in € = Verkauf − Kosten.
|
||||
import type { Cent } from "./geld.js";
|
||||
import { prozentVon } from "./geld.js";
|
||||
|
||||
export const KOSTENARTEN = ["lohn", "material", "geraet", "sonstiges"] as const;
|
||||
export type Kostenart = (typeof KOSTENARTEN)[number];
|
||||
export const KOSTENART_NAME: Record<Kostenart | "ohne", string> = {
|
||||
lohn: "Lohn", material: "Material", geraet: "Gerät", sonstiges: "Sonstiges", ohne: "ohne Kalkulation",
|
||||
};
|
||||
export const LOHNARTEN = ["planer", "geselle", "helfer"] as const;
|
||||
export type Lohnart = (typeof LOHNARTEN)[number];
|
||||
export const LOHNART_NAME: Record<Lohnart, string> = { planer: "Planer", geselle: "Geselle", helfer: "Helfer" };
|
||||
|
||||
// A28: Alternativ- und Eventualpositionen stehen mit Preis da, zählen aber nicht; „eventual_summe“ ist einkalkuliert
|
||||
export const POSITIONSARTEN = ["normal", "alternativ", "eventual", "eventual_summe"] as const;
|
||||
export type Positionsart = (typeof POSITIONSARTEN)[number];
|
||||
export const POSITIONSART_NAME: Record<Positionsart, string> = {
|
||||
normal: "Normal", alternativ: "Alternativ", eventual: "Eventual", eventual_summe: "Eventual, einkalkuliert",
|
||||
};
|
||||
export const zaehlt = (art: Positionsart | string | null | undefined) => !art || art === "normal" || art === "eventual_summe";
|
||||
|
||||
// VOB/C ATV DIN 18334, Abschnitt 0.5 (Henning, 19.10.2026): einheitliche Schreibweise
|
||||
export const EINHEITEN = ["m", "m²", "m³", "St", "kg", "t", "h", "psch"] as const;
|
||||
const SCHREIBWEISE: Record<string, string> = {
|
||||
lfm: "m", lfdm: "m", "m1": "m", m2: "m²", qm: "m²", m3: "m³", cbm: "m³", stk: "St", "stk.": "St", stck: "St", "st.": "St", stück: "St",
|
||||
std: "h", "std.": "h", stunde: "h", stunden: "h", psch: "psch", "psch.": "psch", pauschal: "psch", pausch: "psch",
|
||||
};
|
||||
/** Richtige Schreibweise einer Einheit, oder undefined, wenn sie unbekannt ist */
|
||||
export function einheitRichtig(e: string): string | undefined {
|
||||
const t = e.trim();
|
||||
if ((EINHEITEN as readonly string[]).includes(t)) return t;
|
||||
return SCHREIBWEISE[t.toLowerCase()];
|
||||
}
|
||||
|
||||
export interface Saetze {
|
||||
/** EK-Stundensätze in Cent je Lohnart, beim Anlegen des Angebots festgeschrieben (A36) */
|
||||
stundensaetze: Record<Lohnart, Cent>;
|
||||
/** Standardzuschläge in % je Kostenart */
|
||||
zuschlaege: Record<Kostenart, number>;
|
||||
wagnis: number;
|
||||
gewinn: number;
|
||||
ausfall: number;
|
||||
}
|
||||
|
||||
export interface KKosten {
|
||||
id?: string;
|
||||
position_id: string;
|
||||
kostenart: Kostenart;
|
||||
lohnart?: Lohnart | null;
|
||||
beschreibung?: string | null;
|
||||
/** je Einheit der Position, bei Lohn in Stunden */
|
||||
menge: number | string;
|
||||
einheit?: string | null;
|
||||
/** Cent je Einheit der Kostenzeile; bei Lohn ohne Wert gilt der Stundensatz der Lohnart */
|
||||
ek?: number | string | null;
|
||||
faktor?: number | string | null;
|
||||
zuschlag_prozent?: number | string | null;
|
||||
reihenfolge?: number;
|
||||
}
|
||||
|
||||
export interface KPosition {
|
||||
id: string;
|
||||
titel_id?: string | null;
|
||||
oz?: string | null;
|
||||
kurztext: string;
|
||||
menge: number | string;
|
||||
einheit: string;
|
||||
art?: Positionsart | null;
|
||||
/** fester Einheitspreis in Cent (Position ohne Kalkulation oder „Preis anpassen“) */
|
||||
ep_fest?: number | string | null;
|
||||
reihenfolge?: number;
|
||||
}
|
||||
|
||||
export interface KTitel {
|
||||
id: string;
|
||||
oz?: string | null;
|
||||
bezeichnung: string;
|
||||
reihenfolge?: number;
|
||||
}
|
||||
|
||||
export interface PositionErgebnis {
|
||||
id: string;
|
||||
/** Einheitspreis in Cent */
|
||||
ep: Cent;
|
||||
/** Gesamtbetrag in Cent (zählt nur bei normal und eventual_summe) */
|
||||
gb: Cent;
|
||||
/** Einheitspreis aus der Kalkulation, auch wenn ein fester Preis gilt */
|
||||
ep_kalkuliert: Cent;
|
||||
kosten_je_einheit: Cent;
|
||||
/** Stunden je Einheit und gesamt */
|
||||
std_je_einheit: number;
|
||||
stunden: number;
|
||||
zaehlt: boolean;
|
||||
/** Verkauf je Kostenart (Cent je Einheit, ungerundet) für die Kalkulationsübersicht */
|
||||
vk_je_einheit: Record<Kostenart, number>;
|
||||
kostenzeilen: { id?: string; kosten: number; verkauf: number; ek: number; zuschlag: number }[];
|
||||
}
|
||||
|
||||
export interface KostenartSumme {
|
||||
kosten: Cent;
|
||||
verkauf: Cent;
|
||||
zuschlag: Cent;
|
||||
/** Zuschlag in % der Kosten (null ohne Kosten) */
|
||||
prozent: number | null;
|
||||
}
|
||||
|
||||
export interface AngebotErgebnis {
|
||||
positionen: Record<string, PositionErgebnis>;
|
||||
titel: Record<string, Cent>;
|
||||
netto: Cent;
|
||||
ust: Cent;
|
||||
brutto: Cent;
|
||||
stunden: number;
|
||||
kosten: Cent;
|
||||
/** „möglicher Überschuss“ wie in Plancraft: (Netto − Kosten) / Kosten */
|
||||
ueberschuss_prozent: number | null;
|
||||
kostenarten: Record<Kostenart | "ohne", KostenartSumme>;
|
||||
/** Verkaufswert je Lohnstunde */
|
||||
stundensatz_verkauf: Cent | null;
|
||||
/** § 35a EStG (A34): Arbeits- und Maschinenkosten brutto, für Privatkunden */
|
||||
arbeitskosten_brutto: Cent;
|
||||
}
|
||||
|
||||
const zahl = (v: number | string | null | undefined, sonst = 0) => (v === null || v === undefined || v === "" ? sonst : Number(v));
|
||||
|
||||
/** Kaufmännisch auf ganze Cent; kleine Gleitkommafehler (2,675 → 267,49999…) werden vorher ausgeglichen */
|
||||
export function rundeCent(x: number): Cent {
|
||||
const a = Math.abs(x);
|
||||
const r = Math.floor(a + 0.5 + 1e-7);
|
||||
return x < 0 ? -r : r;
|
||||
}
|
||||
|
||||
/** Ein Betrag nach Gewichten aufgeteilt, Rest nach größtem Bruchteil (Summe stimmt auf den Cent) */
|
||||
export function verteile(betrag: Cent, gewichte: number[]): Cent[] {
|
||||
const summe = gewichte.reduce((s, g) => s + g, 0);
|
||||
if (!(summe > 0)) return gewichte.map(() => 0);
|
||||
const roh = gewichte.map((g) => (betrag * g) / summe);
|
||||
const teile = roh.map((r) => Math.floor(r + 1e-9));
|
||||
let rest = betrag - teile.reduce((s, t) => s + t, 0);
|
||||
const reihenfolge = roh.map((r, i) => [r - Math.floor(r + 1e-9), i] as const).sort((a, b) => b[0] - a[0]);
|
||||
for (let k = 0; rest > 0 && k < reihenfolge.length; k++, rest--) teile[reihenfolge[k]![1]]! += 1;
|
||||
return teile;
|
||||
}
|
||||
|
||||
/** EK einer Kostenzeile in Cent je ihrer Einheit */
|
||||
export function ekVon(k: KKosten, s: Saetze): number {
|
||||
if (k.ek !== null && k.ek !== undefined && k.ek !== "") return Number(k.ek);
|
||||
return k.kostenart === "lohn" ? s.stundensaetze[k.lohnart ?? "geselle"] ?? 0 : 0;
|
||||
}
|
||||
|
||||
export function zuschlagVon(k: KKosten, s: Saetze): number {
|
||||
return k.zuschlag_prozent === null || k.zuschlag_prozent === undefined || k.zuschlag_prozent === "" ? s.zuschlaege[k.kostenart] ?? 0 : Number(k.zuschlag_prozent);
|
||||
}
|
||||
|
||||
export function berechnePosition(p: KPosition, kosten: KKosten[], s: Saetze): PositionErgebnis {
|
||||
const wg = 1 + (s.wagnis + s.gewinn + s.ausfall) / 100;
|
||||
const vk = { lohn: 0, material: 0, geraet: 0, sonstiges: 0 } as Record<Kostenart, number>;
|
||||
let kostenSumme = 0, std = 0;
|
||||
const zeilen = [];
|
||||
for (const k of kosten) {
|
||||
const ek = ekVon(k, s);
|
||||
const z = zuschlagVon(k, s);
|
||||
const kz = zahl(k.menge) * ek * zahl(k.faktor, 1);
|
||||
const v = kz * (1 + z / 100) * wg;
|
||||
kostenSumme += kz;
|
||||
vk[k.kostenart] += v;
|
||||
if (k.kostenart === "lohn") std += zahl(k.menge);
|
||||
zeilen.push({ id: k.id, kosten: kz, verkauf: v, ek, zuschlag: z });
|
||||
}
|
||||
const epKalk = rundeCent(KOSTENARTEN.reduce((t, a) => t + vk[a], 0));
|
||||
const ep = p.ep_fest !== null && p.ep_fest !== undefined && p.ep_fest !== "" ? Number(p.ep_fest) : epKalk;
|
||||
const menge = zahl(p.menge);
|
||||
const z = zaehlt(p.art);
|
||||
return {
|
||||
id: p.id, ep, ep_kalkuliert: epKalk, gb: rundeCent(menge * ep), kosten_je_einheit: rundeCent(kostenSumme),
|
||||
std_je_einheit: std, stunden: Math.round(menge * std * 100) / 100, zaehlt: z, vk_je_einheit: vk, kostenzeilen: zeilen,
|
||||
};
|
||||
}
|
||||
|
||||
export function berechneAngebot(
|
||||
a: { ust_satz?: number },
|
||||
titel: KTitel[], positionen: KPosition[], kosten: KKosten[], s: Saetze,
|
||||
): AngebotErgebnis {
|
||||
const jePosition = new Map<string, KKosten[]>();
|
||||
for (const k of [...kosten].sort((x, y) => (x.reihenfolge ?? 0) - (y.reihenfolge ?? 0))) {
|
||||
jePosition.set(k.position_id, [...(jePosition.get(k.position_id) ?? []), k]);
|
||||
}
|
||||
const erg: Record<string, PositionErgebnis> = {};
|
||||
const titelSumme: Record<string, Cent> = Object.fromEntries(titel.map((t) => [t.id, 0]));
|
||||
const arten = { lohn: [0, 0], material: [0, 0], geraet: [0, 0], sonstiges: [0, 0], ohne: [0, 0] } as Record<Kostenart | "ohne", [number, Cent]>;
|
||||
let netto = 0, stunden = 0;
|
||||
for (const p of positionen) {
|
||||
const r = berechnePosition(p, jePosition.get(p.id) ?? [], s);
|
||||
erg[p.id] = r;
|
||||
if (!r.zaehlt) continue;
|
||||
netto += r.gb;
|
||||
stunden += r.stunden;
|
||||
if (p.titel_id && p.titel_id in titelSumme) titelSumme[p.titel_id]! += r.gb;
|
||||
// Kosten und Verkauf je Kostenart: der Gesamtbetrag der Position wird nach den Verkaufswerten aufgeteilt
|
||||
const menge = zahl(p.menge);
|
||||
for (const k of jePosition.get(p.id) ?? []) {
|
||||
arten[k.kostenart][0] += menge * zahl(k.menge) * ekVon(k, s) * zahl(k.faktor, 1);
|
||||
}
|
||||
const gewichte = KOSTENARTEN.map((x) => r.vk_je_einheit[x]);
|
||||
if (gewichte.some((g) => g > 0)) verteile(r.gb, gewichte).forEach((t, i) => (arten[KOSTENARTEN[i]!][1] += t));
|
||||
else arten.ohne[1] += r.gb;
|
||||
}
|
||||
const kostenarten = {} as Record<Kostenart | "ohne", KostenartSumme>;
|
||||
let kostenGesamt = 0;
|
||||
for (const [art, [k, v]] of Object.entries(arten) as [Kostenart | "ohne", [number, Cent]][]) {
|
||||
const kc = rundeCent(k);
|
||||
kostenGesamt += kc;
|
||||
kostenarten[art] = { kosten: kc, verkauf: v, zuschlag: v - kc, prozent: kc > 0 ? Math.round(((v - kc) / kc) * 10000) / 100 : null };
|
||||
}
|
||||
const satz = a.ust_satz ?? 19;
|
||||
const ust = prozentVon(netto, satz);
|
||||
const arbeit = kostenarten.lohn.verkauf + kostenarten.geraet.verkauf;
|
||||
return {
|
||||
positionen: erg, titel: titelSumme, netto, ust, brutto: netto + ust, stunden: Math.round(stunden * 100) / 100, kosten: kostenGesamt,
|
||||
ueberschuss_prozent: kostenGesamt > 0 ? Math.round(((netto - kostenGesamt) / kostenGesamt) * 1000) / 10 : null,
|
||||
kostenarten,
|
||||
stundensatz_verkauf: stunden > 0 ? rundeCent(kostenarten.lohn.verkauf / stunden) : null,
|
||||
arbeitskosten_brutto: arbeit + prozentVon(arbeit, satz),
|
||||
};
|
||||
}
|
||||
|
||||
export interface Pruefpunkt {
|
||||
/** fehler: so nicht versenden; hinweis: bitte ansehen */
|
||||
stufe: "fehler" | "hinweis";
|
||||
text: string;
|
||||
position_id?: string;
|
||||
}
|
||||
|
||||
const PLATZHALTER = [/\bx-[^\s]*-x\b/i, /\?\?\?/, /\bxxx+\b/i, /\[\s*\]/, /<\s*bitte[^>]*>/i, /\.\.\.\s*$/];
|
||||
|
||||
/** A14 Versandprüfung: Platzhalter, Preise, Einheiten, Bindefrist */
|
||||
export function pruefeAngebot(
|
||||
a: { datum: string; bindefrist?: string | null; kopftext?: string | null; schlusstext?: string | null; betreff?: string | null; empfaenger?: boolean },
|
||||
titel: KTitel[], positionen: KPosition[], kosten: KKosten[], e: AngebotErgebnis, langtexte: Record<string, string | null | undefined> = {},
|
||||
): Pruefpunkt[] {
|
||||
const p: Pruefpunkt[] = [];
|
||||
const name = (x: KPosition) => `${x.oz ? `${x.oz} ` : ""}${x.kurztext}`;
|
||||
if (!positionen.length) p.push({ stufe: "fehler", text: "Das Angebot hat noch keine Position." });
|
||||
if (a.empfaenger === false) p.push({ stufe: "fehler", text: "Beim Projekt ist kein Bauherr als Empfänger eingetragen." });
|
||||
if (a.bindefrist && a.bindefrist < a.datum) p.push({ stufe: "fehler", text: "Die Bindefrist liegt vor dem Angebotsdatum." });
|
||||
for (const [feld, text] of [["Betreff", a.betreff], ["Einleitung", a.kopftext], ["Schlusstext", a.schlusstext]] as const) {
|
||||
if (text && PLATZHALTER.some((r) => r.test(text))) p.push({ stufe: "fehler", text: `Im ${feld} steht noch ein Platzhalter.` });
|
||||
}
|
||||
for (const t of titel) {
|
||||
if (/^neuer titel$/i.test(t.bezeichnung.trim())) p.push({ stufe: "fehler", text: "Ein Titel heißt noch „Neuer Titel“." });
|
||||
if (!positionen.some((x) => x.titel_id === t.id)) p.push({ stufe: "hinweis", text: `Titel „${t.bezeichnung}“ hat keine Position.` });
|
||||
}
|
||||
const ids = new Set(positionen.map((x) => x.id));
|
||||
for (const x of positionen) {
|
||||
const r = e.positionen[x.id];
|
||||
if (/^neue position$/i.test(x.kurztext.trim())) p.push({ stufe: "fehler", text: `Position ${name(x)}: Der Kurztext fehlt noch.`, position_id: x.id });
|
||||
else if (PLATZHALTER.some((re) => re.test(x.kurztext) || re.test(langtexte[x.id] ?? ""))) {
|
||||
p.push({ stufe: "fehler", text: `Position ${name(x)}: Im Text steht noch ein Platzhalter.`, position_id: x.id });
|
||||
}
|
||||
if (!(zahl(x.menge) > 0)) p.push({ stufe: "fehler", text: `Position ${name(x)} hat keine Menge.`, position_id: x.id });
|
||||
if (r && r.ep <= 0) p.push({ stufe: "fehler", text: `Position ${name(x)} hat keinen Preis.`, position_id: x.id });
|
||||
const richtig = einheitRichtig(x.einheit);
|
||||
if (!richtig) p.push({ stufe: "hinweis", text: `Position ${name(x)}: Einheit „${x.einheit}“ gibt es nach DIN 18334 nicht.`, position_id: x.id });
|
||||
else if (richtig !== x.einheit) p.push({ stufe: "hinweis", text: `Position ${name(x)}: Einheit „${x.einheit}“ bitte als „${richtig}“ schreiben.`, position_id: x.id });
|
||||
if (r && x.ep_fest !== null && x.ep_fest !== undefined && x.ep_fest !== "" && r.kosten_je_einheit > 0 && r.ep < r.kosten_je_einheit) {
|
||||
p.push({ stufe: "hinweis", text: `Position ${name(x)}: Der feste Preis liegt unter den Kosten.`, position_id: x.id });
|
||||
}
|
||||
if (x.art === "alternativ" && !(x as { grundposition_id?: string | null }).grundposition_id) {
|
||||
p.push({ stufe: "hinweis", text: `Alternativposition ${name(x)} ist keiner Grundposition zugeordnet.`, position_id: x.id });
|
||||
}
|
||||
}
|
||||
for (const k of kosten) {
|
||||
if (!ids.has(k.position_id)) continue;
|
||||
if (k.kostenart !== "lohn" && !(ekVon(k, { stundensaetze: { planer: 0, geselle: 0, helfer: 0 }, zuschlaege: { lohn: 0, material: 0, geraet: 0, sonstiges: 0 }, wagnis: 0, gewinn: 0, ausfall: 0 }) > 0)) {
|
||||
const x = positionen.find((y) => y.id === k.position_id)!;
|
||||
p.push({ stufe: "hinweis", text: `Position ${name(x)}: ${KOSTENART_NAME[k.kostenart]} „${k.beschreibung || "ohne Text"}“ hat keinen Preis.`, position_id: x.id });
|
||||
}
|
||||
}
|
||||
return p;
|
||||
}
|
||||
|
||||
/** Nächste freie Angebotsnummer im Jahr, Format A-26-121 (wie in Plancraft) */
|
||||
export function naechsteNummer(vorhanden: string[], jahr: number): string {
|
||||
const jj = String(jahr % 100).padStart(2, "0");
|
||||
let max = 0;
|
||||
for (const n of vorhanden) {
|
||||
const m = /^[AP]-(\d{2})-(\d{1,4})/.exec(n.trim());
|
||||
if (m && m[1] === jj) max = Math.max(max, Number(m[2]));
|
||||
}
|
||||
return `A-${jj}-${String(max + 1).padStart(3, "0")}`;
|
||||
}
|
||||
@@ -78,7 +78,7 @@ export function einsatzMatrix(vorgaenge: UeVorgang[], besetzungen: UeBesetzung[]
|
||||
}
|
||||
|
||||
export interface Warnung {
|
||||
art: "ueberschneidung" | "unbesetzt" | "freigabe" | "aufgabe" | "kontostand" | "urlaub" | "freistellung";
|
||||
art: "ueberschneidung" | "unbesetzt" | "freigabe" | "aufgabe" | "kontostand" | "urlaub" | "freistellung" | "angebot";
|
||||
text: string;
|
||||
/** Sprungziel in der App, z. B. "terminplan" */
|
||||
ziel: string;
|
||||
|
||||
277
src/server/angebote.ts
Normal file
277
src/server/angebote.ts
Normal file
@@ -0,0 +1,277 @@
|
||||
// Stufe 3a (Henning, 20.10.2026): Angebote mit Kalkulation. Anlegen mit festgeschriebenen Sätzen (A36),
|
||||
// Versandprüfung (A14), Kalkulationsstand beim Versand und bei Auftrag (A19), „Angebot annehmen“ macht aus dem
|
||||
// Projekt den Auftrag mit Abschnitten, Vorgängen und Zahlungsplan (A4, P9).
|
||||
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 { mitNeuplanung } from "./terminplan.js";
|
||||
import { werName } from "./anmeldung.js";
|
||||
import { type KKosten, type KPosition, type KTitel, type Saetze, berechneAngebot, naechsteNummer, pruefeAngebot } from "../domain/kalkulation.js";
|
||||
import { plusTage } from "../domain/datum.js";
|
||||
import { naechsterArbeitstag } from "../domain/kalender.js";
|
||||
|
||||
const IdParam = z.object({ id: z.uuid() });
|
||||
const heute = () => new Date().toISOString().slice(0, 10);
|
||||
|
||||
export const ANGEBOT_TEILE = new Set(["angebot", "angebot_titel", "angebot_position", "angebot_kosten"]);
|
||||
|
||||
export class AngebotFehler extends Error {
|
||||
statusCode = 409;
|
||||
}
|
||||
|
||||
/** Sätze des Angebots (beim Anlegen kopiert); was fehlt, kommt aus den Einstellungen */
|
||||
export function saetzeVon(a: { saetze?: unknown; wagnis_prozent: unknown; gewinn_prozent: unknown; ausfall_prozent: unknown }, e: Einstellungen): Saetze {
|
||||
const s = (a.saetze ?? {}) as Partial<Pick<Saetze, "stundensaetze" | "zuschlaege">>;
|
||||
return {
|
||||
stundensaetze: { ...e.kalkulation.stundensaetze, ...(s.stundensaetze ?? {}) },
|
||||
zuschlaege: { ...e.kalkulation.zuschlaege, ...(s.zuschlaege ?? {}) },
|
||||
wagnis: Number(a.wagnis_prozent), gewinn: Number(a.gewinn_prozent), ausfall: Number(a.ausfall_prozent),
|
||||
};
|
||||
}
|
||||
|
||||
export async function ladeAngebot(c: Pick<Pool, "query">, id: string, e: Einstellungen) {
|
||||
const angebot = (await c.query(`select a.*, p.nummer as projekt_nummer, p.bezeichnung as projekt_name, p.bauherr_id, p.status as projekt_status,
|
||||
k.name as bauherr_name, k.firma as bauherr_firma
|
||||
from angebot a join projekt p on p.id = a.projekt_id left join kontakt k on k.id = p.bauherr_id where a.id = $1`, [id])).rows[0];
|
||||
if (!angebot) return null;
|
||||
const [t, p, k] = await Promise.all([
|
||||
c.query("select * from angebot_titel where angebot_id = $1 order by reihenfolge, angelegt_am", [id]),
|
||||
c.query("select * from angebot_position where angebot_id = $1 order by reihenfolge, angelegt_am", [id]),
|
||||
c.query("select k.* from angebot_kosten k join angebot_position p on p.id = k.position_id where p.angebot_id = $1 order by k.reihenfolge, k.angelegt_am", [id]),
|
||||
]);
|
||||
const saetze = saetzeVon(angebot, e);
|
||||
const titel = t.rows as KTitel[], positionen = p.rows as (KPosition & { langtext?: string | null })[], kosten = k.rows as KKosten[];
|
||||
const ergebnis = berechneAngebot({ ust_satz: e.ust.satz }, titel, positionen, kosten, saetze);
|
||||
return { angebot, titel, positionen, kosten, saetze, ergebnis };
|
||||
}
|
||||
|
||||
function pruefung(x: NonNullable<Awaited<ReturnType<typeof ladeAngebot>>>) {
|
||||
return pruefeAngebot({ ...x.angebot, empfaenger: !!x.angebot.bauherr_id }, x.titel, x.positionen, x.kosten, x.ergebnis,
|
||||
Object.fromEntries(x.positionen.map((p) => [p.id, p.langtext])));
|
||||
}
|
||||
|
||||
/** A19: Kalkulation unveränderlich ablegen */
|
||||
function stand(x: NonNullable<Awaited<ReturnType<typeof ladeAngebot>>>, anlass: "versand" | "auftrag", wer: string) {
|
||||
return {
|
||||
anlass, am: new Date().toISOString(), von: wer, saetze: x.saetze,
|
||||
netto: x.ergebnis.netto, brutto: x.ergebnis.brutto, stunden: x.ergebnis.stunden, kosten: x.ergebnis.kosten,
|
||||
kostenarten: x.ergebnis.kostenarten, titel: x.titel, positionen: x.positionen.map((p) => ({ ...p, ergebnis: x.ergebnis.positionen[p.id] })),
|
||||
kosten_zeilen: x.kosten,
|
||||
};
|
||||
}
|
||||
|
||||
/** Bearbeiten geht nur im Entwurf; danach gilt der festgeschriebene Stand (A19) */
|
||||
export async function pruefeBearbeitbar(c: Client, tabelle: string, id: string | undefined, daten: Record<string, unknown>): Promise<void> {
|
||||
if (!ANGEBOT_TEILE.has(tabelle)) return;
|
||||
const ids: string[] = [];
|
||||
const angebotVon = async (sql: string, wert: unknown) => {
|
||||
if (typeof wert === "string") {
|
||||
const r = (await c.query(sql, [wert])).rows[0];
|
||||
if (r) ids.push(r.angebot_id);
|
||||
}
|
||||
};
|
||||
if (tabelle === "angebot") {
|
||||
if (!id) return;
|
||||
// nur die Notiz bleibt nach dem Versand änderbar
|
||||
if (Object.keys(daten).every((k) => k === "notiz" || daten[k] === undefined)) return;
|
||||
ids.push(id);
|
||||
} else if (tabelle === "angebot_titel") {
|
||||
if (id) await angebotVon("select angebot_id from angebot_titel where id = $1", id);
|
||||
await angebotVon("select id as angebot_id from angebot where id = $1", daten.angebot_id);
|
||||
} else if (tabelle === "angebot_position") {
|
||||
if (id) await angebotVon("select angebot_id from angebot_position where id = $1", id);
|
||||
await angebotVon("select id as angebot_id from angebot where id = $1", daten.angebot_id);
|
||||
} else {
|
||||
if (id) await angebotVon("select p.angebot_id from angebot_kosten k join angebot_position p on p.id = k.position_id where k.id = $1", id);
|
||||
await angebotVon("select angebot_id from angebot_position where id = $1", daten.position_id);
|
||||
}
|
||||
for (const a of ids) {
|
||||
const s = (await c.query("select status, nummer from angebot where id = $1", [a])).rows[0];
|
||||
if (s && s.status !== "entwurf") {
|
||||
throw new AngebotFehler(`Angebot ${s.nummer} ist ${s.status === "versendet" ? "versendet" : s.status}. Zum Ändern zuerst „Wieder bearbeiten“ wählen.`);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
const NeuSchema = z.object({
|
||||
projekt_id: z.uuid(),
|
||||
belegart: z.enum(["angebot", "kostenvoranschlag"]).default("angebot"),
|
||||
// Kopie eines anderen Angebots (neue Version, Vorlage aus einem früheren Angebot)
|
||||
von_angebot_id: z.uuid().optional(),
|
||||
});
|
||||
|
||||
async function kopiereInhalt(c: Client, von: string, nach: string): Promise<void> {
|
||||
const titelNeu = new Map<string, string>();
|
||||
for (const t of (await c.query("select * from angebot_titel where angebot_id = $1 order by reihenfolge", [von])).rows) {
|
||||
const n = (await c.query("insert into angebot_titel (angebot_id, oz, bezeichnung, reihenfolge) values ($1, $2, $3, $4) returning id", [nach, t.oz, t.bezeichnung, t.reihenfolge])).rows[0];
|
||||
titelNeu.set(t.id, n.id);
|
||||
}
|
||||
const posNeu = new Map<string, string>();
|
||||
const positionen = (await c.query("select * from angebot_position where angebot_id = $1 order by reihenfolge", [von])).rows;
|
||||
for (const p of positionen) {
|
||||
const n = (await c.query(`insert into angebot_position (angebot_id, titel_id, oz, kurztext, langtext, menge, einheit, art, ep_fest, reihenfolge)
|
||||
values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10) returning id`,
|
||||
[nach, p.titel_id ? titelNeu.get(p.titel_id) : null, p.oz, p.kurztext, p.langtext, p.menge, p.einheit, p.art, p.ep_fest, p.reihenfolge])).rows[0];
|
||||
posNeu.set(p.id, n.id);
|
||||
}
|
||||
for (const p of positionen) {
|
||||
if (p.grundposition_id && posNeu.has(p.grundposition_id)) await c.query("update angebot_position set grundposition_id = $2 where id = $1", [posNeu.get(p.id), posNeu.get(p.grundposition_id)]);
|
||||
}
|
||||
const kosten = (await c.query("select k.* from angebot_kosten k join angebot_position p on p.id = k.position_id where p.angebot_id = $1", [von])).rows;
|
||||
for (const k of kosten) {
|
||||
await c.query(`insert into angebot_kosten (position_id, kostenart, lohnart, beschreibung, menge, einheit, ek, faktor, faktor_grund, zuschlag_prozent, reihenfolge)
|
||||
values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)`,
|
||||
[posNeu.get(k.position_id), k.kostenart, k.lohnart, k.beschreibung, k.menge, k.einheit, k.ek, k.faktor, k.faktor_grund, k.zuschlag_prozent, k.reihenfolge]);
|
||||
}
|
||||
}
|
||||
|
||||
export function registriereAngebote(
|
||||
app: FastifyInstance, pool: Pool, einstellungen: () => Promise<Einstellungen>,
|
||||
nachProjekt: (p: Record<string, any>, wer: string) => Promise<Record<string, unknown>>,
|
||||
): void {
|
||||
const wer = (req: FastifyRequest) => werName(req);
|
||||
|
||||
// Liste aller Angebote mit Summen, für die Seite Angebote und die Dokumente eines Projekts
|
||||
app.get("/api/angebote-liste", async (req) => {
|
||||
const q = z.object({ projekt_id: z.uuid().optional() }).parse(req.query);
|
||||
const e = await einstellungen();
|
||||
const r = await pool.query(`select a.id from angebot a ${q.projekt_id ? "where a.projekt_id = $1" : ""} order by a.datum desc, a.nummer desc`, q.projekt_id ? [q.projekt_id] : []);
|
||||
const liste = [];
|
||||
for (const { id } of r.rows) {
|
||||
const x = (await ladeAngebot(pool, id, e))!;
|
||||
const { staende: _s, saetze: _t, kopftext: _k, schlusstext: _l, ...kopf } = x.angebot;
|
||||
liste.push({ ...kopf, netto: x.ergebnis.netto, brutto: x.ergebnis.brutto, stunden: x.ergebnis.stunden, positionen: x.positionen.length });
|
||||
}
|
||||
return liste;
|
||||
});
|
||||
|
||||
app.post("/api/angebote/neu", async (req, reply) => {
|
||||
const q = NeuSchema.parse(req.body);
|
||||
const e = await einstellungen();
|
||||
const a = await transaktion(pool, wer(req), async (c) => {
|
||||
const p = (await c.query("select id, nummer, status from projekt where id = $1", [q.projekt_id])).rows[0];
|
||||
if (!p) return null;
|
||||
const nummern = (await c.query("select nummer from angebot union all select nummer from projekt")).rows.map((r) => r.nummer as string);
|
||||
const belegt = new Set((await c.query("select nummer from angebot")).rows.map((r) => r.nummer as string));
|
||||
// das erste Angebot eines Projekts mit A-Nummer bekommt dessen Nummer (E18), sonst die nächste freie
|
||||
const nummer = /^A-\d{2}-\d+/.test(p.nummer) && !belegt.has(p.nummer) ? p.nummer : naechsteNummer(nummern, new Date().getFullYear());
|
||||
const k = e.kalkulation;
|
||||
const datum = heute();
|
||||
const vorlage = q.von_angebot_id ? (await c.query("select * from angebot where id = $1", [q.von_angebot_id])).rows[0] : undefined;
|
||||
const neu = (await c.query(`insert into angebot (projekt_id, nummer, belegart, datum, bindefrist, betreff, kopftext, schlusstext, wagnis_prozent, gewinn_prozent, ausfall_prozent, saetze)
|
||||
values ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12) returning *`,
|
||||
[q.projekt_id, nummer, vorlage?.belegart ?? q.belegart, datum, k.bindefristWochen ? plusTage(datum, 7 * k.bindefristWochen) : null,
|
||||
vorlage?.betreff ?? null, vorlage?.kopftext ?? k.kopftext, vorlage?.schlusstext ?? k.schlusstext,
|
||||
vorlage?.wagnis_prozent ?? k.wagnis, vorlage?.gewinn_prozent ?? k.gewinn, vorlage?.ausfall_prozent ?? k.ausfall,
|
||||
// A36: Sätze von heute festschreiben; eine Kopie übernimmt die Sätze nicht, sondern bekommt die aktuellen
|
||||
{ stundensaetze: k.stundensaetze, zuschlaege: k.zuschlaege, stand: datum }])).rows[0];
|
||||
if (vorlage) await kopiereInhalt(c, vorlage.id, neu.id);
|
||||
if (p.status === "anfrage") await c.query("update projekt set status = 'angebot' where id = $1", [p.id]);
|
||||
return neu;
|
||||
});
|
||||
if (!a) return reply.status(404).send({ fehler: "Projekt nicht gefunden" });
|
||||
return reply.status(201).send(a);
|
||||
});
|
||||
|
||||
app.get("/api/angebote/:id/voll", async (req, reply) => {
|
||||
const { id } = IdParam.parse(req.params);
|
||||
const x = await ladeAngebot(pool, id, await einstellungen());
|
||||
if (!x) return reply.status(404).send({ fehler: "Nicht gefunden" });
|
||||
return { ...x, pruefung: pruefung(x) };
|
||||
});
|
||||
|
||||
// A14: vor dem Versand prüfen; mit Fehlern nur, wenn ausdrücklich „trotzdem“
|
||||
app.post("/api/angebote/:id/versenden", async (req, reply) => {
|
||||
const { id } = IdParam.parse(req.params);
|
||||
const q = z.object({ trotzdem: z.boolean().default(false), datum: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional() }).parse(req.body ?? {});
|
||||
const e = await einstellungen();
|
||||
const r = await transaktion(pool, wer(req), async (c) => {
|
||||
const x = await ladeAngebot(c, id, e);
|
||||
if (!x) return null;
|
||||
if (x.angebot.status !== "entwurf") throw new AngebotFehler("Das Angebot ist nicht mehr im Entwurf.");
|
||||
const p = pruefung(x);
|
||||
if (p.some((f) => f.stufe === "fehler") && !q.trotzdem) return { pruefung: p, versendet: false };
|
||||
const am = q.datum ?? heute();
|
||||
await c.query("update angebot set status = 'versendet', versendet_am = $2, staende = staende || $3::jsonb where id = $1",
|
||||
[id, am, JSON.stringify([stand(x, "versand", wer(req))])]);
|
||||
if (["anfrage"].includes(x.angebot.projekt_status)) await c.query("update projekt set status = 'angebot' where id = $1", [x.angebot.projekt_id]);
|
||||
return { pruefung: p, versendet: true };
|
||||
});
|
||||
if (!r) return reply.status(404).send({ fehler: "Nicht gefunden" });
|
||||
return r;
|
||||
});
|
||||
|
||||
// Zurück in den Entwurf, z. B. nach Rückfrage des Kunden; der versendete Stand bleibt in den Ständen erhalten
|
||||
app.post("/api/angebote/:id/bearbeiten", async (req, reply) => {
|
||||
const { id } = IdParam.parse(req.params);
|
||||
const r = await transaktion(pool, wer(req), async (c) =>
|
||||
(await c.query("update angebot set status = 'entwurf', entschieden_am = null where id = $1 and status in ('versendet', 'abgelehnt') returning *", [id])).rows[0]);
|
||||
return r ?? reply.status(409).send({ fehler: "Nur ein versendetes oder abgelehntes Angebot lässt sich wieder bearbeiten." });
|
||||
});
|
||||
|
||||
app.post("/api/angebote/:id/ablehnen", async (req, reply) => {
|
||||
const { id } = IdParam.parse(req.params);
|
||||
const r = await transaktion(pool, wer(req), async (c) =>
|
||||
(await c.query("update angebot set status = 'abgelehnt', entschieden_am = $2 where id = $1 and status in ('entwurf', 'versendet') returning *", [id, heute()])).rows[0]);
|
||||
return r ?? reply.status(409).send({ fehler: "Dieses Angebot lässt sich nicht als abgelehnt markieren." });
|
||||
});
|
||||
|
||||
// A4: Angebot annehmen → Auftrag. Titel werden Abschnitte mit je einem Vorgang (Stunden aus der Kalkulation),
|
||||
// der Auftragswert ist die Summe der angenommenen Angebote, der Zahlungsplan entsteht nach P9 von selbst.
|
||||
app.post("/api/angebote/:id/annehmen", async (req, reply) => {
|
||||
const { id } = IdParam.parse(req.params);
|
||||
const q = z.object({ start: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(), personen: z.number().positive().max(20).default(2) }).parse(req.body ?? {});
|
||||
const e = await einstellungen();
|
||||
const woche = { tage: e.arbeitstage };
|
||||
const r = await transaktion(pool, wer(req), async (c) => (await mitNeuplanung(c, woche, async () => {
|
||||
const x = await ladeAngebot(c, id, e);
|
||||
if (!x) return null;
|
||||
if (!["entwurf", "versendet"].includes(x.angebot.status)) throw new AngebotFehler("Das Angebot ist schon angenommen oder abgelehnt.");
|
||||
if (!x.positionen.length) throw new AngebotFehler("Das Angebot hat noch keine Position.");
|
||||
await c.query("update angebot set status = 'angenommen', entschieden_am = $2, versendet_am = coalesce(versendet_am, $2), staende = staende || $3::jsonb where id = $1",
|
||||
[id, heute(), JSON.stringify([stand(x, "auftrag", wer(req))])]);
|
||||
const pid = x.angebot.projekt_id as string;
|
||||
const p = (await c.query("select * from projekt where id = $1", [pid])).rows[0];
|
||||
// Auftragswert: alle angenommenen Angebote des Projekts (ein zweites Angebot kann ein Nachtrag sein)
|
||||
const summe = (await c.query("select id from angebot where projekt_id = $1 and status = 'angenommen'", [pid])).rows;
|
||||
let umsatz = 0;
|
||||
for (const s of summe) umsatz += s.id === id ? x.ergebnis.netto : (await ladeAngebot(c, s.id, e))!.ergebnis.netto;
|
||||
const nummer = /^A-/.test(p.nummer) && !(await c.query("select 1 from projekt where nummer = $1", [p.nummer.replace(/^A-/, "P-")])).rowCount
|
||||
? p.nummer.replace(/^A-/, "P-") : p.nummer;
|
||||
const status = ["anfrage", "angebot"].includes(p.status) ? "auftrag" : p.status;
|
||||
// geplante Kosten für die Liquidität, nur wenn noch keine eingetragen sind
|
||||
const leer = !Number(p.material_kosten) && !Number(p.fremd_kosten) && !Number(p.sonstige_kosten);
|
||||
const ka = x.ergebnis.kostenarten;
|
||||
await c.query(`update projekt set umsatz_netto = $2, status = $3, nummer = $4,
|
||||
material_kosten = case when $5 then $6 else material_kosten end, sonstige_kosten = case when $5 then $7 else sonstige_kosten end,
|
||||
soll_stunden = coalesce(soll_stunden, 0) + $8 where id = $1`,
|
||||
[pid, umsatz, status, nummer, leer, ka.material.kosten + ka.geraet.kosten, ka.sonstiges.kosten, x.ergebnis.stunden]);
|
||||
// Abschnitte nur, wenn das Projekt noch keinen Terminplan hat
|
||||
const abschnitte = (await c.query("select count(*)::int as n from abschnitt where projekt_id = $1", [pid])).rows[0].n;
|
||||
let neu = 0;
|
||||
if (!abschnitte) {
|
||||
const gruppen = x.titel.length
|
||||
? x.titel.map((t) => ({ name: t.bezeichnung, stunden: x.positionen.filter((p) => p.titel_id === t.id).reduce((s, p) => s + (x.ergebnis.positionen[p.id]!.zaehlt ? x.ergebnis.positionen[p.id]!.stunden : 0), 0) }))
|
||||
: [{ name: "Ausführung", stunden: x.ergebnis.stunden }];
|
||||
let start = q.start ? naechsterArbeitstag(q.start, woche) : naechsterArbeitstag(plusTage(heute(), 14), woche);
|
||||
let vorher: string | null = null;
|
||||
for (const [i, g] of gruppen.entries()) {
|
||||
const ab = (await c.query("insert into abschnitt (projekt_id, name, reihenfolge) values ($1, $2, $3) returning id", [pid, g.name, i])).rows[0];
|
||||
const stunden = Math.round(g.stunden * 100) / 100;
|
||||
const dauer = Math.max(1, Math.ceil(stunden / (e.stundenProTag * q.personen)));
|
||||
const v: { id: string } = (await c.query("insert into vorgang (abschnitt_id, name, start, dauer, stunden, personen, reihenfolge) values ($1, $2, $3, $4, $5, $6, 0) returning id",
|
||||
[ab.id, g.name, start, dauer, stunden > 0 ? stunden : null, q.personen])).rows[0];
|
||||
if (vorher) await c.query("insert into vorgang_vorgaenger (vorgang_id, vorgaenger_id, art) values ($1, $2, 'EA')", [v.id, vorher]);
|
||||
vorher = v.id;
|
||||
start = naechsterArbeitstag(plusTage(start, 1), woche);
|
||||
neu++;
|
||||
}
|
||||
}
|
||||
return { projekt_id: pid, nummer, umsatz, abschnitte: neu };
|
||||
}, [], e.stundenProTag, e.aufgabenVorlage)).ergebnis);
|
||||
if (!r) return reply.status(404).send({ fehler: "Nicht gefunden" });
|
||||
const p = (await pool.query("select * from projekt where id = $1", [r.projekt_id])).rows[0];
|
||||
return { ...r, projekt: await nachProjekt(p, wer(req)) };
|
||||
});
|
||||
}
|
||||
@@ -25,6 +25,7 @@ import { registrierePersonal } from "./personal.js";
|
||||
import { registriereZeiten } from "./zeiten.js";
|
||||
import { registriereUrlaub, zeitraumText } from "./urlaub.js";
|
||||
import { vorlageAnwenden } from "./vorlage.js";
|
||||
import { AngebotFehler, pruefeBearbeitbar, registriereAngebote } from "./angebote.js";
|
||||
import { type BezugArt, bezugsTage } from "../domain/bezug.js";
|
||||
import { formatDatum, plusTage } from "../domain/datum.js";
|
||||
|
||||
@@ -91,6 +92,8 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
}
|
||||
}
|
||||
|
||||
registriereAngebote(app, pool, ladeEinstellungen, mitOrdner);
|
||||
|
||||
app.post("/api/projekte/:id/ordner", async (req, reply) => {
|
||||
const { id } = IdParam.parse(req.params);
|
||||
const p = (await pool.query("select * from projekt where id = $1", [id])).rows[0];
|
||||
@@ -217,6 +220,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
if (verboten(req, t, daten)) return reply.status(403).send({ fehler: "Dafür fehlt dir die Berechtigung." });
|
||||
const row = await transaktion(pool, benutzer(req), async (c) => {
|
||||
if (t.name === "vorgang_vorgaenger") await pruefeVerknuepfung(c, daten as { vorgang_id: string; vorgaenger_id: string });
|
||||
await pruefeBearbeitbar(c, t.name, undefined, daten);
|
||||
await versatzAusDatum(c, t.name, daten);
|
||||
const spalten = felder.filter((f) => daten[f] !== undefined);
|
||||
return geplant(c, t.name, async () =>
|
||||
@@ -241,6 +245,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
if (t.name === "kosten" && daten.netto !== undefined && daten.automatisch === undefined) daten.automatisch = false;
|
||||
if (felder.every((f) => daten[f] === undefined)) return reply.status(400).send({ fehler: "Keine Änderung angegeben" });
|
||||
const row = await transaktion(pool, benutzer(req), async (c) => {
|
||||
await pruefeBearbeitbar(c, t.name, id, daten);
|
||||
await versatzAusDatum(c, t.name, daten, id);
|
||||
const spalten = felder.filter((f) => daten[f] !== undefined);
|
||||
if (t.name === "vorgang_vorgaenger" && (daten.vorgang_id || daten.vorgaenger_id)) {
|
||||
@@ -260,8 +265,14 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
|
||||
app.delete(`/api/${t.pfad}/:id`, async (req, reply) => {
|
||||
const { id } = IdParam.parse(req.params);
|
||||
const n = await transaktion(pool, benutzer(req), async (c) =>
|
||||
geplant(c, t.name, async () => (await c.query(`delete from ${t.name} where id = $1`, [id])).rowCount, [], await projektDerZahlung(c, t.name, id)));
|
||||
const n = await transaktion(pool, benutzer(req), async (c) => {
|
||||
// ein angenommenes Angebot ist das Soll der Nachkalkulation (A19) und bleibt
|
||||
if (t.name === "angebot" && (await c.query("select 1 from angebot where id = $1 and status = 'angenommen'", [id])).rowCount) {
|
||||
throw new AngebotFehler("Ein angenommenes Angebot lässt sich nicht löschen.");
|
||||
}
|
||||
await pruefeBearbeitbar(c, t.name === "angebot" ? "" : t.name, id, {});
|
||||
return geplant(c, t.name, async () => (await c.query(`delete from ${t.name} where id = $1`, [id])).rowCount, [], await projektDerZahlung(c, t.name, id));
|
||||
});
|
||||
return n ? reply.status(204).send() : reply.status(404).send({ fehler: "Nicht gefunden" });
|
||||
});
|
||||
}
|
||||
@@ -351,6 +362,15 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
: !bis && eingeplant.has(s.id) ? `${s.name} ist eingeplant, aber ohne Freistellungsbescheinigung (§ 48b)` : "";
|
||||
if (text) u.warnungen.push({ art: "freistellung", ziel: `subunternehmer-${s.id}`, text });
|
||||
}
|
||||
// A35: Bindefrist eines versendeten Angebots läuft bald ab
|
||||
const bis = plusTage(heute, e.kalkulation.erinnerungTage);
|
||||
const angebote = await pool.query(`select a.id, a.nummer, a.bindefrist, p.bezeichnung from angebot a join projekt p on p.id = a.projekt_id
|
||||
where a.status = 'versendet' and a.bindefrist is not null and a.bindefrist <= $1 order by a.bindefrist`, [bis]);
|
||||
for (const a of angebote.rows) {
|
||||
u.warnungen.push({ art: "angebot", ziel: `angebot-${a.id}`,
|
||||
text: a.bindefrist < heute ? `Bindefrist von Angebot ${a.nummer} (${a.bezeichnung}) ist seit ${formatDatum(a.bindefrist)} abgelaufen`
|
||||
: `Bindefrist von Angebot ${a.nummer} (${a.bezeichnung}) endet am ${formatDatum(a.bindefrist)}, nachfassen?` });
|
||||
}
|
||||
return u;
|
||||
});
|
||||
|
||||
|
||||
@@ -50,6 +50,25 @@ export const EinstellungenSchema = z.object({
|
||||
// geheimer Teil der Kalender-Links (T11); Outlook classic kann sich nicht anmelden
|
||||
kalenderToken: z.string().min(20).nullable().default(null),
|
||||
aufgabenVorlage: z.array(VorlageEintrag).max(50).default(STANDARD_VORLAGE),
|
||||
// Stufe 3a: Vorgaben der Angebotskalkulation. Stundensätze (EK, Cent) gelten, bis Hennings Stundensatz-Excel da ist
|
||||
kalkulation: z
|
||||
.object({
|
||||
stundensaetze: z
|
||||
.object({ planer: z.number().int().min(0).default(8000), geselle: z.number().int().min(0).default(5831), helfer: z.number().int().min(0).default(5000) })
|
||||
.prefault({}),
|
||||
zuschlaege: z
|
||||
.object({ lohn: z.number().min(0).max(500).default(20), material: z.number().min(0).max(500).default(5), geraet: z.number().min(0).max(500).default(10), sonstiges: z.number().min(0).max(500).default(10) })
|
||||
.prefault({}),
|
||||
wagnis: z.number().min(0).max(50).default(5),
|
||||
gewinn: z.number().min(0).max(50).default(5),
|
||||
ausfall: z.number().min(0).max(50).default(5),
|
||||
bindefristWochen: z.number().int().min(0).max(52).default(4),
|
||||
// A35: so viele Tage vor Ablauf der Bindefrist erscheint die Erinnerung auf der Startseite
|
||||
erinnerungTage: z.number().int().min(0).max(60).default(5),
|
||||
kopftext: z.string().max(5000).default("vielen Dank für Ihre Anfrage. Gern bieten wir Ihnen die folgenden Leistungen an:"),
|
||||
schlusstext: z.string().max(5000).default("An dieses Angebot halten wir uns bis zum {bindefrist} gebunden. Wir freuen uns auf Ihren Auftrag."),
|
||||
})
|
||||
.prefault({}),
|
||||
});
|
||||
|
||||
export type Einstellungen = z.infer<typeof EinstellungenSchema>;
|
||||
|
||||
@@ -54,8 +54,17 @@ export async function baustellenKalender(pool: Pool, woche: Arbeitswoche): Promi
|
||||
export async function aufgabenKalender(pool: Pool): Promise<string> {
|
||||
const r = await pool.query(`select a.id, a.text, a.faellig_am, a.geaendert_am, p.nummer from aufgabe a left join projekt p on p.id = a.projekt_id
|
||||
where a.erledigt_am is null and a.faellig_am is not null`);
|
||||
return kalender("Aufgaben", r.rows.map((a) => ({
|
||||
uid: `${a.id}@betrieb.schaarschmidt-holzbau.de`, von: a.faellig_am, bis: a.faellig_am,
|
||||
titel: `Aufgabe: ${a.text}${a.nummer ? ` (${a.nummer})` : ""}`, geaendert: a.geaendert_am,
|
||||
})));
|
||||
// A35: Ende der Bindefrist offener Angebote als Termin (Outlook classic gleicht keine Aufgaben ab, E15)
|
||||
const b = await pool.query(`select a.id, a.nummer, a.bindefrist, a.geaendert_am, p.bezeichnung from angebot a join projekt p on p.id = a.projekt_id
|
||||
where a.status = 'versendet' and a.bindefrist is not null`);
|
||||
return kalender("Aufgaben", [
|
||||
...r.rows.map((a) => ({
|
||||
uid: `${a.id}@betrieb.schaarschmidt-holzbau.de`, von: a.faellig_am, bis: a.faellig_am,
|
||||
titel: `Aufgabe: ${a.text}${a.nummer ? ` (${a.nummer})` : ""}`, geaendert: a.geaendert_am,
|
||||
})),
|
||||
...b.rows.map((a) => ({
|
||||
uid: `bindefrist-${a.id}@betrieb.schaarschmidt-holzbau.de`, von: a.bindefrist, bis: a.bindefrist,
|
||||
titel: `Bindefrist Angebot ${a.nummer} (${a.bezeichnung})`, geaendert: a.geaendert_am,
|
||||
})),
|
||||
]);
|
||||
}
|
||||
|
||||
97
src/server/migrations/014_angebote.sql
Normal file
97
src/server/migrations/014_angebote.sql
Normal file
@@ -0,0 +1,97 @@
|
||||
-- Stufe 3a (Henning, 20.10.2026): Angebote mit Kalkulation im Programm statt in Plancraft.
|
||||
-- Ein Projekt kann mehrere Angebote haben; „Angebot annehmen“ macht daraus den Auftrag (A4).
|
||||
|
||||
create table angebot (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
projekt_id uuid not null references projekt (id) on delete cascade,
|
||||
nummer text not null unique,
|
||||
-- A7: Kostenvoranschlag aus derselben Kalkulation, als „unverbindlich“ gekennzeichnet
|
||||
belegart text not null default 'angebot' check (belegart in ('angebot', 'kostenvoranschlag')),
|
||||
status text not null default 'entwurf' check (status in ('entwurf', 'versendet', 'angenommen', 'abgelehnt')),
|
||||
datum date not null default current_date,
|
||||
-- A35: Standard 4 Wochen ab Angebotsdatum
|
||||
bindefrist date,
|
||||
betreff text,
|
||||
kopftext text,
|
||||
schlusstext text,
|
||||
-- A37: Wagnis, Gewinn und Zahlungsausfall je Angebot, zusätzlich zu den Zuschlägen je Kostenart
|
||||
wagnis_prozent numeric(6, 2) not null default 5,
|
||||
gewinn_prozent numeric(6, 2) not null default 5,
|
||||
ausfall_prozent numeric(6, 2) not null default 5,
|
||||
-- A36: Stundensätze (Cent je Lohnart) und Standardzuschläge beim Anlegen festgeschrieben
|
||||
saetze jsonb not null default '{}',
|
||||
-- A19: festgeschriebene Kalkulationsstände (beim Versand und bei Auftrag), neueste zuletzt
|
||||
staende jsonb not null default '[]',
|
||||
versendet_am date,
|
||||
entschieden_am date,
|
||||
notiz 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'
|
||||
);
|
||||
create index angebot_projekt on angebot (projekt_id);
|
||||
create trigger angebot_protokoll before insert or update or delete on angebot
|
||||
for each row execute function stempel_und_protokoll();
|
||||
|
||||
create table angebot_titel (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
angebot_id uuid not null references angebot (id) on delete cascade,
|
||||
oz text,
|
||||
bezeichnung text not null,
|
||||
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 angebot_titel_angebot on angebot_titel (angebot_id);
|
||||
create trigger angebot_titel_protokoll before insert or update or delete on angebot_titel
|
||||
for each row execute function stempel_und_protokoll();
|
||||
|
||||
create table angebot_position (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
angebot_id uuid not null references angebot (id) on delete cascade,
|
||||
titel_id uuid references angebot_titel (id) on delete cascade,
|
||||
oz text,
|
||||
kurztext text not null,
|
||||
langtext text,
|
||||
menge numeric(14, 4) not null default 1,
|
||||
einheit text not null default 'St',
|
||||
-- A28: normal, alternativ (zu einer Grundposition), eventual (ohne Gesamtbetrag), eventual_summe (einkalkuliert)
|
||||
art text not null default 'normal' check (art in ('normal', 'alternativ', 'eventual', 'eventual_summe')),
|
||||
grundposition_id uuid references angebot_position (id) on delete set null deferrable initially deferred,
|
||||
-- fester Einheitspreis in Cent: Position ohne Kalkulation oder „Preis anpassen“ (A21)
|
||||
ep_fest bigint check (ep_fest >= 0),
|
||||
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 angebot_position_angebot on angebot_position (angebot_id);
|
||||
create trigger angebot_position_protokoll before insert or update or delete on angebot_position
|
||||
for each row execute function stempel_und_protokoll();
|
||||
|
||||
-- A2, A32, A33: Kostenzeilen je Einheit der Position
|
||||
create table angebot_kosten (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
position_id uuid not null references angebot_position (id) on delete cascade,
|
||||
kostenart text not null check (kostenart in ('lohn', 'material', 'geraet', 'sonstiges')),
|
||||
lohnart text check (lohnart in ('planer', 'geselle', 'helfer')),
|
||||
beschreibung text,
|
||||
-- je Einheit der Position; bei Lohn Stunden
|
||||
menge numeric(14, 4) not null default 1,
|
||||
einheit text,
|
||||
-- Cent je Einheit der Kostenzeile; bei Lohn leer = Stundensatz der Lohnart
|
||||
ek bigint check (ek >= 0),
|
||||
faktor numeric(8, 4) not null default 1 check (faktor > 0),
|
||||
faktor_grund text,
|
||||
-- leer = Standardzuschlag der Kostenart
|
||||
zuschlag_prozent numeric(7, 2),
|
||||
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 angebot_kosten_position on angebot_kosten (position_id);
|
||||
create trigger angebot_kosten_protokoll before insert or update or delete on angebot_kosten
|
||||
for each row execute function stempel_und_protokoll();
|
||||
@@ -98,6 +98,79 @@ export const TABELLEN: Tabelle[] = [
|
||||
notiz: optText,
|
||||
}),
|
||||
},
|
||||
// Stufe 3a: Angebote mit Kalkulation (A2, A19, A28, A32, A37); Status und Stände nur über eigene Routen
|
||||
{
|
||||
name: "angebot",
|
||||
pfad: "angebote",
|
||||
sortierung: "projekt_id, datum, nummer",
|
||||
schema: z.object({
|
||||
projekt_id: id,
|
||||
nummer: text,
|
||||
belegart: z.enum(["angebot", "kostenvoranschlag"]).optional(),
|
||||
datum: datum.optional(),
|
||||
bindefrist: datum.nullable().optional(),
|
||||
betreff: optText,
|
||||
kopftext: optText,
|
||||
schlusstext: optText,
|
||||
wagnis_prozent: z.number().min(0).max(50).optional(),
|
||||
gewinn_prozent: z.number().min(0).max(50).optional(),
|
||||
ausfall_prozent: z.number().min(0).max(50).optional(),
|
||||
saetze: z.object({
|
||||
stundensaetze: z.object({ planer: cent.min(0), geselle: cent.min(0), helfer: cent.min(0) }).partial().optional(),
|
||||
zuschlaege: z.object({ lohn: z.number().min(0).max(500), material: z.number().min(0).max(500), geraet: z.number().min(0).max(500), sonstiges: z.number().min(0).max(500) }).partial().optional(),
|
||||
stand: datum.optional(),
|
||||
}).optional(),
|
||||
notiz: optText,
|
||||
reihenfolge: z.number().int().optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "angebot_titel",
|
||||
pfad: "angebot-titel",
|
||||
sortierung: "angebot_id, reihenfolge",
|
||||
schema: z.object({
|
||||
angebot_id: id,
|
||||
oz: optText,
|
||||
bezeichnung: text,
|
||||
reihenfolge: z.number().int().optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "angebot_position",
|
||||
pfad: "angebot-positionen",
|
||||
sortierung: "angebot_id, reihenfolge",
|
||||
schema: z.object({
|
||||
angebot_id: id,
|
||||
titel_id: id.nullable().optional(),
|
||||
oz: optText,
|
||||
kurztext: text,
|
||||
langtext: optText,
|
||||
menge: z.number().min(0).max(1e9).optional(),
|
||||
einheit: text.optional(),
|
||||
art: z.enum(["normal", "alternativ", "eventual", "eventual_summe"]).optional(),
|
||||
grundposition_id: id.nullable().optional(),
|
||||
ep_fest: cent.min(0).nullable().optional(),
|
||||
reihenfolge: z.number().int().optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "angebot_kosten",
|
||||
pfad: "angebot-kosten",
|
||||
sortierung: "position_id, reihenfolge",
|
||||
schema: z.object({
|
||||
position_id: id,
|
||||
kostenart: z.enum(["lohn", "material", "geraet", "sonstiges"]),
|
||||
lohnart: z.enum(["planer", "geselle", "helfer"]).nullable().optional(),
|
||||
beschreibung: optText,
|
||||
menge: z.number().min(0).max(1e9).optional(),
|
||||
einheit: optText,
|
||||
ek: cent.min(0).nullable().optional(),
|
||||
faktor: z.number().positive().max(100).optional(),
|
||||
faktor_grund: optText,
|
||||
zuschlag_prozent: z.number().min(0).max(500).nullable().optional(),
|
||||
reihenfolge: z.number().int().optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "abschnitt",
|
||||
pfad: "abschnitte",
|
||||
|
||||
421
src/web/angebote.ts
Normal file
421
src/web/angebote.ts
Normal file
@@ -0,0 +1,421 @@
|
||||
// Stufe 3a: Angebote mit Kalkulation (Henning, 20.10.2026). Das Leistungsverzeichnis wird direkt in der Tabelle
|
||||
// bearbeitet: Titel, Positionen, darunter je Position die Kostenzeilen (Lohn, Material, Gerät, Sonstiges).
|
||||
// Jede Änderung wird sofort gespeichert und neu gerechnet; nach dem Versand ist das Angebot festgeschrieben (A19).
|
||||
|
||||
import { formatEuro, parseEuro } from "../domain/geld.js";
|
||||
import { EINHEITEN, KOSTENARTEN, KOSTENART_NAME, LOHNARTEN, LOHNART_NAME, POSITIONSARTEN, POSITIONSART_NAME } from "../domain/kalkulation.js";
|
||||
import { plusTage } from "../domain/datum.js";
|
||||
import { type Feld, type Zeile, api, bestaetigen, dat, dialog, esc, euro, heute, hinweis, huelle, inhalt, optionenHtml, seite } from "./ui.js";
|
||||
import { liste } from "./liste.js";
|
||||
|
||||
export const ANGEBOT_STATUS: Record<string, string> = { entwurf: "Entwurf", versendet: "Versendet", angenommen: "Angenommen", abgelehnt: "Abgelehnt" };
|
||||
const BELEGART: Record<string, string> = { angebot: "Angebot", kostenvoranschlag: "Kostenvoranschlag" };
|
||||
const MARKE: Record<string, string> = { entwurf: "grau", versendet: "offen", angenommen: "gut", abgelehnt: "schlecht" };
|
||||
|
||||
const zahlText = (v: unknown) => (v === null || v === undefined || v === "" ? "" : String(Number(v)).replace(".", ","));
|
||||
const zahlAus = (t: string) => { const n = Number(t.trim().replace(/\./g, "").replace(",", ".")); if (!Number.isFinite(n)) throw new Error(`„${t}“ ist keine Zahl`); return n; };
|
||||
const prozentText = (n: number | null | undefined) => (n == null ? "–" : `${String(n).replace(".", ",")} %`);
|
||||
const stdText = (h: number) => `${String(Math.round(h * 100) / 100).replace(".", ",")} Std.`;
|
||||
/** Cent mit Nachkommastellen (je Einheit), auf den Cent gerundet angezeigt */
|
||||
const euroGenau = (c: number) => formatEuro(Math.round(c));
|
||||
|
||||
export function angebotMarke(a: Zeile): string {
|
||||
const abgelaufen = a.status === "versendet" && a.bindefrist && a.bindefrist < heute();
|
||||
return `<span class="marke ${abgelaufen ? "schlecht" : MARKE[a.status] ?? "grau"}">${abgelaufen ? "Bindefrist abgelaufen" : esc(ANGEBOT_STATUS[a.status] ?? a.status)}</span>`;
|
||||
}
|
||||
|
||||
/** Neues Angebot (oder neue Version) anlegen und öffnen */
|
||||
export async function neuesAngebot(projektId: string, vonAngebot?: string): Promise<void> {
|
||||
const a = await api<Zeile>("angebote/neu", "POST", { projekt_id: projektId, ...(vonAngebot ? { von_angebot_id: vonAngebot } : {}) });
|
||||
location.hash = `angebot-${a.id}`;
|
||||
}
|
||||
|
||||
/** Die Angebote eines Projekts im Reiter Dokumente */
|
||||
export function angeboteHtml(angebote: Zeile[]): string {
|
||||
if (!angebote.length) return '<p class="hinweis leer">Noch kein Angebot. Mit „+ Angebot“ legst du eins an; die Nummer ist die des Projekts.</p>';
|
||||
return `<ul class="dokumente">${angebote.map((a) => `<li><a class="dokument" href="#angebot-${a.id}"><span><b>${esc(BELEGART[a.belegart] ?? "Angebot")} ${esc(a.nummer)}</b>${a.betreff ? ` ${esc(a.betreff)}` : ""}
|
||||
<span class="unter">vom ${dat(a.datum)} · ${euro(a.netto)} netto · ${a.positionen} ${a.positionen === 1 ? "Position" : "Positionen"}${a.bindefrist && a.status === "versendet" ? ` · gebunden bis ${dat(a.bindefrist)}` : ""}</span></span>
|
||||
<span class="marken">${angebotMarke(a)}</span></a></li>`).join("")}</ul>`;
|
||||
}
|
||||
|
||||
// ---------- Liste aller Angebote ----------
|
||||
|
||||
export async function angeboteSeite(): Promise<void> {
|
||||
const [zeilen, projekte] = await Promise.all([api<Zeile[]>("angebote-liste"), api<Zeile[]>("projekte")]);
|
||||
const neu = async () => {
|
||||
const offen = projekte.filter((p) => !["abgeschlossen", "gewaehrleistung"].includes(p.status))
|
||||
.sort((a, b) => Number(["anfrage", "angebot"].includes(b.status)) - Number(["anfrage", "angebot"].includes(a.status)) || String(b.nummer).localeCompare(String(a.nummer)));
|
||||
if (!offen.length) { hinweis.text = "Lege zuerst unter Projekte eine Anfrage an; das Angebot gehört zu einem Projekt."; return angeboteSeite(); }
|
||||
const e = await dialog("Neues Angebot", [{ name: "projekt_id", titel: "Für Projekt", art: "auswahl", pflicht: true,
|
||||
optionen: offen.map((p): [string, string] => [p.id, `${p.nummer} ${p.bezeichnung}`]), hilfe: "Neue Anfragen legst du unter Projekte an." }], { projekt_id: offen[0]!.id }, false);
|
||||
if (e?.aktion === "speichern") await neuesAngebot(e.daten.projekt_id);
|
||||
};
|
||||
seite("Angebote", { text: "Neues Angebot", aktion: () => void neu() });
|
||||
inhalt.querySelector(".kopf h1")!.insertAdjacentHTML("afterend", '<a class="neben" href="#projekte">Projekte</a>');
|
||||
const rang = Object.fromEntries(Object.keys(ANGEBOT_STATUS).map((k, i) => [k, i]));
|
||||
inhalt.appendChild(liste({
|
||||
schluessel: "angebote", einheit: ["Angebot", "Angebote"], vorgabe: { sort: [["datum", "ab"]] },
|
||||
leer: "Noch keine Angebote. Ein Angebot legst du hier oder auf der Projektseite unter Dokumente an.",
|
||||
spalten: [
|
||||
{ id: "nummer", titel: "Nummer", text: (a) => a.nummer, wert: (a) => `<strong>${esc(a.nummer)}</strong>${a.belegart === "kostenvoranschlag" ? ' <small class="hinweis">KVA</small>' : ""}<span class="unter">${esc(a.betreff || a.projekt_name)}</span>` },
|
||||
{ id: "projekt", titel: "Projekt", text: (a) => `${a.projekt_nummer} ${a.projekt_name}`, wert: (a) => `${esc(a.projekt_name)}<span class="unter">${esc(a.projekt_nummer)}</span>`, klasse: "optional" },
|
||||
{ id: "kunde", titel: "Kunde", wert: (a) => esc(a.bauherr_name ?? ""), klasse: "optional" },
|
||||
{ id: "datum", titel: "Datum", art: "datum", wert: (a) => dat(a.datum), sortWert: (a) => a.datum },
|
||||
{ id: "bindefrist", titel: "Bindefrist", art: "datum", wert: (a) => dat(a.bindefrist), sortWert: (a) => a.bindefrist, klasse: "optional" },
|
||||
{ id: "status", titel: "Status", text: (a) => ANGEBOT_STATUS[a.status] ?? a.status, wert: angebotMarke, sortWert: (a) => rang[a.status] ?? 9 },
|
||||
{ id: "netto", titel: "Netto", art: "zahl", wert: (a) => euro(a.netto), sortWert: (a) => a.netto, klasse: "zahl" },
|
||||
],
|
||||
zeilen, klick: (a) => (location.hash = `angebot-${a.id}`),
|
||||
fuss: (s) => {
|
||||
const offen = s.filter((a) => a.status === "versendet");
|
||||
return `<p>Offen (versendet): <strong>${euro(offen.reduce((t, a) => t + a.netto, 0))}</strong> in ${offen.length} ${offen.length === 1 ? "Angebot" : "Angeboten"}</p>`;
|
||||
},
|
||||
}));
|
||||
}
|
||||
|
||||
// ---------- Angebot bearbeiten ----------
|
||||
|
||||
const offen = new Set<string>();
|
||||
|
||||
export async function angebotSeite(id: string): Promise<void> {
|
||||
let d = await api<Zeile>(`angebote/${id}/voll`);
|
||||
let meldung = "";
|
||||
// eigener Rahmen, damit die Ereignisse mit der Seite verschwinden
|
||||
const wurzel = document.createElement("div");
|
||||
inhalt.replaceChildren(wurzel);
|
||||
|
||||
const zeichne = () => {
|
||||
// Fokus und gerade Getipptes über den Neuaufbau retten (gespeichert wird beim Verlassen eines Feldes)
|
||||
const fokus = document.activeElement as HTMLInputElement | null;
|
||||
const k = fokus?.dataset?.k;
|
||||
const getippt = k && "defaultValue" in fokus! && fokus.value !== fokus.defaultValue ? fokus.value : null;
|
||||
const auswahl = k && typeof fokus!.selectionStart === "number" ? [fokus!.selectionStart, fokus!.selectionEnd] : null;
|
||||
wurzel.innerHTML = html(d, meldung);
|
||||
if (k) {
|
||||
const neu = wurzel.querySelector<HTMLInputElement>(`[data-k="${CSS.escape(k)}"]`);
|
||||
if (neu) {
|
||||
if (getippt !== null) neu.value = getippt;
|
||||
neu.focus();
|
||||
if (auswahl) try { neu.setSelectionRange(auswahl[0]!, auswahl[1] ?? null); } catch { /* Auswahlfeld */ }
|
||||
}
|
||||
}
|
||||
};
|
||||
const neuLaden = async (m = "") => {
|
||||
d = await api<Zeile>(`angebote/${id}/voll`);
|
||||
meldung = m;
|
||||
zeichne();
|
||||
};
|
||||
|
||||
const entwurf = () => d.angebot.status === "entwurf";
|
||||
const reihe = (titelId: string | null) => d.positionen.filter((p: Zeile) => (p.titel_id ?? null) === titelId);
|
||||
const naechste = (liste: Zeile[]) => liste.reduce((m: number, x: Zeile) => Math.max(m, Number(x.reihenfolge) + 1), 0);
|
||||
|
||||
const speichern = async (el: HTMLInputElement) => {
|
||||
const [pfad, zid, feld] = el.dataset.k!.split(":") as [string, string, string];
|
||||
const typ = el.dataset.typ ?? "text";
|
||||
const roh = el.value.trim();
|
||||
let wert: unknown;
|
||||
if (typ === "euro") wert = roh ? parseEuro(roh) : null;
|
||||
else if (typ === "zahl") wert = roh ? zahlAus(roh) : el.dataset.leer === "null" ? null : 0;
|
||||
else wert = roh || (el.dataset.leer === "pflicht" ? undefined : null);
|
||||
if (wert === undefined) { el.value = el.defaultValue; throw new Error("Das Feld darf nicht leer sein."); }
|
||||
let body: Zeile = { [feld]: wert };
|
||||
if (pfad === "saetze") {
|
||||
// Sätze dieses Angebots (A36): ganze Gruppe zurückschreiben
|
||||
const s = { stundensaetze: { ...d.saetze.stundensaetze }, zuschlaege: { ...d.saetze.zuschlaege }, stand: d.angebot.saetze?.stand ?? heute() };
|
||||
(s as Zeile)[zid][feld] = wert ?? 0;
|
||||
return api(`angebote/${id}`, "PATCH", { saetze: s });
|
||||
}
|
||||
if (pfad === "angebot-positionen" && feld === "art" && wert !== "alternativ") body = { ...body, grundposition_id: null };
|
||||
if (pfad === "angebot-kosten" && feld === "kostenart") {
|
||||
const kz = d.kosten.find((x: Zeile) => x.id === zid);
|
||||
body = { ...body, lohnart: wert === "lohn" ? kz?.lohnart ?? "geselle" : null, ...(wert === "lohn" ? { einheit: "h" } : kz?.einheit === "h" ? { einheit: null } : {}) };
|
||||
}
|
||||
return api(`${pfad}/${pfad === "angebote" ? id : zid}`, "PATCH", body);
|
||||
};
|
||||
|
||||
const verschieben = async (pfad: string, liste: Zeile[], zid: string, richtung: number) => {
|
||||
const i = liste.findIndex((x) => x.id === zid), j = i + richtung;
|
||||
if (i < 0 || j < 0 || j >= liste.length) return;
|
||||
const neu = [...liste];
|
||||
[neu[i], neu[j]] = [neu[j]!, neu[i]!];
|
||||
for (const [n, x] of neu.entries()) if (Number(x.reihenfolge) !== n) await api(`${pfad}/${x.id}`, "PATCH", { reihenfolge: n });
|
||||
};
|
||||
|
||||
zeichne();
|
||||
|
||||
const fehler = (e: unknown) => { meldung = `! ${(e as Error).message}`; zeichne(); };
|
||||
|
||||
wurzel.addEventListener("change", async (ev) => {
|
||||
const el = ev.target as HTMLInputElement;
|
||||
if (!el.dataset?.k) return;
|
||||
try { await speichern(el); await neuLaden(); } catch (e) { fehler(e); }
|
||||
});
|
||||
wurzel.addEventListener("keydown", (ev) => {
|
||||
const el = ev.target as HTMLInputElement;
|
||||
// Enter speichert ein Eingabefeld und springt in die Zeile darunter (wie in Excel)
|
||||
if (ev.key !== "Enter" || el.tagName !== "INPUT" || !el.dataset.k) return;
|
||||
ev.preventDefault();
|
||||
const felder = [...wurzel.querySelectorAll<HTMLInputElement>(`input[data-spalte="${el.dataset.spalte}"]`)];
|
||||
const weiter = felder[felder.indexOf(el) + 1];
|
||||
if (weiter && el.dataset.spalte) weiter.focus(); else el.blur();
|
||||
});
|
||||
wurzel.addEventListener("click", async (ev) => {
|
||||
const b = (ev.target as HTMLElement).closest<HTMLElement>("[data-a]");
|
||||
if (!b) return;
|
||||
const a = b.dataset.a!, zid = b.dataset.id ?? "";
|
||||
try {
|
||||
if (a === "auf") { offen.has(zid) ? offen.delete(zid) : offen.add(zid); return zeichne(); }
|
||||
if (a === "titel-neu") {
|
||||
await api("angebot-titel", "POST", { angebot_id: id, bezeichnung: "Neuer Titel", reihenfolge: naechste(d.titel) });
|
||||
await neuLaden();
|
||||
const t = d.titel.at(-1);
|
||||
if (t) wurzel.querySelector<HTMLInputElement>(`[data-k="angebot-titel:${t.id}:bezeichnung"]`)?.select();
|
||||
return;
|
||||
}
|
||||
if (a === "position-neu") {
|
||||
const titelId = zid || null;
|
||||
const p = await api<Zeile>("angebot-positionen", "POST", { angebot_id: id, titel_id: titelId, kurztext: "Neue Position", menge: 1, einheit: "St", reihenfolge: naechste(reihe(titelId)) });
|
||||
offen.add(p.id);
|
||||
await neuLaden();
|
||||
wurzel.querySelector<HTMLInputElement>(`[data-k="angebot-positionen:${p.id}:kurztext"]`)?.select();
|
||||
return;
|
||||
}
|
||||
if (a === "kosten-neu") {
|
||||
const art = b.dataset.art!;
|
||||
const pos = d.positionen.find((x: Zeile) => x.id === zid);
|
||||
const k = await api<Zeile>("angebot-kosten", "POST", { position_id: zid, kostenart: art, lohnart: art === "lohn" ? "geselle" : null, menge: 1,
|
||||
einheit: art === "lohn" ? "h" : pos?.einheit ?? null, reihenfolge: naechste(d.kosten.filter((x: Zeile) => x.position_id === zid)) });
|
||||
await neuLaden();
|
||||
wurzel.querySelector<HTMLInputElement>(`[data-k="angebot-kosten:${k.id}:${art === "lohn" ? "menge" : "beschreibung"}"]`)?.focus();
|
||||
return;
|
||||
}
|
||||
if (a === "kosten-weg") { await api(`angebot-kosten/${zid}`, "DELETE"); return neuLaden(); }
|
||||
if (a === "position-weg") {
|
||||
if (!(await bestaetigen("Position mit ihren Kostenzeilen löschen?"))) return;
|
||||
await api(`angebot-positionen/${zid}`, "DELETE");
|
||||
return neuLaden();
|
||||
}
|
||||
if (a === "titel-weg") {
|
||||
const n = reihe(zid).length;
|
||||
if (!(await bestaetigen(n ? `Titel mit ${n} ${n === 1 ? "Position" : "Positionen"} löschen?` : "Titel löschen?"))) return;
|
||||
await api(`angebot-titel/${zid}`, "DELETE");
|
||||
return neuLaden();
|
||||
}
|
||||
if (a === "position-kopie") {
|
||||
const p = d.positionen.find((x: Zeile) => x.id === zid)!;
|
||||
const n = await api<Zeile>("angebot-positionen", "POST", { angebot_id: id, titel_id: p.titel_id, kurztext: p.kurztext, langtext: p.langtext, menge: Number(p.menge),
|
||||
einheit: p.einheit, art: p.art, ep_fest: p.ep_fest == null ? null : Number(p.ep_fest), reihenfolge: naechste(reihe(p.titel_id ?? null)) });
|
||||
for (const k of d.kosten.filter((x: Zeile) => x.position_id === zid)) {
|
||||
await api("angebot-kosten", "POST", { position_id: n.id, kostenart: k.kostenart, lohnart: k.lohnart, beschreibung: k.beschreibung, menge: Number(k.menge), einheit: k.einheit,
|
||||
ek: k.ek == null ? null : Number(k.ek), faktor: Number(k.faktor), faktor_grund: k.faktor_grund, zuschlag_prozent: k.zuschlag_prozent == null ? null : Number(k.zuschlag_prozent), reihenfolge: k.reihenfolge });
|
||||
}
|
||||
offen.add(n.id);
|
||||
return neuLaden();
|
||||
}
|
||||
if (a === "position-hoch" || a === "position-runter") {
|
||||
const p = d.positionen.find((x: Zeile) => x.id === zid)!;
|
||||
await verschieben("angebot-positionen", reihe(p.titel_id ?? null), zid, a === "position-hoch" ? -1 : 1);
|
||||
return neuLaden();
|
||||
}
|
||||
if (a === "titel-hoch" || a === "titel-runter") { await verschieben("angebot-titel", d.titel, zid, a === "titel-hoch" ? -1 : 1); return neuLaden(); }
|
||||
if (a === "pruefung") {
|
||||
const pid = b.dataset.pos;
|
||||
if (pid) { offen.add(pid); zeichne(); wurzel.querySelector(`[data-zeile="${pid}"]`)?.scrollIntoView({ block: "center" }); }
|
||||
return;
|
||||
}
|
||||
if (a === "versenden") return versenden(false);
|
||||
if (a === "bearbeiten") { await api(`angebote/${id}/bearbeiten`, "POST", {}); return neuLaden("Das Angebot ist wieder im Entwurf. Der versendete Stand bleibt gespeichert."); }
|
||||
if (a === "ablehnen") {
|
||||
if (!(await bestaetigen("Angebot als abgelehnt markieren?"))) return;
|
||||
await api(`angebote/${id}/ablehnen`, "POST", {});
|
||||
return neuLaden();
|
||||
}
|
||||
if (a === "annehmen") return annehmen();
|
||||
if (a === "version") {
|
||||
if (!(await bestaetigen("Neue Version als Kopie dieses Angebots anlegen?"))) return;
|
||||
return neuesAngebot(d.angebot.projekt_id, id);
|
||||
}
|
||||
if (a === "loeschen") {
|
||||
if (!(await bestaetigen(`${BELEGART[d.angebot.belegart]} ${d.angebot.nummer} löschen?`))) return;
|
||||
await api(`angebote/${id}`, "DELETE");
|
||||
location.hash = `projekt-${d.angebot.projekt_id}-dokumente`;
|
||||
return;
|
||||
}
|
||||
} catch (e) { fehler(e); }
|
||||
});
|
||||
|
||||
// A14: Versandprüfung; mit Fehlern nur nach ausdrücklichem „trotzdem“
|
||||
async function versenden(trotzdem: boolean): Promise<void> {
|
||||
const r = await api<Zeile>(`angebote/${id}/versenden`, "POST", { trotzdem });
|
||||
if (r.versendet) return neuLaden(`Als versendet markiert am ${dat(heute())}. Kalkulation und Preise sind jetzt festgeschrieben.`);
|
||||
const fehlerListe = r.pruefung.filter((p: Zeile) => p.stufe === "fehler");
|
||||
huelle.innerHTML = `<div class="dialog"><h2>Vor dem Versand bitte prüfen</h2>
|
||||
<ul class="pruefung">${r.pruefung.map((p: Zeile) => `<li class="${p.stufe}">${esc(p.text)}</li>`).join("")}</ul>
|
||||
<p class="hinweis">${fehlerListe.length} ${fehlerListe.length === 1 ? "Punkt verhindert" : "Punkte verhindern"} den Versand. Du kannst trotzdem versenden, wenn das so gewollt ist.</p>
|
||||
<div class="knoepfe"><button class="neben" data-p="trotzdem">Trotzdem versenden</button><button class="haupt" data-p="zurueck">Zurück zum Angebot</button></div></div>`;
|
||||
huelle.hidden = false;
|
||||
const wahl = await new Promise<string>((fertig) => huelle.querySelector(".dialog")!.addEventListener("click", (ev) => {
|
||||
const p = (ev.target as HTMLElement).dataset.p;
|
||||
if (p) fertig(p);
|
||||
}));
|
||||
huelle.hidden = true;
|
||||
huelle.innerHTML = "";
|
||||
if (wahl === "trotzdem") return versenden(true);
|
||||
}
|
||||
|
||||
// A4: aus dem Angebot wird der Auftrag
|
||||
async function annehmen(): Promise<void> {
|
||||
const felder: Feld[] = [
|
||||
{ name: "start", titel: "Ausführung ab", art: "datum", hilfe: d.ergebnis.stunden ? `Aus jedem Titel wird ein Abschnitt im Terminplan; die Dauer ergibt sich aus den ${stdText(d.ergebnis.stunden)}.` : "Aus jedem Titel wird ein Abschnitt im Terminplan." },
|
||||
{ name: "personen", titel: "Personen auf der Baustelle", art: "zahl" },
|
||||
];
|
||||
const e = await dialog(`${BELEGART[d.angebot.belegart]} ${d.angebot.nummer} annehmen`, felder, { start: plusTage(heute(), 14), personen: 2 }, false);
|
||||
if (e?.aktion !== "speichern") return;
|
||||
const r = await api<Zeile>(`angebote/${id}/annehmen`, "POST", { start: e.daten.start ?? undefined, personen: e.daten.personen ?? 2 });
|
||||
hinweis.gut = true;
|
||||
hinweis.text = `Auftrag ${r.nummer}: Auftragswert ${euro(r.umsatz)} netto${r.abschnitte ? `, ${r.abschnitte} ${r.abschnitte === 1 ? "Abschnitt" : "Abschnitte"} im Terminplan` : ", der vorhandene Terminplan bleibt"}. Der Zahlungsplan entsteht aus Auftragswert und Terminen.`;
|
||||
location.hash = `projekt-${r.projekt_id}`;
|
||||
}
|
||||
}
|
||||
|
||||
// ---------- Darstellung ----------
|
||||
|
||||
function html(d: Zeile, meldung: string): string {
|
||||
const a = d.angebot, e = d.ergebnis, s = d.saetze;
|
||||
const frei = a.status === "entwurf";
|
||||
const aus = frei ? "" : " disabled";
|
||||
const feld = (k: string, wert: unknown, o: { typ?: string; klasse?: string; leer?: string; spalte?: string; titel?: string; platz?: string; liste?: string } = {}) =>
|
||||
`<input data-k="${k}"${o.typ ? ` data-typ="${o.typ}"` : ""}${o.leer ? ` data-leer="${o.leer}"` : ""}${o.spalte ? ` data-spalte="${o.spalte}"` : ""} value="${esc(wert)}"
|
||||
${o.typ === "euro" || o.typ === "zahl" ? 'inputmode="decimal"' : ""} class="${o.klasse ?? ""}"${o.titel ? ` aria-label="${esc(o.titel)}"` : ""}${o.platz ? ` placeholder="${esc(o.platz)}"` : ""}${o.liste ? ` list="${o.liste}"` : ""}${aus}>`;
|
||||
const auswahl = (k: string, optionen: [string, string][], wert: string, titel: string) => `<select data-k="${k}" aria-label="${esc(titel)}"${aus}>${optionenHtml(optionen, wert)}</select>`;
|
||||
const euroFeld = (c: number | null | undefined) => (c == null ? "" : formatEuro(Number(c), false));
|
||||
|
||||
// OZ aus der Reihenfolge: Titel 01, Positionen 01.0001 (eigene OZ aus einem Import geht vor)
|
||||
const oz: Record<string, string> = {};
|
||||
const gruppen: { titel: Zeile | null; positionen: Zeile[] }[] = [];
|
||||
const ohne = d.positionen.filter((p: Zeile) => !p.titel_id);
|
||||
if (ohne.length || !d.titel.length) gruppen.push({ titel: null, positionen: ohne });
|
||||
d.titel.forEach((t: Zeile, i: number) => {
|
||||
oz[t.id] = t.oz || String(i + 1).padStart(2, "0");
|
||||
gruppen.push({ titel: t, positionen: d.positionen.filter((p: Zeile) => p.titel_id === t.id) });
|
||||
});
|
||||
for (const g of gruppen) g.positionen.forEach((p, j) => (oz[p.id] = p.oz || (g.titel ? `${oz[g.titel.id]}.${String(j + 1).padStart(4, "0")}` : String(j + 1).padStart(2, "0"))));
|
||||
|
||||
const kostenZeilen = (p: Zeile) => {
|
||||
const r = e.positionen[p.id];
|
||||
const zeilen = d.kosten.filter((k: Zeile) => k.position_id === p.id);
|
||||
if (!frei && !zeilen.length) return '<p class="hinweis">Ohne Kalkulation, fester Preis.</p>';
|
||||
return `<div class="kosten-rolle"><table class="kosten-tabelle"><thead><tr><th>Art</th><th>Bezeichnung</th><th class="zahl">Menge je ${esc(p.einheit)}</th><th>Einheit</th><th class="zahl">EK</th><th class="zahl">Faktor</th><th class="zahl">Zuschlag</th><th class="zahl">Kosten</th><th class="zahl">Verkauf</th><th></th></tr></thead>
|
||||
<tbody>${zeilen.map((k: Zeile, i: number) => {
|
||||
const z = r.kostenzeilen[i] ?? { kosten: 0, verkauf: 0 };
|
||||
const lohn = k.kostenart === "lohn";
|
||||
return `<tr class="kz-${k.kostenart}"><td>${auswahl(`angebot-kosten:${k.id}:kostenart`, KOSTENARTEN.map((x) => [x, KOSTENART_NAME[x]]), k.kostenart, "Kostenart")}</td>
|
||||
<td class="kz-text">${lohn ? auswahl(`angebot-kosten:${k.id}:lohnart`, LOHNARTEN.map((x) => [x, LOHNART_NAME[x]]), k.lohnart ?? "geselle", "Lohnart") : ""}${feld(`angebot-kosten:${k.id}:beschreibung`, k.beschreibung ?? "", { titel: "Bezeichnung", platz: lohn ? "Tätigkeit" : "z. B. KVH 6/12" })}</td>
|
||||
<td>${feld(`angebot-kosten:${k.id}:menge`, zahlText(k.menge), { typ: "zahl", klasse: "zahl w-menge", titel: "Menge", spalte: `km-${p.id}` })}</td>
|
||||
<td>${lohn ? '<span class="hinweis">h</span>' : feld(`angebot-kosten:${k.id}:einheit`, k.einheit ?? "", { klasse: "w-kurz", titel: "Einheit", liste: "einheiten" })}</td>
|
||||
<td>${feld(`angebot-kosten:${k.id}:ek`, euroFeld(k.ek), { typ: "euro", klasse: "zahl w-euro", leer: "null", titel: "Einkaufspreis", platz: lohn ? euroFeld(s.stundensaetze[k.lohnart ?? "geselle"]) : "0,00", spalte: `ke-${p.id}` })}</td>
|
||||
<td>${feld(`angebot-kosten:${k.id}:faktor`, zahlText(k.faktor), { typ: "zahl", klasse: "zahl w-kurz", titel: "Faktor" })}</td>
|
||||
<td><span class="mit-einheit">${feld(`angebot-kosten:${k.id}:zuschlag_prozent`, zahlText(k.zuschlag_prozent), { typ: "zahl", klasse: "zahl w-kurz", leer: "null", titel: "Zuschlag in Prozent", platz: zahlText(s.zuschlaege[k.kostenart]) })} %</span></td>
|
||||
<td class="zahl">${euroGenau(z.kosten)}</td><td class="zahl">${euroGenau(z.verkauf)}</td>
|
||||
<td>${frei ? `<button class="weg" data-a="kosten-weg" data-id="${k.id}" title="Kostenzeile löschen" aria-label="Kostenzeile löschen">×</button>` : ""}</td></tr>`;
|
||||
}).join("")}</tbody>
|
||||
<tfoot><tr><td colspan="7">${frei ? KOSTENARTEN.map((x) => `<button class="neben klein" data-a="kosten-neu" data-art="${x}" data-id="${p.id}">+ ${KOSTENART_NAME[x]}</button>`).join(" ") : ""}</td>
|
||||
<td class="zahl">${euro(r.kosten_je_einheit)}</td><td class="zahl"><b>${euro(r.ep_kalkuliert)}</b></td><td></td></tr></tfoot></table></div>
|
||||
<p class="hinweis">Je ${esc(p.einheit)}: Kosten ${euro(r.kosten_je_einheit)}, Einheitspreis kalkuliert ${euro(r.ep_kalkuliert)}${r.std_je_einheit ? `, ${String(r.std_je_einheit).replace(".", ",")} Std` : ""}. Verkauf = Kosten × Zuschlag × (Wagnis + Gewinn + Ausfall ${prozentText(s.wagnis + s.gewinn + s.ausfall)}).</p>`;
|
||||
};
|
||||
|
||||
const positionZeilen = (p: Zeile, liste: Zeile[], j: number) => {
|
||||
const r = e.positionen[p.id];
|
||||
const auf = offen.has(p.id);
|
||||
const fehler = d.pruefung.some((x: Zeile) => x.position_id === p.id && x.stufe === "fehler");
|
||||
const grund = d.positionen.filter((x: Zeile) => x.id !== p.id && x.art !== "alternativ");
|
||||
return `<tr class="position${r.zaehlt ? "" : " zaehlt-nicht"}${auf ? " auf" : ""}${fehler ? " mit-fehler" : ""}" data-zeile="${p.id}">
|
||||
<td class="oz"><button class="auf-zu" data-a="auf" data-id="${p.id}" aria-expanded="${auf}" title="Kalkulation zeigen">${auf ? "▾" : "▸"}</button>${esc(oz[p.id])}</td>
|
||||
<td class="text">${feld(`angebot-positionen:${p.id}:kurztext`, p.kurztext, { leer: "pflicht", titel: "Kurztext", spalte: "kurztext" })}${p.art && p.art !== "normal" ? `<span class="marke grau">${esc(POSITIONSART_NAME[p.art as keyof typeof POSITIONSART_NAME])}</span>` : ""}</td>
|
||||
<td>${feld(`angebot-positionen:${p.id}:menge`, zahlText(p.menge), { typ: "zahl", klasse: "zahl", titel: "Menge", spalte: "menge" })}</td>
|
||||
<td>${feld(`angebot-positionen:${p.id}:einheit`, p.einheit, { leer: "pflicht", klasse: "kurz", titel: "Einheit", liste: "einheiten", spalte: "einheit" })}</td>
|
||||
<td class="zahl">${euro(r.ep)}${p.ep_fest != null ? '<span class="unter">fest</span>' : ""}</td>
|
||||
<td class="zahl">${r.zaehlt ? euro(r.gb) : `<span class="hinweis">(${euro(r.gb)})</span>`}</td>
|
||||
<td class="zahl optional">${r.stunden ? String(r.stunden).replace(".", ",") : ""}</td></tr>
|
||||
${auf ? `<tr class="details"><td colspan="7"><div class="position-details">
|
||||
${frei || p.langtext ? `<label>Langtext<textarea data-k="angebot-positionen:${p.id}:langtext" rows="3"${aus}>${esc(p.langtext ?? "")}</textarea></label>` : ""}
|
||||
<div class="details-zeile">
|
||||
<label>Art${auswahl(`angebot-positionen:${p.id}:art`, POSITIONSARTEN.map((x) => [x, POSITIONSART_NAME[x]]), p.art ?? "normal", "Positionsart")}</label>
|
||||
${p.art === "alternativ" ? `<label>Alternativ zu${auswahl(`angebot-positionen:${p.id}:grundposition_id`, [["", "–"], ...grund.map((x: Zeile): [string, string] => [x.id, `${oz[x.id]} ${x.kurztext}`])], p.grundposition_id ?? "", "Grundposition")}</label>` : ""}
|
||||
<label>Fester Einheitspreis${feld(`angebot-positionen:${p.id}:ep_fest`, euroFeld(p.ep_fest), { typ: "euro", klasse: "zahl", leer: "null", titel: "Fester Einheitspreis", platz: `kalkuliert ${euroFeld(r.ep_kalkuliert)}` })}</label>
|
||||
${frei ? `<span class="details-knoepfe"><button class="neben klein" data-a="position-hoch" data-id="${p.id}"${j === 0 ? " disabled" : ""} title="nach oben">↑</button><button class="neben klein" data-a="position-runter" data-id="${p.id}"${j === liste.length - 1 ? " disabled" : ""} title="nach unten">↓</button>
|
||||
<button class="neben klein" data-a="position-kopie" data-id="${p.id}">Kopieren</button><button class="neben klein gefahr" data-a="position-weg" data-id="${p.id}">Löschen</button></span>` : ""}
|
||||
</div>${kostenZeilen(p)}</div></td></tr>` : ""}`;
|
||||
};
|
||||
|
||||
const lv = gruppen.map((g, gi) => `<tbody class="gruppe-lv">${g.titel ? `<tr class="titel"><td class="oz">${esc(oz[g.titel.id])}</td>
|
||||
<td class="text" colspan="4"><span class="titel-zeile">${feld(`angebot-titel:${g.titel.id}:bezeichnung`, g.titel.bezeichnung, { leer: "pflicht", titel: "Titel", klasse: "titel-feld" })}${frei ? `<span class="titel-knoepfe"><button class="neben klein" data-a="titel-hoch" data-id="${g.titel.id}"${gi === (gruppen[0]!.titel ? 0 : 1) ? " disabled" : ""} title="Titel nach oben" aria-label="Titel nach oben">↑</button><button class="neben klein" data-a="titel-runter" data-id="${g.titel.id}"${gi === gruppen.length - 1 ? " disabled" : ""} title="Titel nach unten" aria-label="Titel nach unten">↓</button><button class="weg" data-a="titel-weg" data-id="${g.titel.id}" title="Titel löschen" aria-label="Titel löschen">×</button></span>` : ""}</span></td>
|
||||
<td class="zahl"><b>${euro(e.titel[g.titel.id])}</b></td><td class="optional"></td></tr>` : ""}
|
||||
${g.positionen.map((p, j) => positionZeilen(p, g.positionen, j)).join("")}
|
||||
${frei && (g.titel || !d.titel.length) ? `<tr class="neu"><td></td><td colspan="6"><button class="verweis" data-a="position-neu" data-id="${g.titel?.id ?? ""}">+ Position${g.titel ? ` in ${esc(g.titel.bezeichnung)}` : ""}</button></td></tr>` : ""}</tbody>`).join("");
|
||||
|
||||
const fehlerZahl = d.pruefung.filter((p: Zeile) => p.stufe === "fehler").length;
|
||||
const knoepfe = {
|
||||
entwurf: `<button class="haupt" data-a="versenden">Als versendet markieren</button><button class="neben" data-a="annehmen">Annehmen</button>`,
|
||||
versendet: `<button class="haupt" data-a="annehmen">Annehmen</button><button class="neben" data-a="ablehnen">Abgelehnt</button><button class="neben" data-a="bearbeiten">Wieder bearbeiten</button>`,
|
||||
abgelehnt: `<button class="neben" data-a="bearbeiten">Wieder bearbeiten</button>`,
|
||||
angenommen: "",
|
||||
}[a.status as string] ?? "";
|
||||
const ka = e.kostenarten;
|
||||
const staende = (a.staende ?? []) as Zeile[];
|
||||
|
||||
return `<datalist id="einheiten">${EINHEITEN.map((x) => `<option value="${x}">`).join("")}</datalist>
|
||||
<div class="kopf angebot-kopf"><a class="neben zurueck" href="#projekt-${a.projekt_id}-dokumente" aria-label="Zurück zum Projekt">←</a>
|
||||
<h1>${esc(BELEGART[a.belegart])} <span class="nummer">${esc(a.nummer)}</span></h1>${angebotMarke(a)}
|
||||
<span class="kopf-knoepfe">${knoepfe}<button class="neben" data-a="version" title="Kopie als neues Angebot">Neue Version</button>${a.status !== "angenommen" ? '<button class="neben gefahr" data-a="loeschen">Löschen</button>' : ""}</span></div>
|
||||
${meldung ? `<div class="${meldung.startsWith("! ") ? "warnung" : "erfolg"}" role="status">${esc(meldung.replace(/^! /, ""))}</div>` : ""}
|
||||
<p class="angebot-bezug"><a href="#projekt-${a.projekt_id}">${esc(a.projekt_nummer)} ${esc(a.projekt_name)}</a>${a.bauherr_name ? ` · ${esc(a.bauherr_name)}${a.bauherr_firma ? `, ${esc(a.bauherr_firma)}` : ""}` : ' · <span class="fehler">kein Bauherr eingetragen</span>'}
|
||||
${frei ? "" : ` · <span class="hinweis">festgeschrieben${a.versendet_am ? `, versendet am ${dat(a.versendet_am)}` : ""}${a.entschieden_am ? `, ${a.status === "angenommen" ? "angenommen" : "abgelehnt"} am ${dat(a.entschieden_am)}` : ""}</span>`}</p>
|
||||
<div class="angebot-raster">
|
||||
<div class="angebot-haupt">
|
||||
<section class="karte angebot-angaben">
|
||||
<label class="breit">Betreff${feld("angebote:x:betreff", a.betreff ?? "", { platz: `z. B. ${a.projekt_name}` })}</label>
|
||||
<label>Beleg${auswahl("angebote:x:belegart", Object.entries(BELEGART), a.belegart, "Belegart")}</label>
|
||||
<label>Datum<input type="date" data-k="angebote:x:datum" data-leer="pflicht" value="${esc(a.datum)}"${aus}></label>
|
||||
<label>Bindefrist bis<input type="date" data-k="angebote:x:bindefrist" value="${esc(a.bindefrist ?? "")}"${aus}></label>
|
||||
<label class="breit">Einleitung<textarea data-k="angebote:x:kopftext" rows="2"${aus}>${esc(a.kopftext ?? "")}</textarea></label>
|
||||
</section>
|
||||
<section class="karte lv-karte"><div class="lv-rolle"><table class="lv">
|
||||
<colgroup><col class="c-oz"><col><col class="c-menge"><col class="c-einheit"><col class="c-ep"><col class="c-gb"><col class="c-std optional"></colgroup>
|
||||
<thead><tr><th>OZ</th><th>Leistung</th><th class="zahl">Menge</th><th>Einheit</th><th class="zahl">EP</th><th class="zahl">GB</th><th class="zahl optional">Std.</th></tr></thead>
|
||||
${lv}
|
||||
<tfoot><tr><td></td><td colspan="4">${frei ? '<button class="neben" data-a="titel-neu">+ Titel</button>' : ""}</td><td class="zahl"><b>${euro(e.netto)}</b></td><td class="optional"></td></tr></tfoot></table></div>
|
||||
${d.positionen.length ? "" : '<p class="hinweis leer">Lege Titel (z. B. „Dachstuhl“, „Dämmung“) und darin Positionen an. Mit ▸ öffnest du je Position die Kalkulation.</p>'}</section>
|
||||
<section class="karte angebot-angaben"><label class="breit">Schlusstext<textarea data-k="angebote:x:schlusstext" rows="3"${aus}>${esc(a.schlusstext ?? "")}</textarea></label>
|
||||
<p class="hinweis breit">{bindefrist} wird im Angebot durch das Datum ersetzt.</p></section>
|
||||
</div>
|
||||
<aside class="angebot-seite">
|
||||
<section class="karte summen"><dl>
|
||||
<dt>Netto</dt><dd>${euro(e.netto)}</dd><dt>USt</dt><dd>${euro(e.ust)}</dd><dt class="brutto">Brutto</dt><dd class="brutto">${euro(e.brutto)}</dd>
|
||||
<dt>Stunden</dt><dd>${stdText(e.stunden)}</dd>
|
||||
<dt>Kosten</dt><dd>${euro(e.kosten)}</dd>
|
||||
<dt>Möglicher Überschuss</dt><dd>${e.kosten ? `${euro(e.netto - e.kosten)} <small>(${prozentText(e.ueberschuss_prozent)})</small>` : "–"}</dd>
|
||||
${e.stundensatz_verkauf ? `<dt>Verkauf je Lohnstunde</dt><dd>${euro(e.stundensatz_verkauf)}</dd>` : ""}
|
||||
${e.arbeitskosten_brutto ? `<dt title="§ 35a EStG, für Privatkunden">Arbeitskosten brutto</dt><dd>${euro(e.arbeitskosten_brutto)}</dd>` : ""}</dl></section>
|
||||
<section class="karte"><h3>Kalkulation</h3>
|
||||
<table class="kalk-tabelle"><thead><tr><th></th><th class="zahl">Kosten</th><th class="zahl">Zuschlag</th><th class="zahl">Verkauf</th></tr></thead><tbody>
|
||||
${([...KOSTENARTEN, "ohne"] as const).filter((x) => x === "lohn" || x === "material" || ka[x].kosten || ka[x].verkauf).map((x) => `<tr><td>${KOSTENART_NAME[x]}</td><td class="zahl">${euro(ka[x].kosten)}</td>
|
||||
<td class="zahl">${euro(ka[x].zuschlag)}<span class="unter">${prozentText(ka[x].prozent)}</span></td><td class="zahl">${euro(ka[x].verkauf)}</td></tr>`).join("")}</tbody>
|
||||
<tfoot><tr><td>Summe</td><td class="zahl">${euro(e.kosten)}</td><td class="zahl">${euro(e.netto - e.kosten)}</td><td class="zahl">${euro(e.netto)}</td></tr></tfoot></table>
|
||||
<div class="saetze">
|
||||
<label>Wagnis<span class="mit-einheit">${feld("angebote:x:wagnis_prozent", zahlText(a.wagnis_prozent), { typ: "zahl", klasse: "zahl" })} %</span></label>
|
||||
<label>Gewinn<span class="mit-einheit">${feld("angebote:x:gewinn_prozent", zahlText(a.gewinn_prozent), { typ: "zahl", klasse: "zahl" })} %</span></label>
|
||||
<label>Ausfall<span class="mit-einheit">${feld("angebote:x:ausfall_prozent", zahlText(a.ausfall_prozent), { typ: "zahl", klasse: "zahl" })} %</span></label>
|
||||
</div>
|
||||
<details class="saetze-mehr"><summary>Stundensätze und Zuschläge dieses Angebots</summary>
|
||||
<p class="hinweis">Festgeschrieben am ${dat(a.saetze?.stand) || dat(a.datum)}; spätere Änderungen in den Einstellungen ändern dieses Angebot nicht.</p>
|
||||
<div class="saetze">${LOHNARTEN.map((x) => `<label>${LOHNART_NAME[x]} (EK je h)${feld(`saetze:stundensaetze:${x}`, euroFeld(s.stundensaetze[x]), { typ: "euro", klasse: "zahl" })}</label>`).join("")}</div>
|
||||
<div class="saetze">${KOSTENARTEN.map((x) => `<label>Zuschlag ${KOSTENART_NAME[x]}<span class="mit-einheit">${feld(`saetze:zuschlaege:${x}`, zahlText(s.zuschlaege[x]), { typ: "zahl", klasse: "zahl" })} %</span></label>`).join("")}</div>
|
||||
</details></section>
|
||||
<section class="karte"><h3>Prüfung ${fehlerZahl ? `<span class="marke schlecht">${fehlerZahl}</span>` : '<span class="marke gut">in Ordnung</span>'}</h3>
|
||||
${d.pruefung.length ? `<ul class="pruefung">${d.pruefung.map((p: Zeile) => `<li class="${p.stufe}">${p.position_id ? `<button class="verweis" data-a="pruefung" data-pos="${p.position_id}">${esc(p.text)}</button>` : esc(p.text)}</li>`).join("")}</ul>` : '<p class="hinweis">Keine Platzhalter, alle Positionen mit Menge, Einheit und Preis.</p>'}</section>
|
||||
${staende.length ? `<section class="karte"><h3>Festgeschriebene Stände</h3><ul class="staende">${staende.map((x) => `<li>${x.anlass === "auftrag" ? "Auftrag" : "Versand"} am ${dat(String(x.am).slice(0, 10))}: ${euro(x.netto)} netto${x.von ? ` <small class="hinweis">${esc(x.von)}</small>` : ""}</li>`).join("")}</ul></section>` : ""}
|
||||
</aside>
|
||||
</div>`;
|
||||
}
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
import { kalenderwoche, terminplanSeite } from "./gantt.js";
|
||||
import { type Feld, type Zeile, MONATSNAMEN, api, bearbeiten, bestaetigen, dat, dialog, esc, euro, heute, hinweis,
|
||||
huelle, inhalt, optionenHtml, seite, abgemeldet, lies, merke, TEST_BENUTZER } from "./ui.js";
|
||||
huelle, hinweisHtml, inhalt, optionenHtml, seite, abgemeldet, lies, merke, TEST_BENUTZER } from "./ui.js";
|
||||
import { type Sitzung, anmeldeSeite, benutzerSeite, werLeiste } from "./anmeldung.js";
|
||||
import { ablageSeite, meineEinsaetze } from "./mitarbeiter.js";
|
||||
import { meinUrlaub } from "./urlaub.js";
|
||||
@@ -10,6 +10,7 @@ import { AUGE, AUGE_ZU, ansichtMerken, ansichtenLaden, filterMenue, filterText,
|
||||
import { gesamtFortschritt } from "../domain/fortschritt.js";
|
||||
import { kolonneSeite, mitarbeiterSeite, personalSeite, subunternehmerSeite } from "./personal.js";
|
||||
import { meineStunden, stundenSeite } from "./stunden.js";
|
||||
import { angebotSeite, angeboteHtml, angeboteSeite, neuesAngebot } from "./angebote.js";
|
||||
|
||||
|
||||
// ---------- Reiter ----------
|
||||
@@ -80,6 +81,7 @@ async function projekte(): Promise<void> {
|
||||
location.hash = `projekt-${p.id}`;
|
||||
};
|
||||
seite("Projekte", { text: "Neues Projekt", aktion: neu });
|
||||
inhalt.querySelector(".kopf h1")!.insertAdjacentHTML("afterend", '<a class="neben" href="#angebote">Angebote</a>');
|
||||
const [zeilen, kontaktListe] = await Promise.all([api<Zeile[]>("projekte"), api<Zeile[]>("kontakte")]);
|
||||
const name = Object.fromEntries(kontaktListe.map((k) => [k.id, k.name]));
|
||||
const statusRang = Object.fromEntries(STATUS.map(([k], i) => [k, i]));
|
||||
@@ -136,9 +138,10 @@ const stundenText = (h: number) => { const m = Math.round(h * 60); return `${Mat
|
||||
const groesseText = (b: number) => (b >= 1048576 ? `${(b / 1048576).toFixed(1).replace(".", ",")} MB` : `${Math.max(1, Math.round(b / 1024))} KB`);
|
||||
|
||||
async function projektSeite(id: string): Promise<void> {
|
||||
const [p, kontaktListe, plan, zahlungen, kosten, aufgabenDat, alleAufgaben, istJeProjekt] = await Promise.all([
|
||||
const [p, kontaktListe, plan, zahlungen, kosten, aufgabenDat, alleAufgaben, istJeProjekt, angebote] = await Promise.all([
|
||||
api<Zeile>(`projekte/${id}`), api<Zeile[]>("kontakte"), api<Zeile>("terminplan"),
|
||||
api<Zeile[]>("zahlungen"), api<Zeile[]>("kosten"), aufgabenDaten(), api<Zeile[]>("aufgaben"), api<Record<string, number>>("zeiten/projekte"),
|
||||
api<Zeile[]>(`angebote-liste?projekt_id=${id}`),
|
||||
]);
|
||||
const neuLaden = () => projektSeite(id);
|
||||
const kontakt = Object.fromEntries(kontaktListe.map((k) => [k.id, k]));
|
||||
@@ -150,7 +153,7 @@ async function projektSeite(id: string): Promise<void> {
|
||||
const eigeneAufgaben = alleAufgaben.filter((a) => a.projekt_id === id);
|
||||
const umsatz = p.umsatz_netto, kostenGesamt = kostenSumme(p);
|
||||
|
||||
inhalt.innerHTML = `${hinweis.text ? `<div class="warnung">${esc(hinweis.text)}</div>` : ""}
|
||||
inhalt.innerHTML = `${hinweisHtml()}
|
||||
<div class="kopf projekt-kopf"><a class="neben zurueck" href="#projekte" aria-label="Zurück zur Projektliste">←</a>
|
||||
<h1>${esc(p.bezeichnung)} <span class="nummer">(${esc(p.nummer)})</span></h1>
|
||||
<select id="p-status" class="etikett ${esc(p.status)}" aria-label="Status">${optionenHtml(STATUS, p.status)}</select>
|
||||
@@ -166,6 +169,7 @@ async function projektSeite(id: string): Promise<void> {
|
||||
<aside class="karte projekt-aufgaben" aria-label="Offene Aufgaben"></aside>
|
||||
</div>`;
|
||||
hinweis.text = "";
|
||||
hinweis.gut = false;
|
||||
const oben = inhalt.querySelector<HTMLElement>("#p-oben")!;
|
||||
const unten = inhalt.querySelector<HTMLElement>("#p-unten")!;
|
||||
const teil = unten.querySelector<HTMLElement>("#teil")!;
|
||||
@@ -213,7 +217,7 @@ async function projektSeite(id: string): Promise<void> {
|
||||
<dl class="werte"><dt>Auftragswert netto</dt><dd>${euro(umsatz)}</dd><dt>Kosten geplant</dt><dd>${euro(kostenGesamt)}</dd>
|
||||
<dt>Rohertrag</dt><dd><b>${euro(umsatz - kostenGesamt)}</b>${umsatz ? ` <small>(${Math.round(((umsatz - kostenGesamt) / umsatz) * 100)} %)</small>` : ""}</dd>
|
||||
<dt>Vertrag</dt><dd>${p.vertragsart ? (p.vertragsart === "vob" ? "VOB/B" : "BGB") : "–"}${p.abnahme_am ? ` · Abnahme ${dat(p.abnahme_am)}` : ""}</dd></dl>
|
||||
<p class="hinweis">Der Vergleich Soll gegen Ist je Kostenart (Lohn, Material, Geräte, Fremdleistung) mit Zeiterfassung und Eingangsrechnungen kommt mit Stufe 5. Bis dahin stehen hier die geplanten Einzelkosten; die Pauschalen änderst du unter „Bearbeiten“.</p>
|
||||
<p class="hinweis">Der Vergleich Soll gegen Ist je Kostenart (Lohn, Material, Geräte, Fremdleistung) mit Zeiterfassung und Eingangsrechnungen kommt mit Stufe 3c. Bis dahin stehen hier die geplanten Einzelkosten; die Pauschalen änderst du unter „Bearbeiten“.</p>
|
||||
<div class="kosten-kopf"><h3>Einzelkosten</h3><button class="neben" data-a="kosten-neu">+ Kosten</button></div><div class="kosten-liste"></div></div>`;
|
||||
const lieferanten = kontaktListe.filter((k) => ["lieferant", "subunternehmer"].includes(k.rolle));
|
||||
const felder: Feld[] = [
|
||||
@@ -249,7 +253,8 @@ async function projektSeite(id: string): Promise<void> {
|
||||
const rechnungen = eigeneZahlungen.filter((z) => z.status !== "geplant").sort((a, b) => (a.rechnungsdatum ?? a.termin).localeCompare(b.rechnungsdatum ?? b.termin));
|
||||
let abschlag = 0;
|
||||
const art = (z: Zeile) => (z.art === "abschlag" ? `${++abschlag}. Abschlag` : ZAHLUNGSART_TEXT[z.art] ?? z.art);
|
||||
teil.innerHTML = `<h3 class="gruppe">Angebote</h3><p class="hinweis leer">Angebote, Kostenvoranschläge und Auftragsbestätigungen schreibst du bis Stufe 5 noch in Plancraft; die PDFs liegen in der Ablage unter „01 Auftrag“.</p>
|
||||
knopf("+ Angebot", () => void neuesAngebot(id));
|
||||
teil.innerHTML = `<h3 class="gruppe">Angebote</h3>${angeboteHtml(angebote)}
|
||||
<h3 class="gruppe">Rechnungen</h3>${rechnungen.length ? `<ul class="dokumente">${rechnungen.map((z) => {
|
||||
const ueberfaellig = z.status === "gestellt" && z.termin < heute();
|
||||
return `<li><button class="dokument" data-zahlung="${z.id}"><span><b>${esc(z.bezeichnung)}</b><span class="unter">${z.rechnungsdatum ? `Rechnung vom ${dat(z.rechnungsdatum)}` : `fällig ${dat(z.termin)}`} · ${euro(z.netto)} netto</span></span>
|
||||
@@ -258,7 +263,7 @@ async function projektSeite(id: string): Promise<void> {
|
||||
}).join("")}</ul>` : '<p class="hinweis leer">Noch keine Rechnung gestellt. Eine Rate wird zur Rechnung, wenn du sie im Zahlungsplan auf „gestellt“ setzt.</p>'}`;
|
||||
} else if (projektTeil === "berichte") {
|
||||
teil.innerHTML = `<p class="hinweis leer">Noch keine Berichte.</p>
|
||||
<ul class="kommt"><li><b>Bautagebuch</b> mit Wetter, Personal und Fotos, am Handy (Stufe 4)</li><li><b>Regiebericht</b> für Stundenlohnarbeiten, unterschreiben lassen (Stufe 4)</li><li><b>Abnahmeprotokoll</b> mit Mängeln und Unterschrift; stellt das Projekt auf Gewährleistung (Stufe 5)</li></ul>`;
|
||||
<ul class="kommt"><li><b>Bautagebuch</b> mit Wetter, Personal und Fotos, am Handy (Stufe 4)</li><li><b>Regiebericht</b> für Stundenlohnarbeiten, unterschreiben lassen (Stufe 4)</li><li><b>Abnahmeprotokoll</b> mit Mängeln und Unterschrift; stellt das Projekt auf Gewährleistung</li></ul>`;
|
||||
} else if (projektTeil === "ablage") {
|
||||
void zeigeAblage();
|
||||
} else {
|
||||
@@ -707,7 +712,7 @@ async function uebersicht(): Promise<void> {
|
||||
<small>${a.faellig_am ? `${WOCHENTAG[wtag(a.faellig_am)]} ${dat(a.faellig_am).slice(0, 6)}` : "ohne Datum"}${a.projekt_nummer ? ` · ${esc(a.projekt_nummer)}` : ""}${a.kontakt_name ? ` · ${esc(a.kontakt_name)}` : ""}</small>${a.kategorie ? `<span class="kategorie">${esc(a.kategorie)}</span>` : ""}</li>`;
|
||||
const gruppe = (titel: string, liste: Zeile[], leer: string, warn = false) => `<div class="gruppe${warn && liste.length ? " warn" : ""}">
|
||||
<h3>${titel} <b>${liste.length}</b></h3>${liste.length ? `<ul class="aufgaben">${liste.map(aufgabeLi).join("")}</ul>` : `<p class="hinweis">${leer}</p>`}</div>`;
|
||||
const SYMBOL: Record<string, string> = { ueberschneidung: "⚠", unbesetzt: "👤", freigabe: "✋", aufgabe: "⏰", kontostand: "€", urlaub: "☀", freistellung: "§" };
|
||||
const SYMBOL: Record<string, string> = { ueberschneidung: "⚠", unbesetzt: "👤", freigabe: "✋", aufgabe: "⏰", kontostand: "€", urlaub: "☀", freistellung: "§", angebot: "✉" };
|
||||
|
||||
const raster = document.createElement("div");
|
||||
raster.className = "start";
|
||||
@@ -864,6 +869,37 @@ async function daten(): Promise<void> {
|
||||
daten();
|
||||
};
|
||||
inhalt.appendChild(knopf);
|
||||
// Stufe 3a: Vorgaben für neue Angebote; ein angelegtes Angebot behält seine Sätze (A36)
|
||||
const k = e.kalkulation;
|
||||
const kalkFelder: Feld[] = [
|
||||
{ name: "planer", titel: "Stundensatz Planer (EK je Stunde)", art: "euro" },
|
||||
{ name: "geselle", titel: "Stundensatz Geselle (EK je Stunde)", art: "euro" },
|
||||
{ name: "helfer", titel: "Stundensatz Helfer (EK je Stunde)", art: "euro", hilfe: "Gilt für neue Angebote. Die genauen Sätze kommen aus deiner Stundensatz-Tabelle." },
|
||||
{ name: "z_lohn", titel: "Zuschlag Lohn (%)", art: "zahl" }, { name: "z_material", titel: "Zuschlag Material (%)", art: "zahl" },
|
||||
{ name: "z_geraet", titel: "Zuschlag Gerät (%)", art: "zahl" }, { name: "z_sonstiges", titel: "Zuschlag Sonstiges (%)", art: "zahl" },
|
||||
{ name: "wagnis", titel: "Wagnis (%)", art: "zahl" }, { name: "gewinn", titel: "Gewinn (%)", art: "zahl" }, { name: "ausfall", titel: "Zahlungsausfall (%)", art: "zahl" },
|
||||
{ name: "bindefristWochen", titel: "Bindefrist (Wochen)", art: "zahl" },
|
||||
{ name: "erinnerungTage", titel: "Erinnerung vor Ablauf der Bindefrist (Tage)", art: "zahl" },
|
||||
{ name: "kopftext", titel: "Einleitung", art: "langtext" },
|
||||
{ name: "schlusstext", titel: "Schlusstext", art: "langtext", hilfe: "{bindefrist} wird durch das Datum ersetzt." },
|
||||
];
|
||||
const kalkKnopf = document.createElement("button");
|
||||
kalkKnopf.className = "neben";
|
||||
kalkKnopf.textContent = "Angebotskalkulation bearbeiten";
|
||||
kalkKnopf.onclick = async () => {
|
||||
const r = await dialog("Angebotskalkulation", kalkFelder, { ...k, ...k.stundensaetze, ...Object.fromEntries(Object.entries(k.zuschlaege).map(([x, v]) => [`z_${x}`, v])) }, false);
|
||||
if (r?.aktion !== "speichern") return;
|
||||
const d = r.daten, z = (n: string, alt: number) => (d[n] ?? alt) as number;
|
||||
await api("einstellungen", "PUT", { ...e, kalkulation: {
|
||||
stundensaetze: { planer: z("planer", 0), geselle: z("geselle", 0), helfer: z("helfer", 0) },
|
||||
zuschlaege: { lohn: z("z_lohn", 0), material: z("z_material", 0), geraet: z("z_geraet", 0), sonstiges: z("z_sonstiges", 0) },
|
||||
wagnis: z("wagnis", 0), gewinn: z("gewinn", 0), ausfall: z("ausfall", 0),
|
||||
bindefristWochen: Math.round(z("bindefristWochen", k.bindefristWochen)), erinnerungTage: Math.round(z("erinnerungTage", k.erinnerungTage)),
|
||||
kopftext: d.kopftext ?? "", schlusstext: d.schlusstext ?? "",
|
||||
} });
|
||||
daten();
|
||||
};
|
||||
inhalt.append(" ", kalkKnopf);
|
||||
await vorlageEditor(e);
|
||||
}
|
||||
|
||||
@@ -977,9 +1013,12 @@ async function zeige(): Promise<void> {
|
||||
const kolonne = /^kolonne-([0-9a-f-]{36})$/.exec(id)?.[1];
|
||||
const sub = /^subunternehmer-([0-9a-f-]{36})$/.exec(id)?.[1];
|
||||
const zuPersonal = mitarbeiter || personalTeil || kolonne || sub;
|
||||
// Angebote (Stufe 3a) gehören zum Reiter Projekte
|
||||
const angebot = /^angebot-([0-9a-f-]{36})$/.exec(id)?.[1];
|
||||
const zuProjekte = treffer || angebot || id === "angebote";
|
||||
const projekt = treffer?.[1];
|
||||
if (treffer?.[2]) projektTeil = treffer[2];
|
||||
const reiter = REITER.find(([r]) => r === (projekt ? "projekte" : zuPersonal ? "personal" : id)) ?? REITER[0]!;
|
||||
const reiter = REITER.find(([r]) => r === (zuProjekte ? "projekte" : zuPersonal ? "personal" : id)) ?? REITER[0]!;
|
||||
nav.querySelectorAll("button").forEach((b) => b.classList.toggle("aktiv", b.dataset.r === reiter[0]));
|
||||
try {
|
||||
await (ablage ? ablageSeite(ablage)
|
||||
@@ -987,7 +1026,9 @@ async function zeige(): Promise<void> {
|
||||
: kolonne && reiter[0] === "personal" ? kolonneSeite(kolonne)
|
||||
: sub && reiter[0] === "personal" ? subunternehmerSeite(sub)
|
||||
: personalTeil && reiter[0] === "personal" ? personalSeite(personalTeil)
|
||||
: projekt && reiter[0] === "projekte" ? projektSeite(projekt) : reiter[2]());
|
||||
: projekt && reiter[0] === "projekte" ? projektSeite(projekt)
|
||||
: angebot && reiter[0] === "projekte" ? angebotSeite(angebot)
|
||||
: id === "angebote" && reiter[0] === "projekte" ? angeboteSeite() : reiter[2]());
|
||||
} catch (e) {
|
||||
inhalt.insertAdjacentHTML("beforeend", `<p class="fehler">${esc((e as Error).message)}</p>`);
|
||||
}
|
||||
|
||||
@@ -700,3 +700,93 @@ table.einfach td:last-child { text-align: right; white-space: nowrap; }
|
||||
.zeile-dazu { display: flex; gap: 8px; margin-top: 10px; flex-wrap: wrap; }
|
||||
.zeile-dazu select { flex: 1; min-width: 0; }
|
||||
.personal-raster #sub-teil { padding: 12px 16px 16px; }
|
||||
|
||||
/* Angebote (Stufe 3a): Leistungsverzeichnis mit Kalkulation, Eingaben direkt in der Tabelle */
|
||||
.erfolg { background: var(--gut-bg); color: var(--gut-text); border-radius: 10px; padding: 10px 14px; margin-bottom: 12px; font-size: 14px; }
|
||||
.angebot-kopf .marke { font-size: 14px; }
|
||||
.kopf-knoepfe { display: flex; gap: 8px; flex-wrap: wrap; }
|
||||
button.gefahr { color: var(--warn); }
|
||||
button.neben.klein { padding: 3px 9px; font-size: 13px; }
|
||||
button.neben:disabled { opacity: 0.4; cursor: default; }
|
||||
.angebot-bezug { margin: -8px 0 14px; color: var(--leise); }
|
||||
.angebot-raster { display: grid; grid-template-columns: minmax(0, 1fr) 330px; gap: 16px; align-items: start; }
|
||||
.angebot-haupt, .angebot-seite { display: flex; flex-direction: column; gap: 16px; min-width: 0; }
|
||||
.angebot-seite h3 { margin: 0 0 8px; font-size: 15px; display: flex; align-items: center; gap: 8px; }
|
||||
.angebot-angaben { display: grid; grid-template-columns: repeat(3, minmax(0, 1fr)); gap: 10px 14px; }
|
||||
.angebot-angaben label, .saetze label, .position-details label { display: flex; flex-direction: column; gap: 4px; font-size: 13px; color: var(--leise); min-width: 0; }
|
||||
.angebot-angaben .breit { grid-column: 1 / -1; }
|
||||
.angebot-angaben p.hinweis { margin: 0; font-size: 13px; }
|
||||
.angebot-raster input, .angebot-raster select, .angebot-raster textarea { width: 100%; min-width: 0; padding: 7px 9px; border: 1px solid var(--linie); border-radius: 7px; background: var(--fl); color: var(--text); font: inherit; font-size: 14px; }
|
||||
.angebot-raster input:focus, .angebot-raster select:focus, .angebot-raster textarea:focus { outline: 2px solid var(--akzent-hell); border-color: var(--akzent); }
|
||||
.angebot-raster input:disabled, .angebot-raster select:disabled, .angebot-raster textarea:disabled { border-color: transparent; background: transparent; color: var(--text); opacity: 1; -webkit-text-fill-color: var(--text); }
|
||||
.angebot-raster input.zahl { text-align: right; font-variant-numeric: tabular-nums; }
|
||||
.angebot-raster input.kurz { width: 100%; }
|
||||
.lv-karte { padding: 0; overflow: hidden; }
|
||||
.lv-rolle { overflow-x: auto; }
|
||||
table.lv { border: 0; border-radius: 0; min-width: 620px; table-layout: fixed; }
|
||||
table.lv col.c-oz { width: 92px; } table.lv col.c-menge { width: 6.5em; } table.lv col.c-einheit { width: 5.2em; }
|
||||
table.lv col.c-ep { width: 7.5em; } table.lv col.c-gb { width: 8.5em; } table.lv col.c-std { width: 4.5em; }
|
||||
.kosten-rolle { overflow-x: auto; max-width: 100%; }
|
||||
.angebot-raster select:disabled { appearance: none; }
|
||||
table.lv th, table.lv td { padding: 6px 8px; }
|
||||
table.lv td.oz { white-space: nowrap; font-variant-numeric: tabular-nums; color: var(--leise); font-size: 13px; width: 1%; }
|
||||
table.lv td.text .marke { margin-top: 3px; display: inline-block; }
|
||||
table.lv tr.titel td { background: var(--bg); font-weight: 600; }
|
||||
table.lv tr.titel input { font-weight: 600; }
|
||||
.titel-zeile { display: flex; gap: 6px; align-items: center; }
|
||||
.titel-knoepfe { display: flex; gap: 4px; flex: none; }
|
||||
table.lv tr.position.zaehlt-nicht td { color: var(--leise); }
|
||||
table.lv tr.position.mit-fehler td.oz { box-shadow: inset 3px 0 0 var(--warn); }
|
||||
table.lv tr.position.auf td { border-bottom-color: transparent; }
|
||||
table.lv tr.details > td { background: var(--bg); }
|
||||
table.lv tr.neu td { border-bottom: 0; padding: 8px; }
|
||||
table.lv tfoot td { border-bottom: 0; }
|
||||
.auf-zu { background: none; border: 0; color: var(--akzent); cursor: pointer; font: inherit; padding: 0 6px 0 0; }
|
||||
button.weg { background: none; border: 0; color: var(--leise); cursor: pointer; font-size: 18px; line-height: 1; padding: 2px 6px; border-radius: 5px; }
|
||||
button.weg:hover { background: var(--warnung-bg); color: var(--warn); }
|
||||
.position-details { display: flex; flex-direction: column; gap: 10px; padding: 4px 0 8px; }
|
||||
.details-zeile { display: flex; gap: 10px 14px; flex-wrap: wrap; align-items: flex-end; }
|
||||
.details-zeile label { width: 13em; }
|
||||
.details-knoepfe { display: flex; gap: 6px; margin-left: auto; flex-wrap: wrap; }
|
||||
.position-details > .hinweis { margin: 0; font-size: 13px; }
|
||||
table.kosten-tabelle { border-radius: 8px; width: auto; }
|
||||
table.kosten-tabelle th, table.kosten-tabelle td { padding: 4px 6px; font-size: 13px; }
|
||||
table.kosten-tabelle td.kz-text { display: flex; gap: 6px; }
|
||||
table.kosten-tabelle td.kz-text select { width: 6.8em; flex: none; }
|
||||
table.kosten-tabelle td.kz-text input { width: 12em; }
|
||||
.angebot-raster input.w-menge { width: 5.5em; }
|
||||
.angebot-raster input.w-euro { width: 6.5em; }
|
||||
.angebot-raster input.w-kurz { width: 4.2em; }
|
||||
.mit-einheit { display: inline-flex; align-items: center; gap: 4px; white-space: nowrap; color: var(--leise); }
|
||||
table.kosten-tabelle tr.kz-lohn td:first-child { box-shadow: inset 3px 0 0 var(--akzent); }
|
||||
table.kosten-tabelle tr.kz-material td:first-child { box-shadow: inset 3px 0 0 var(--holz); }
|
||||
table.kosten-tabelle tr.kz-geraet td:first-child { box-shadow: inset 3px 0 0 var(--ein); }
|
||||
table.kosten-tabelle tr.kz-sonstiges td:first-child { box-shadow: inset 3px 0 0 var(--leise); }
|
||||
table.kosten-tabelle td:first-child select { width: 7.2em; }
|
||||
.summen dl { display: grid; grid-template-columns: 1fr auto; gap: 6px 12px; margin: 0; }
|
||||
.summen dt { color: var(--leise); }
|
||||
.summen dd { margin: 0; text-align: right; font-variant-numeric: tabular-nums; }
|
||||
.summen .brutto { font-weight: 700; font-size: 17px; color: var(--text); border-bottom: 1px solid var(--linie); padding-bottom: 6px; }
|
||||
table.kalk-tabelle { border-radius: 8px; }
|
||||
table.kalk-tabelle th, table.kalk-tabelle td { padding: 5px 7px; font-size: 13px; }
|
||||
table.kalk-tabelle tfoot td { font-weight: 600; border-bottom: 0; }
|
||||
.saetze { display: flex; gap: 8px; flex-wrap: wrap; margin-top: 10px; }
|
||||
.saetze label { flex: 1 1 6em; }
|
||||
.saetze .mit-einheit input { width: 4.5em; }
|
||||
.saetze-mehr { margin-top: 10px; font-size: 14px; }
|
||||
.saetze-mehr summary { cursor: pointer; color: var(--akzent); }
|
||||
.saetze-mehr .hinweis { font-size: 13px; margin: 6px 0 0; }
|
||||
ul.pruefung { margin: 0; padding-left: 18px; font-size: 14px; display: flex; flex-direction: column; gap: 4px; }
|
||||
ul.pruefung li.fehler { color: var(--warn); }
|
||||
ul.pruefung li.hinweis { color: var(--leise); }
|
||||
ul.pruefung .verweis { color: inherit; text-align: left; }
|
||||
.dialog ul.pruefung { margin: 8px 0 12px; }
|
||||
ul.staende { margin: 0; padding-left: 18px; font-size: 14px; }
|
||||
@media (max-width: 1100px) {
|
||||
.angebot-raster { grid-template-columns: 1fr; }
|
||||
}
|
||||
@media (max-width: 800px) {
|
||||
.angebot-angaben { grid-template-columns: 1fr 1fr; }
|
||||
table.lv col.c-std { width: 0; }
|
||||
.kopf-knoepfe { width: 100%; }
|
||||
}
|
||||
|
||||
@@ -184,12 +184,14 @@ export async function bearbeiten(pfad: string, titel: string, felder: Feld[], ze
|
||||
}
|
||||
|
||||
/** Hinweis, der nach dem nächsten Neuaufbau der Seite oben steht */
|
||||
export const hinweis = { text: "" };
|
||||
export const hinweis = { text: "", gut: false };
|
||||
export const hinweisHtml = () => (hinweis.text ? `<div class="${hinweis.gut ? "erfolg" : "warnung"}" role="status">${esc(hinweis.text)}</div>` : "");
|
||||
|
||||
// Kopf wie bei Plancraft: Titel links, Hauptknopf rechts; darunter eine Leiste für Filter
|
||||
export function seite(titel: string, knopf?: { text: string; aktion: () => void }): HTMLElement {
|
||||
inhalt.innerHTML = `<div class="kopf"><h1>${esc(titel)}</h1></div>${hinweis.text ? `<div class="warnung">${esc(hinweis.text)}</div>` : ""}`;
|
||||
inhalt.innerHTML = `<div class="kopf"><h1>${esc(titel)}</h1></div>${hinweisHtml()}`;
|
||||
hinweis.text = "";
|
||||
hinweis.gut = false;
|
||||
if (knopf) {
|
||||
const b = document.createElement("button");
|
||||
b.className = "haupt";
|
||||
|
||||
Reference in New Issue
Block a user