Zahlungen, Kosten und Aufgaben im Terminplan, Aufgaben-Vorlage, Schlussrechnung als Rest, Zahlungsplan verschieben (0.14.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:
@@ -7,7 +7,7 @@ import { randomBytes, timingSafeEqual } from "node:crypto";
|
||||
import { z, ZodError } from "zod";
|
||||
import { type Client, type Pool, transaktion } from "./db.js";
|
||||
import { mitNeuplanung, pruefeVerknuepfung, terminplan } from "./terminplan.js";
|
||||
import { legeZahlungsplanAn, zahlungsplanFest, zahlungsplaeneAutomatisch } from "./zahlungsplan.js";
|
||||
import { legeZahlungsplanAn, restNachziehen, zahlungsplanFest, zahlungsplaeneAutomatisch } from "./zahlungsplan.js";
|
||||
import { uebersicht } from "./uebersicht.js";
|
||||
import { aufgabenKalender, baustellenKalender } from "./kalender.js";
|
||||
import { type Nextcloud, ordnerAbgleichen } from "./nextcloud.js";
|
||||
@@ -24,6 +24,8 @@ import { istEingeteilt, registriereIch } from "./ich.js";
|
||||
import { registrierePersonal } from "./personal.js";
|
||||
import { registriereZeiten } from "./zeiten.js";
|
||||
import { registriereUrlaub, zeitraumText } from "./urlaub.js";
|
||||
import { vorlageAnwenden } from "./vorlage.js";
|
||||
import { type BezugArt, bezugsTage } from "../domain/bezug.js";
|
||||
|
||||
export interface Optionen {
|
||||
pool: Pool;
|
||||
@@ -149,18 +151,37 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
|
||||
// Änderungen an Vorgängen und Verknüpfungen planen die Nachfolger in derselben Transaktion neu
|
||||
// T15: auch Besetzung, Abwesenheiten und Arbeitszeitmodelle ändern die Dauer berechneter Vorgänge
|
||||
const PLAN = new Set(["vorgang", "vorgang_vorgaenger", "zahlung", "besetzung", "abwesenheit", "arbeitszeitmodell"]);
|
||||
// Zahlungen, Kosten und Aufgaben können an Vorgängen hängen und wandern dann mit
|
||||
const PLAN = new Set(["vorgang", "vorgang_vorgaenger", "zahlung", "kosten", "aufgabe", "besetzung", "abwesenheit", "arbeitszeitmodell"]);
|
||||
// P12: Projektänderungen legen den Zahlungsplan an oder führen ihn nach; eine Rate von Hand ändern stellt ihn fest
|
||||
async function geplant<T>(c: Client, tabelle: string, fn: () => Promise<T>, bewegt: string[] = [], zahlungVon?: string): Promise<T> {
|
||||
const e = await ladeEinstellungen();
|
||||
if (tabelle === "projekt") {
|
||||
const ergebnis = await fn();
|
||||
await zahlungsplaeneAutomatisch(c, { tage: e.arbeitstage });
|
||||
await restNachziehen(c);
|
||||
await vorlageAnwenden(c, e.aufgabenVorlage, { tage: e.arbeitstage });
|
||||
return ergebnis;
|
||||
}
|
||||
if (!PLAN.has(tabelle)) return fn();
|
||||
const aenderung = zahlungVon ? async () => { const r = await fn(); await zahlungsplanFest(c, zahlungVon); return r; } : fn;
|
||||
return (await mitNeuplanung(c, { tage: e.arbeitstage }, aenderung, bewegt, e.stundenProTag)).ergebnis;
|
||||
return (await mitNeuplanung(c, { tage: e.arbeitstage }, aenderung, bewegt, e.stundenProTag, e.aufgabenVorlage)).ergebnis;
|
||||
}
|
||||
|
||||
// Wer das Datum einer verknüpften Zahlung, Kosten oder Aufgabe ändert (z. B. die Raute im Terminplan zieht),
|
||||
// ändert den Versatz zum Vorgang: sie bleibt verknüpft und wandert weiter mit
|
||||
const DATUM_FELD: Record<string, string> = { zahlung: "termin", kosten: "termin", aufgabe: "faellig_am" };
|
||||
async function versatzAusDatum(c: Client, tabelle: string, daten: Record<string, unknown>, id?: string): Promise<void> {
|
||||
const feld = DATUM_FELD[tabelle];
|
||||
if (!feld || typeof daten[feld] !== "string" || daten.bezug_tage !== undefined) return;
|
||||
const alt = id ? (await c.query(`select vorgang_id, bezug_art from ${tabelle} where id = $1`, [id])).rows[0] : undefined;
|
||||
const vid = (daten.vorgang_id !== undefined ? daten.vorgang_id : alt?.vorgang_id) as string | null | undefined;
|
||||
if (!vid) return;
|
||||
const v = (await c.query("select id, start, dauer from vorgang where id = $1", [vid])).rows[0];
|
||||
if (!v) return;
|
||||
const e = await ladeEinstellungen();
|
||||
const art = (daten.bezug_art ?? alt?.bezug_art ?? "EE") as BezugArt;
|
||||
daten.bezug_tage = bezugsTage({ ...v, dauer: Number(v.dauer) }, art, daten[feld] as string, { tage: e.arbeitstage });
|
||||
}
|
||||
const projektDerZahlung = async (c: Client, tabelle: string, id: string) =>
|
||||
tabelle === "zahlung" ? (await c.query("select projekt_id from zahlung where id = $1", [id])).rows[0]?.projekt_id as string | undefined : undefined;
|
||||
@@ -191,9 +212,10 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
app.post(`/api/${t.pfad}`, async (req, reply) => {
|
||||
const daten = t.schema.parse(req.body) as Record<string, unknown>;
|
||||
if (verboten(req, t, daten)) return reply.status(403).send({ fehler: "Dafür fehlt dir die Berechtigung." });
|
||||
const spalten = felder.filter((f) => daten[f] !== undefined);
|
||||
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 versatzAusDatum(c, t.name, daten);
|
||||
const spalten = felder.filter((f) => daten[f] !== undefined);
|
||||
return geplant(c, t.name, async () =>
|
||||
(await c.query(
|
||||
spalten.length
|
||||
@@ -212,9 +234,10 @@ 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." });
|
||||
// T15: wer die Dauer von Hand ändert, legt sie fest (wie beim Zahlungsplan)
|
||||
if (t.name === "vorgang" && daten.dauer !== undefined && daten.dauer_fest === undefined) daten.dauer_fest = true;
|
||||
const spalten = felder.filter((f) => daten[f] !== undefined);
|
||||
if (spalten.length === 0) return reply.status(400).send({ fehler: "Keine Änderung angegeben" });
|
||||
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 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)) {
|
||||
const alt = (await c.query("select vorgang_id, vorgaenger_id from vorgang_vorgaenger where id = $1", [id])).rows[0];
|
||||
if (alt) await pruefeVerknuepfung(c, { ...alt, ...daten } as { vorgang_id: string; vorgaenger_id: string }, id);
|
||||
@@ -247,10 +270,19 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
|
||||
app.put("/api/einstellungen", async (req) => {
|
||||
const neu = EinstellungenSchema.parse(req.body);
|
||||
await transaktion(pool, benutzer(req), (c) => c.query("update einstellungen set daten = $1", [neu]));
|
||||
await transaktion(pool, benutzer(req), async (c) => {
|
||||
await c.query("update einstellungen set daten = $1", [neu]);
|
||||
await vorlageAnwenden(c, neu.aufgabenVorlage, { tage: neu.arbeitstage });
|
||||
});
|
||||
return neu;
|
||||
});
|
||||
|
||||
// Aufgaben-Vorlage auf alle beauftragten Projekte anwenden (Testversion nach dem Laden, Server nach dem Update)
|
||||
app.post("/api/vorlage/anwenden", async (req) => {
|
||||
const e = await ladeEinstellungen();
|
||||
return { neu: await transaktion(pool, benutzer(req), (c) => vorlageAnwenden(c, e.aufgabenVorlage, { tage: e.arbeitstage })) };
|
||||
});
|
||||
|
||||
const LiquiAnfrage = z.object({
|
||||
ansicht: z.enum(["woche", "monat"]).default("woche"),
|
||||
start: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
|
||||
|
||||
@@ -1,5 +1,23 @@
|
||||
import { z } from "zod";
|
||||
|
||||
// Aufgaben, die jedes beauftragte Projekt von selbst bekommt (Henning, 20.10.2026), an einem Vorgang festgemacht:
|
||||
// bezug ist ein Wort aus dem Vorgangsnamen („Abbund“), leer = der erste Vorgang des Projekts
|
||||
export const VorlageEintrag = z.object({
|
||||
id: z.string().regex(/^[a-z0-9-]{1,40}$/),
|
||||
text: z.string().trim().min(1).max(200),
|
||||
bezug: z.string().trim().max(60).default(""),
|
||||
art: z.enum(["AA", "EE"]).default("AA"),
|
||||
tage: z.number().int().min(-500).max(500).default(0),
|
||||
kategorie_id: z.string().nullable().default(null),
|
||||
});
|
||||
export type VorlageEintrag = z.infer<typeof VorlageEintrag>;
|
||||
export const STANDARD_VORLAGE: VorlageEintrag[] = [
|
||||
{ id: "statik", text: "Statik anfordern", bezug: "Abbund", art: "AA", tage: -15, kategorie_id: null },
|
||||
{ id: "material", text: "Material bestellen", bezug: "Abbund", art: "AA", tage: -7, kategorie_id: null },
|
||||
{ id: "geruest", text: "Gerüst bestellen", bezug: "Richten", art: "AA", tage: -5, kategorie_id: null },
|
||||
{ id: "sub", text: "Subunternehmer beauftragen", bezug: "", art: "AA", tage: -10, kategorie_id: null },
|
||||
];
|
||||
|
||||
export const EinstellungenSchema = z.object({
|
||||
arbeitstage: z.array(z.number().int().min(1).max(7)).default([1, 2, 3, 4]),
|
||||
stundenProTag: z.number().positive().default(8),
|
||||
@@ -31,6 +49,7 @@ export const EinstellungenSchema = z.object({
|
||||
pausenabzug: z.enum(["bis_grenze", "voll"]).default("bis_grenze"),
|
||||
// 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),
|
||||
});
|
||||
|
||||
export type Einstellungen = z.infer<typeof EinstellungenSchema>;
|
||||
|
||||
@@ -1,5 +1,7 @@
|
||||
import { randomBytes } from "node:crypto";
|
||||
import { erstellePool } from "./db.js";
|
||||
import { erstellePool, transaktion } from "./db.js";
|
||||
import { EinstellungenSchema } from "./einstellungen.js";
|
||||
import { vorlageAnwenden } from "./vorlage.js";
|
||||
import { migriere } from "./migrate.js";
|
||||
import { baueApp } from "./app.js";
|
||||
import { Nextcloud } from "./nextcloud.js";
|
||||
@@ -12,6 +14,12 @@ if (!url) {
|
||||
|
||||
const pool = erstellePool(url);
|
||||
await migriere(pool, (t) => console.log(t));
|
||||
// Aufgaben-Vorlage für Projekte, die seit dem letzten Start nichts geändert haben (z. B. nach einem Update)
|
||||
{
|
||||
const e = EinstellungenSchema.parse((await pool.query("select daten from einstellungen limit 1")).rows[0]?.daten ?? {});
|
||||
const neu = await transaktion(pool, "system", (c) => vorlageAnwenden(c, e.aufgabenVorlage, { tage: e.arbeitstage }));
|
||||
if (neu) console.log(`Aufgaben-Vorlage: ${neu} neue Aufgaben angelegt`);
|
||||
}
|
||||
// P10: Ordner der Projekte; gleicher Zugang wie für die Sicherung, eigene Adresse
|
||||
const { NEXTCLOUD_PROJEKTE_URL: ncUrl, NEXTCLOUD_BENUTZER: ncBenutzer, NEXTCLOUD_PASSWORT: ncPasswort } = process.env;
|
||||
const nextcloud = ncUrl && ncBenutzer && ncPasswort ? new Nextcloud({ url: ncUrl, benutzer: ncBenutzer, passwort: ncPasswort }) : undefined;
|
||||
|
||||
@@ -0,0 +1,29 @@
|
||||
-- Zahlungen, Kosten und Aufgaben im Terminplan (Henning, 20.10.2026): jede kann an einem Vorgang hängen,
|
||||
-- am Anfang (AA) oder Ende (EE) mit Versatz in Arbeitstagen, und wandert mit ihm.
|
||||
-- Raten hingen schon bisher am Ende ihres Vorgangs (vorgang_id): das ist EE ohne Versatz.
|
||||
alter table zahlung
|
||||
add column bezug_art text not null default 'EE' check (bezug_art in ('AA', 'EE')),
|
||||
add column bezug_tage integer not null default 0;
|
||||
alter table kosten
|
||||
add column vorgang_id uuid references vorgang (id) on delete set null,
|
||||
add column bezug_art text not null default 'EE' check (bezug_art in ('AA', 'EE')),
|
||||
add column bezug_tage integer not null default 0;
|
||||
alter table aufgabe
|
||||
add column vorgang_id uuid references vorgang (id) on delete set null,
|
||||
add column bezug_art text not null default 'EE' check (bezug_art in ('AA', 'EE')),
|
||||
add column bezug_tage integer not null default 0,
|
||||
-- aus welchem Eintrag der Aufgaben-Vorlage sie stammt
|
||||
add column vorlage text;
|
||||
|
||||
-- Welche Einträge der Aufgaben-Vorlage ein Projekt schon bekommen hat; wer eine solche Aufgabe löscht,
|
||||
-- bekommt sie nicht wieder
|
||||
create table projekt_vorlage (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
projekt_id uuid not null references projekt (id) on delete cascade,
|
||||
vorlage text not null,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
unique (projekt_id, vorlage)
|
||||
);
|
||||
|
||||
-- Schlussrechnung ohne eigenen Betrag (Henning, 20.10.2026): Rest aus Auftragswert minus alle anderen Raten
|
||||
alter table zahlung add column rest boolean not null default false;
|
||||
@@ -128,6 +128,9 @@ export const TABELLEN: Tabelle[] = [
|
||||
bezahlt_am: datum.nullable().optional(),
|
||||
reihenfolge: z.number().int().optional(),
|
||||
zahlungsziel_tage: z.number().int().min(0).nullable().optional(),
|
||||
bezug_art: z.enum(["AA", "EE"]).optional(),
|
||||
bezug_tage: z.number().int().min(-500).max(500).optional(),
|
||||
rest: z.boolean().optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
@@ -144,6 +147,9 @@ export const TABELLEN: Tabelle[] = [
|
||||
mit_vorsteuer: z.boolean().optional(),
|
||||
status: z.enum(["geplant", "bestellt", "bezahlt"]).optional(),
|
||||
zahlungsziel_tage: z.number().int().min(0).nullable().optional(),
|
||||
vorgang_id: id.nullable().optional(),
|
||||
bezug_art: z.enum(["AA", "EE"]).optional(),
|
||||
bezug_tage: z.number().int().min(-500).max(500).optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
@@ -181,6 +187,9 @@ export const TABELLEN: Tabelle[] = [
|
||||
kontakt_id: id.nullable().optional(),
|
||||
kategorie_id: id.nullable().optional(),
|
||||
erledigt_am: z.iso.datetime({ offset: true }).nullable().optional(),
|
||||
vorgang_id: id.nullable().optional(),
|
||||
bezug_art: z.enum(["AA", "EE"]).optional(),
|
||||
bezug_tage: z.number().int().min(-500).max(500).optional(),
|
||||
}),
|
||||
},
|
||||
// Stufe 2: Personal (M1, M8, M4, M10)
|
||||
@@ -243,4 +252,5 @@ export const TABELLEN: Tabelle[] = [
|
||||
export const NUR_SICHERUNG: { name: string; pfad: string; sortierung: string }[] = [
|
||||
{ name: "zeiteintrag", pfad: "zeiteintraege", sortierung: "datum, kontakt_id" },
|
||||
{ name: "zeitanteil", pfad: "zeitanteile", sortierung: "zeiteintrag_id, reihenfolge" },
|
||||
{ name: "projekt_vorlage", pfad: "projekt_vorlagen", sortierung: "projekt_id, vorlage" },
|
||||
];
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
// Terminplan auf dem Server: Laden für das Gantt und Neuplanung der Nachfolger nach jeder
|
||||
// Änderung an Vorgängen oder Verknüpfungen, in derselben Transaktion.
|
||||
import { zahlungsplaeneAutomatisch } from "./zahlungsplan.js";
|
||||
import { restNachziehen, zahlungsplaeneAutomatisch } from "./zahlungsplan.js";
|
||||
import type { Client, Pool } from "./db.js";
|
||||
import type { Arbeitswoche } from "../domain/kalender.js";
|
||||
import { kuerzel, ueberschneidungen } from "../domain/einsatz.js";
|
||||
@@ -8,6 +8,9 @@ import { type PlanVorgang, type Verknuepfung, anfang, bildetKreis, ende, engeVor
|
||||
import { type KapBesetzung, type Personaldaten, auslastung, dauerNachBesetzung, reduzierteTage } from "../domain/kapazitaet.js";
|
||||
import { ladePersonal } from "./personal.js";
|
||||
import { plusTage } from "../domain/datum.js";
|
||||
import { type BezugArt, bezugsTermin } from "../domain/bezug.js";
|
||||
import type { VorlageEintrag } from "./einstellungen.js";
|
||||
import { vorlageAnwenden } from "./vorlage.js";
|
||||
|
||||
export class PlanFehler extends Error {
|
||||
statusCode = 409;
|
||||
@@ -38,7 +41,7 @@ async function ladeKapazitaet(c: Client | Pool, stundenProTag: number): Promise<
|
||||
* Gibt die IDs der verschobenen Vorgänge zurück.
|
||||
*/
|
||||
export async function mitNeuplanung<T>(
|
||||
c: Client, woche: Arbeitswoche, aenderung: () => Promise<T>, bewegt: string[] = [], stundenProTag = 8,
|
||||
c: Client, woche: Arbeitswoche, aenderung: () => Promise<T>, bewegt: string[] = [], stundenProTag = 8, vorlage?: VorlageEintrag[],
|
||||
): Promise<{ ergebnis: T; verschoben: string[] }> {
|
||||
const vorher = await ladeStand(c);
|
||||
const eng = engeVorgaenge(vorher.vorgaenge, vorher.links, woche);
|
||||
@@ -58,19 +61,31 @@ export async function mitNeuplanung<T>(
|
||||
}
|
||||
for (const [id, start] of starts) await c.query("update vorgang set start = $2 where id = $1", [id, start]);
|
||||
for (const [id, dauer] of dauern) await c.query("update vorgang set dauer = $2 where id = $1", [id, dauer]);
|
||||
await zahlungenNachziehen(c, woche);
|
||||
await bezuegeNachziehen(c, woche);
|
||||
await zahlungsplaeneAutomatisch(c, woche);
|
||||
await restNachziehen(c);
|
||||
if (vorlage) await vorlageAnwenden(c, vorlage, woche);
|
||||
return { ergebnis, verschoben: [...new Set([...starts.keys(), ...dauern.keys()])] };
|
||||
}
|
||||
|
||||
/** Geplante Raten, die an einem Vorgang hängen, werden mit dessen Ende fällig und wandern mit ihm. */
|
||||
export async function zahlungenNachziehen(c: Client, woche: Arbeitswoche): Promise<void> {
|
||||
const r = await c.query<{ id: string; termin: string; start: string; dauer: number }>(
|
||||
`select z.id, z.termin, v.start, v.dauer from zahlung z join vorgang v on v.id = z.vorgang_id
|
||||
where coalesce(z.status, 'geplant') = 'geplant'`);
|
||||
for (const z of r.rows) {
|
||||
const e = ende({ id: z.id, start: z.start, dauer: Number(z.dauer) }, woche);
|
||||
if (e !== z.termin) await c.query("update zahlung set termin = $2 where id = $1", [z.id, e]);
|
||||
/**
|
||||
* Was an einem Vorgang hängt, wandert mit ihm: geplante Raten, nicht bezahlte Kosten und offene Aufgaben.
|
||||
* Bezug am Anfang (AA) oder Ende (EE) mit Versatz in Arbeitstagen.
|
||||
*/
|
||||
export async function bezuegeNachziehen(c: Client, woche: Arbeitswoche): Promise<void> {
|
||||
const teile: [string, string, string][] = [
|
||||
["zahlung", "termin", "coalesce(x.status, 'geplant') = 'geplant'"],
|
||||
["kosten", "termin", "x.status <> 'bezahlt'"],
|
||||
["aufgabe", "faellig_am", "x.erledigt_am is null"],
|
||||
];
|
||||
for (const [tabelle, feld, offen] of teile) {
|
||||
const r = await c.query<{ id: string; datum: string | null; bezug_art: BezugArt; bezug_tage: number; vid: string; start: string; dauer: number }>(
|
||||
`select x.id, x.${feld} as datum, x.bezug_art, x.bezug_tage, v.id as vid, v.start, v.dauer
|
||||
from ${tabelle} x join vorgang v on v.id = x.vorgang_id where ${offen}`);
|
||||
for (const z of r.rows) {
|
||||
const soll = bezugsTermin({ id: z.vid, start: z.start, dauer: Number(z.dauer) }, z.bezug_art, Number(z.bezug_tage), woche);
|
||||
if (soll !== z.datum) await c.query(`update ${tabelle} set ${feld} = $2 where id = $1`, [z.id, soll]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -84,7 +99,7 @@ export async function pruefeVerknuepfung(c: Client, neu: { vorgang_id: string; v
|
||||
|
||||
/** Alles, was das Gantt braucht, mit berechnetem Anfang und Ende je Vorgang. */
|
||||
export async function terminplan(pool: Pool, woche: Arbeitswoche, stundenProTag = 8) {
|
||||
const [projekte, abschnitte, vorgaenge, links, besetzungen, leute, zahlungen] = await Promise.all([
|
||||
const [projekte, abschnitte, vorgaenge, links, besetzungen, leute, zahlungen, kosten, aufgaben] = await Promise.all([
|
||||
pool.query(`select p.id, p.nummer, p.bezeichnung, p.status, p.farbe, p.reihenfolge, p.umsatz_netto, p.zahlungsplan, k.name as bauherr
|
||||
from projekt p left join kontakt k on k.id = p.bauherr_id order by p.reihenfolge, p.nummer`),
|
||||
pool.query("select id, projekt_id, name, ist_meilenstein, reihenfolge from abschnitt order by reihenfolge, name"),
|
||||
@@ -93,7 +108,12 @@ export async function terminplan(pool: Pool, woche: Arbeitswoche, stundenProTag
|
||||
pool.query(`select b.id, b.vorgang_id, b.kontakt_id, b.platzhalter, b.personen, b.freigegeben, k.name, k.firma, k.rolle
|
||||
from besetzung b left join kontakt k on k.id = b.kontakt_id order by b.angelegt_am`),
|
||||
pool.query("select id, name, firma, rolle from kontakt where rolle in ('mitarbeiter', 'subunternehmer') order by rolle, name"),
|
||||
pool.query("select id, projekt_id, vorgang_id, art, bezeichnung, netto, termin, status from zahlung order by termin, reihenfolge"),
|
||||
pool.query("select id, projekt_id, vorgang_id, bezug_art, bezug_tage, art, bezeichnung, netto, termin, status, rest, reihenfolge from zahlung order by reihenfolge, termin"),
|
||||
pool.query("select id, projekt_id, vorgang_id, bezug_art, bezug_tage, art, bezeichnung, netto, termin, status from kosten order by termin, bezeichnung"),
|
||||
// Aufgaben eines Projekts stehen im Terminplan in dessen Abschnitt „Aufgaben“
|
||||
pool.query(`select a.id, a.projekt_id, a.vorgang_id, a.bezug_art, a.bezug_tage, a.text, a.faellig_am, a.erledigt_am, a.kategorie_id, g.name as kategorie
|
||||
from aufgabe a left join aufgabe_kategorie g on g.id = a.kategorie_id where a.projekt_id is not null
|
||||
order by a.faellig_am nulls last, a.angelegt_am`),
|
||||
]);
|
||||
const kap = await ladeKapazitaet(pool, stundenProTag);
|
||||
const vs = vorgaenge.rows.map((v) => {
|
||||
@@ -130,6 +150,8 @@ export async function terminplan(pool: Pool, woche: Arbeitswoche, stundenProTag
|
||||
besetzungen: bs,
|
||||
leute: leute.rows,
|
||||
zahlungen: zahlungen.rows,
|
||||
kosten: kosten.rows,
|
||||
aufgaben: aufgaben.rows,
|
||||
ueberschneidungen: ueberschneidungen(vs, bs).map((u) => ({ ...u, name: anzeige.get(u.wer) ?? u.wer })),
|
||||
arbeitstage: woche.tage,
|
||||
team,
|
||||
|
||||
50
src/server/vorlage.ts
Normal file
50
src/server/vorlage.ts
Normal file
@@ -0,0 +1,50 @@
|
||||
// Aufgaben-Vorlage (Henning, 20.10.2026): jedes beauftragte Projekt bekommt Aufgaben wie „Material bestellen,
|
||||
// 7 Arbeitstage vor Abbund“. Sie hängen am passenden Vorgang, wandern mit ihm und stehen in den Aufgaben,
|
||||
// in der Übersicht und im Terminplan. Jeder Eintrag kommt je Projekt nur einmal: wer die Aufgabe löscht,
|
||||
// bekommt sie nicht wieder.
|
||||
import type { Client } from "./db.js";
|
||||
import type { VorlageEintrag } from "./einstellungen.js";
|
||||
import type { Arbeitswoche } from "../domain/kalender.js";
|
||||
import { anfang } from "../domain/terminplan.js";
|
||||
import { bezugsTermin } from "../domain/bezug.js";
|
||||
|
||||
/** Projekte, die Vorlage-Aufgaben bekommen */
|
||||
export const MIT_VORLAGE = ["auftrag", "ausfuehrung"];
|
||||
|
||||
/**
|
||||
* Legt fehlende Vorlage-Aufgaben an. Ein Eintrag wartet, bis das Projekt einen passenden Vorgang hat.
|
||||
* Hat dieser Vorgang schon angefangen oder wäre die Aufgabe schon überfällig (laufende Projekte), gilt sie als
|
||||
* erledigt und wird nur vermerkt.
|
||||
* Gibt die Zahl der neuen Aufgaben zurück.
|
||||
*/
|
||||
export async function vorlageAnwenden(c: Client, vorlage: VorlageEintrag[], woche: Arbeitswoche, heute = new Date().toISOString().slice(0, 10)): Promise<number> {
|
||||
if (!vorlage.length) return 0;
|
||||
const projekte = (await c.query<{ id: string }>("select id from projekt where status = any($1)", [MIT_VORLAGE])).rows;
|
||||
if (!projekte.length) return 0;
|
||||
const vs = (await c.query<{ id: string; projekt_id: string; name: string; start: string; dauer: number }>(
|
||||
`select v.id, a.projekt_id, v.name, v.start, v.dauer from vorgang v join abschnitt a on a.id = v.abschnitt_id
|
||||
where a.projekt_id = any($1)`, [projekte.map((p) => p.id)])).rows.map((v) => ({ ...v, dauer: Number(v.dauer) }));
|
||||
const schon = new Set((await c.query<{ projekt_id: string; vorlage: string }>("select projekt_id, vorlage from projekt_vorlage")).rows.map((r) => `${r.projekt_id}/${r.vorlage}`));
|
||||
let neu = 0;
|
||||
for (const p of projekte) {
|
||||
const eigene = vs.filter((v) => v.projekt_id === p.id).map((v) => ({ ...v, anfang: anfang(v, woche) })).sort((a, b) => a.anfang.localeCompare(b.anfang));
|
||||
if (!eigene.length) continue;
|
||||
for (const e of vorlage) {
|
||||
if (schon.has(`${p.id}/${e.id}`)) continue;
|
||||
const wort = e.bezug.trim().toLowerCase();
|
||||
const anker = wort ? eigene.find((v) => v.name.toLowerCase().includes(wort)) : eigene[0];
|
||||
if (!anker) continue;
|
||||
await c.query("insert into projekt_vorlage (projekt_id, vorlage) values ($1, $2)", [p.id, e.id]);
|
||||
schon.add(`${p.id}/${e.id}`);
|
||||
// laufende Projekte: was schon hätte erledigt sein müssen, ist es vermutlich auch
|
||||
const termin = bezugsTermin(anker, e.art, e.tage, woche);
|
||||
if (anker.anfang < heute || termin < heute) continue;
|
||||
await c.query(
|
||||
`insert into aufgabe (text, projekt_id, kategorie_id, vorgang_id, bezug_art, bezug_tage, faellig_am, vorlage)
|
||||
values ($1, $2, (select id from aufgabe_kategorie where id::text = $3), $4, $5, $6, $7, $8)`,
|
||||
[e.text, p.id, e.kategorie_id ?? "", anker.id, e.art, e.tage, termin, e.id]);
|
||||
neu++;
|
||||
}
|
||||
}
|
||||
return neu;
|
||||
}
|
||||
@@ -20,8 +20,8 @@ export async function legeZahlungsplanAn(c: Client, projektId: string, umsatz: n
|
||||
const neu = [];
|
||||
for (const [i, z] of (await vorschlag(c, projektId, umsatz, woche)).entries()) {
|
||||
neu.push((await c.query(
|
||||
`insert into zahlung (projekt_id, vorgang_id, art, bezeichnung, netto, termin, status, reihenfolge) values ($1, $2, $3, $4, $5, $6, 'geplant', $7) returning *`,
|
||||
[projektId, z.vorgang_id, z.art, z.bezeichnung, z.netto, z.termin, i])).rows[0]);
|
||||
`insert into zahlung (projekt_id, vorgang_id, art, bezeichnung, netto, termin, status, reihenfolge, rest) values ($1, $2, $3, $4, $5, $6, 'geplant', $7, $8) returning *`,
|
||||
[projektId, z.vorgang_id, z.art, z.bezeichnung, z.netto, z.termin, i, z.art === "schluss"])).rows[0]);
|
||||
}
|
||||
await c.query("update projekt set zahlungsplan = 'auto' where id = $1", [projektId]);
|
||||
return neu;
|
||||
@@ -57,3 +57,14 @@ export async function zahlungsplaeneAutomatisch(c: Client, woche: Arbeitswoche):
|
||||
export async function zahlungsplanFest(c: Client, projektId: string): Promise<void> {
|
||||
await c.query("update projekt set zahlungsplan = 'fest' where id = $1 and zahlungsplan is distinct from 'fest'", [projektId]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Schlussrechnung ohne eigenen Betrag (Henning, 20.10.2026): solange sie geplant ist, ist sie der Rest aus
|
||||
* Auftragswert und allen anderen Raten (gestellt, bezahlt und noch geplant), damit nichts doppelt zählt.
|
||||
*/
|
||||
export async function restNachziehen(c: Client): Promise<void> {
|
||||
await c.query(`update zahlung z set netto = r.soll from (
|
||||
select z2.id, greatest(0, coalesce(p.umsatz_netto, 0) - coalesce((select sum(a.netto) from zahlung a where a.projekt_id = z2.projekt_id and a.id <> z2.id), 0)) as soll
|
||||
from zahlung z2 join projekt p on p.id = z2.projekt_id where z2.rest and z2.status = 'geplant') r
|
||||
where z.id = r.id and z.netto <> r.soll`);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user