Compare commits
8 Commits
a3ab0c1d46
...
e406c5a842
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
e406c5a842 | ||
|
|
a3bb310cea | ||
|
|
6615acf936 | ||
|
|
c2bbeff713 | ||
|
|
8a4fbafa65 | ||
|
|
aedd86a29b | ||
|
|
57b9ff5d26 | ||
|
|
cc1116a540 |
13
CHANGELOG.md
13
CHANGELOG.md
@@ -2,6 +2,19 @@
|
||||
|
||||
Neueste Version oben. Erste Zahl: großer Umbau, zweite: neue Funktionen, dritte: Fehlerbehebungen.
|
||||
|
||||
## 0.2.0
|
||||
|
||||
Stufe 1, Aufgaben und Termine:
|
||||
|
||||
- Neues Aussehen in den Logofarben mit Blautönen, aufgebaut ähnlich wie Plancraft; auf dem Handy wird die Seitenleiste zur Kopfleiste.
|
||||
- Startseite: Aufgaben (diese Woche, überfällig, langfristig) und Warnungen nebeneinander, darunter „Wer macht was“ für die nächsten 8 Arbeitstage und die Liquidität.
|
||||
- Terminplan als Gantt mit Tag-, Wochen- und Monatsansicht, Balken ziehen und in der Länge ändern, Meilensteine, mehrere Vorgänger (EA, AA, EE, AE mit Versatz), Nachfolger rücken mit, Kreise werden abgelehnt.
|
||||
- Besetzung je Vorgang mit Mitarbeitern, Subunternehmern, Kolonnen und Platzhaltern; Fremde zählen erst nach Freigabe; Warnung bei Doppelbelegung.
|
||||
- Filter nach Person, Subunternehmer oder Kolonne.
|
||||
- Kalender-Abos „Baustellen“ und „Aufgaben“ für Outlook classic.
|
||||
- Projektordner in der Nextcloud werden angelegt und je nach Status verschoben.
|
||||
- Aufgaben werden aus der V70-Sicherung übernommen, Vorgangsnummern bleiben erhalten.
|
||||
|
||||
## 0.1.0
|
||||
|
||||
- Grundgerüst für Stufe 0: Server mit Datenbank, Änderungsprotokoll (wer hat wann was geändert), Export als JSON.
|
||||
|
||||
@@ -14,3 +14,5 @@ BACKUP_UHRZEIT=02:30
|
||||
NEXTCLOUD_URL=https://cloud.example.de/remote.php/dav/files/henning/Sicherungen/betrieb
|
||||
NEXTCLOUD_BENUTZER=henning
|
||||
NEXTCLOUD_PASSWORT=app-passwort-aus-nextcloud
|
||||
# Ordner, in dem „01 Angebot“, „02 laufende Projekte“, „03 Gewährl.-Projekte“ und „04 Archiv“ liegen (P10)
|
||||
NEXTCLOUD_PROJEKTE_URL=https://cloud.example.de/remote.php/dav/files/henning/Projekte
|
||||
|
||||
@@ -1,6 +1,8 @@
|
||||
# HTTPS mit automatischem Zertifikat für Produktion und Testumgebung.
|
||||
# Bis zur eigenen Benutzerverwaltung (Modul 16) schützt eine Anmeldung am Proxy
|
||||
# das Programm; der Name geht als X-Benutzer an die App und ins Änderungsprotokoll.
|
||||
# Ausnahme: die Kalender-Abos unter /kalender/ (Outlook classic kann sich nicht anmelden);
|
||||
# sie sind durch ein Geheimnis im Link geschützt, das die App prüft.
|
||||
(anmeldung) {
|
||||
basic_auth {
|
||||
{$APP_BENUTZER} {$APP_PASSWORT_HASH}
|
||||
@@ -9,16 +11,26 @@
|
||||
|
||||
{$DOMAIN} {
|
||||
encode gzip
|
||||
import anmeldung
|
||||
reverse_proxy app:3000 {
|
||||
header_up X-Benutzer {http.auth.user.id}
|
||||
handle /kalender/* {
|
||||
reverse_proxy app:3000
|
||||
}
|
||||
handle {
|
||||
import anmeldung
|
||||
reverse_proxy app:3000 {
|
||||
header_up X-Benutzer {http.auth.user.id}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
{$TEST_DOMAIN} {
|
||||
encode gzip
|
||||
import anmeldung
|
||||
reverse_proxy app-test:3000 {
|
||||
header_up X-Benutzer {http.auth.user.id}
|
||||
handle /kalender/* {
|
||||
reverse_proxy app-test:3000
|
||||
}
|
||||
handle {
|
||||
import anmeldung
|
||||
reverse_proxy app-test:3000 {
|
||||
header_up X-Benutzer {http.auth.user.id}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -41,6 +41,9 @@ services:
|
||||
image: ${IMAGE}:${APP_VERSION}
|
||||
environment:
|
||||
DATABASE_URL: postgres://betrieb:${DB_PASSWORT}@db:5432/betrieb
|
||||
NEXTCLOUD_PROJEKTE_URL: ${NEXTCLOUD_PROJEKTE_URL:-}
|
||||
NEXTCLOUD_BENUTZER: ${NEXTCLOUD_BENUTZER:-}
|
||||
NEXTCLOUD_PASSWORT: ${NEXTCLOUD_PASSWORT:-}
|
||||
depends_on:
|
||||
db: { condition: service_healthy }
|
||||
db:
|
||||
|
||||
4
package-lock.json
generated
4
package-lock.json
generated
@@ -1,12 +1,12 @@
|
||||
{
|
||||
"name": "betrieb",
|
||||
"version": "0.1.0",
|
||||
"version": "0.2.0",
|
||||
"lockfileVersion": 3,
|
||||
"requires": true,
|
||||
"packages": {
|
||||
"": {
|
||||
"name": "betrieb",
|
||||
"version": "0.1.0",
|
||||
"version": "0.2.0",
|
||||
"dependencies": {
|
||||
"@fastify/static": "^10.1.6",
|
||||
"fastify": "^5.0.0",
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
{
|
||||
"name": "betrieb",
|
||||
"version": "0.1.0",
|
||||
"version": "0.2.0",
|
||||
"private": true,
|
||||
"description": "Betriebsführungsprogramm Schaarschmidt Holzbau",
|
||||
"type": "module",
|
||||
|
||||
@@ -13,3 +13,4 @@ await build({
|
||||
});
|
||||
await cp("src/web/index.html", "dist/web/index.html");
|
||||
await cp("src/web/styles.css", "dist/web/styles.css");
|
||||
await cp("src/web/bilder", "dist/web/bilder", { recursive: true });
|
||||
|
||||
69
src/domain/einsatz.ts
Normal file
69
src/domain/einsatz.ts
Normal file
@@ -0,0 +1,69 @@
|
||||
// Besetzung der Vorgänge (T14) und Warnung bei Terminüberschneidung (T9): dieselbe Person,
|
||||
// derselbe Subunternehmer oder dieselbe Kolonne zur gleichen Zeit an zwei Stellen.
|
||||
|
||||
import { type Datum } from "./datum.js";
|
||||
|
||||
export interface EinsatzVorgang {
|
||||
id: string;
|
||||
anfang: Datum;
|
||||
ende: Datum;
|
||||
}
|
||||
|
||||
export interface Besetzung {
|
||||
vorgang_id: string;
|
||||
kontakt_id?: string | null;
|
||||
platzhalter?: string | null;
|
||||
personen: number;
|
||||
freigegeben: boolean;
|
||||
}
|
||||
|
||||
export interface Ueberschneidung {
|
||||
/** Kontakt-ID oder Platzhaltertext */
|
||||
wer: string;
|
||||
vorgang_a: string;
|
||||
vorgang_b: string;
|
||||
/** erster gemeinsamer Tag */
|
||||
ab: Datum;
|
||||
}
|
||||
|
||||
/** Schlüssel einer Besetzung: der Kontakt oder der Platzhalter (ohne Groß/klein). „N.N.“ zählt nicht. */
|
||||
export function wer(b: Pick<Besetzung, "kontakt_id" | "platzhalter">): string | undefined {
|
||||
if (b.kontakt_id) return b.kontakt_id;
|
||||
const p = b.platzhalter?.trim().toLowerCase();
|
||||
return p && !/^n\.?\s*n\.?$/.test(p) ? `platzhalter:${p}` : undefined;
|
||||
}
|
||||
|
||||
export function ueberschneidungen(vorgaenge: EinsatzVorgang[], besetzungen: Besetzung[]): Ueberschneidung[] {
|
||||
const v = new Map(vorgaenge.map((x) => [x.id, x]));
|
||||
const jeWer = new Map<string, EinsatzVorgang[]>();
|
||||
for (const b of besetzungen) {
|
||||
const w = wer(b);
|
||||
const vg = v.get(b.vorgang_id);
|
||||
if (!w || !vg) continue;
|
||||
const liste = jeWer.get(w) ?? [];
|
||||
if (!liste.some((x) => x.id === vg.id)) liste.push(vg);
|
||||
jeWer.set(w, liste);
|
||||
}
|
||||
const aus: Ueberschneidung[] = [];
|
||||
for (const [w, liste] of jeWer) {
|
||||
liste.sort((a, b) => (a.anfang < b.anfang ? -1 : a.anfang > b.anfang ? 1 : 0));
|
||||
for (let i = 0; i < liste.length; i++) {
|
||||
for (let j = i + 1; j < liste.length; j++) {
|
||||
const a = liste[i]!, b = liste[j]!;
|
||||
if (b.anfang > a.ende) break;
|
||||
aus.push({ wer: w, vorgang_a: a.id, vorgang_b: b.id, ab: b.anfang });
|
||||
}
|
||||
}
|
||||
}
|
||||
return aus;
|
||||
}
|
||||
|
||||
/**
|
||||
* Kurzname am Balken: Mitarbeiter mit Initialen („Henning Schaarschmidt“ → „HS“),
|
||||
* Subunternehmer mit dem ersten Wort („Meier Bedachungen GmbH“ → „Meier“).
|
||||
*/
|
||||
export function kuerzel(name: string, rolle?: string): string {
|
||||
const teile = name.trim().split(/\s+/).filter((t) => /^[\p{L}]/u.test(t));
|
||||
if (rolle === "mitarbeiter" && teile.length >= 2) return (teile[0]![0]! + teile[teile.length - 1]![0]!).toUpperCase();
|
||||
return (teile[0] ?? name.trim()).slice(0, 12);
|
||||
}
|
||||
72
src/domain/ical.ts
Normal file
72
src/domain/ical.ts
Normal file
@@ -0,0 +1,72 @@
|
||||
// Internetkalender (iCalendar, RFC 5545) für das Kalender-Abo in Outlook classic (T11, E15).
|
||||
// Ganztägige Termine; Outlook holt Änderungen beim nächsten Abgleich ab, nur in eine Richtung.
|
||||
|
||||
import { type Datum, plusTage } from "./datum.js";
|
||||
|
||||
export interface Termin {
|
||||
uid: string;
|
||||
von: Datum;
|
||||
/** letzter Tag, eingeschlossen */
|
||||
bis: Datum;
|
||||
titel: string;
|
||||
beschreibung?: string;
|
||||
ort?: string;
|
||||
geaendert?: Date;
|
||||
}
|
||||
|
||||
function text(s: string): string {
|
||||
return s.replace(/\\/g, "\\\\").replace(/;/g, "\\;").replace(/,/g, "\\,").replace(/\r?\n/g, "\\n");
|
||||
}
|
||||
|
||||
/** Zeilen über 75 Byte umbrechen; Folgezeilen beginnen mit einem Leerzeichen. UTF-8-Zeichen bleiben ganz. */
|
||||
function falte(zeile: string): string {
|
||||
const teile: string[] = [];
|
||||
let aktuell = "";
|
||||
let bytes = 0;
|
||||
for (const z of zeile) {
|
||||
const n = new TextEncoder().encode(z).length;
|
||||
if (bytes + n > (teile.length ? 74 : 75)) {
|
||||
teile.push(aktuell);
|
||||
aktuell = "";
|
||||
bytes = 0;
|
||||
}
|
||||
aktuell += z;
|
||||
bytes += n;
|
||||
}
|
||||
teile.push(aktuell);
|
||||
return teile.join("\r\n ");
|
||||
}
|
||||
|
||||
const tag = (d: Datum) => d.replaceAll("-", "");
|
||||
const zeit = (d: Date) => d.toISOString().replace(/[-:]/g, "").replace(/\.\d{3}/, "");
|
||||
|
||||
export function kalender(name: string, termine: Termin[], jetzt = new Date()): string {
|
||||
const z = [
|
||||
"BEGIN:VCALENDAR",
|
||||
"VERSION:2.0",
|
||||
"PRODID:-//Schaarschmidt Holzbau//Betrieb//DE",
|
||||
"CALSCALE:GREGORIAN",
|
||||
"METHOD:PUBLISH",
|
||||
`X-WR-CALNAME:${text(name)}`,
|
||||
"X-WR-TIMEZONE:Europe/Berlin",
|
||||
"REFRESH-INTERVAL;VALUE=DURATION:PT1H",
|
||||
"X-PUBLISHED-TTL:PT1H",
|
||||
];
|
||||
for (const t of termine) {
|
||||
z.push(
|
||||
"BEGIN:VEVENT",
|
||||
`UID:${t.uid}`,
|
||||
`DTSTAMP:${zeit(jetzt)}`,
|
||||
...(t.geaendert ? [`LAST-MODIFIED:${zeit(t.geaendert)}`] : []),
|
||||
`DTSTART;VALUE=DATE:${tag(t.von)}`,
|
||||
`DTEND;VALUE=DATE:${tag(plusTage(t.bis, 1))}`,
|
||||
`SUMMARY:${text(t.titel)}`,
|
||||
...(t.beschreibung ? [`DESCRIPTION:${text(t.beschreibung)}`] : []),
|
||||
...(t.ort ? [`LOCATION:${text(t.ort)}`] : []),
|
||||
"TRANSP:TRANSPARENT",
|
||||
"END:VEVENT",
|
||||
);
|
||||
}
|
||||
z.push("END:VCALENDAR");
|
||||
return z.map(falte).join("\r\n") + "\r\n";
|
||||
}
|
||||
149
src/domain/terminplan.ts
Normal file
149
src/domain/terminplan.ts
Normal file
@@ -0,0 +1,149 @@
|
||||
// Terminplanung mit Verknüpfungen (T3, T5): ein Vorgang darf mehrere Vorgänger haben.
|
||||
// Regeln wie in V70 (reqOf/reschedAll): EA, AA, EE, AE mit Verzögerung in Arbeitstagen.
|
||||
// Nachfolger werden nach hinten geschoben, wenn ein Vorgänger sich verlängert oder später
|
||||
// liegt. Nach vorn rücken nur Nachfolger, die vorher direkt am Vorgänger hingen („eng“).
|
||||
|
||||
import { type Datum } from "./datum.js";
|
||||
import { type Arbeitswoche, endeNachDauer, naechsterArbeitstag, verschiebeArbeitstage } from "./kalender.js";
|
||||
|
||||
export type Art = "EA" | "AA" | "EE" | "AE";
|
||||
|
||||
export interface PlanVorgang {
|
||||
id: string;
|
||||
start: Datum;
|
||||
/** Arbeitstage; angefangene Tage zählen voll; 0 = Meilenstein */
|
||||
dauer: number;
|
||||
}
|
||||
|
||||
export interface Verknuepfung {
|
||||
vorgang_id: string;
|
||||
vorgaenger_id: string;
|
||||
art: Art;
|
||||
/** Arbeitstage, darf negativ sein */
|
||||
verzoegerung: number;
|
||||
}
|
||||
|
||||
const tage = (v: PlanVorgang) => Math.ceil(v.dauer);
|
||||
|
||||
export function anfang(v: PlanVorgang, woche: Arbeitswoche): Datum {
|
||||
return naechsterArbeitstag(v.start, woche);
|
||||
}
|
||||
|
||||
export function ende(v: PlanVorgang, woche: Arbeitswoche): Datum {
|
||||
return endeNachDauer(v.start, tage(v), woche);
|
||||
}
|
||||
|
||||
/** V70 offW: n Arbeitstage nach (n > 0) oder vor (n < 0) dem Tag; 0 = der Tag oder der nächste Arbeitstag. */
|
||||
function versatz(d: Datum, n: number, woche: Arbeitswoche): Datum {
|
||||
return n === 0 ? naechsterArbeitstag(d, woche) : verschiebeArbeitstage(d, n, woche);
|
||||
}
|
||||
|
||||
/** Start, der sich ergibt, wenn der Vorgang an `endeAm` endet. */
|
||||
function startFuerEnde(v: PlanVorgang, endeAm: Datum, woche: Arbeitswoche): Datum {
|
||||
const e = naechsterArbeitstag(endeAm, woche);
|
||||
return tage(v) <= 1 ? e : verschiebeArbeitstage(e, -(tage(v) - 1), woche);
|
||||
}
|
||||
|
||||
/** Frühester Start, den eine Verknüpfung dem Nachfolger erlaubt. */
|
||||
export function startNachVerknuepfung(v: PlanVorgang, vorgaenger: PlanVorgang, k: Verknuepfung, woche: Arbeitswoche): Datum {
|
||||
const lg = k.verzoegerung;
|
||||
const meilenstein = tage(v) === 0;
|
||||
switch (k.art) {
|
||||
case "EA": return versatz(ende(vorgaenger, woche), meilenstein ? lg : 1 + lg, woche);
|
||||
case "AA": return versatz(anfang(vorgaenger, woche), lg, woche);
|
||||
case "EE": return startFuerEnde(v, versatz(ende(vorgaenger, woche), lg, woche), woche);
|
||||
case "AE": return startFuerEnde(v, versatz(anfang(vorgaenger, woche), lg, woche), woche);
|
||||
}
|
||||
}
|
||||
|
||||
/** Frühester Start aus allen Vorgängern; undefined ohne Vorgänger. */
|
||||
export function fruehesterStart(v: PlanVorgang, alle: Map<string, PlanVorgang>, links: Verknuepfung[], woche: Arbeitswoche): Datum | undefined {
|
||||
let s: Datum | undefined;
|
||||
for (const k of links) {
|
||||
if (k.vorgang_id !== v.id) continue;
|
||||
const p = alle.get(k.vorgaenger_id);
|
||||
if (!p) continue;
|
||||
const x = startNachVerknuepfung(v, p, k, woche);
|
||||
if (!s || x > s) s = x;
|
||||
}
|
||||
return s;
|
||||
}
|
||||
|
||||
/** Vorgänge, die genau an ihrem frühesten Start liegen; sie rücken mit, wenn der Vorgänger früher fertig wird. */
|
||||
export function engeVorgaenge(vorgaenge: PlanVorgang[], links: Verknuepfung[], woche: Arbeitswoche): Set<string> {
|
||||
const alle = new Map(vorgaenge.map((v) => [v.id, v]));
|
||||
const eng = new Set<string>();
|
||||
for (const v of vorgaenge) {
|
||||
const f = fruehesterStart(v, alle, links, woche);
|
||||
if (f && f === anfang(v, woche)) eng.add(v.id);
|
||||
}
|
||||
return eng;
|
||||
}
|
||||
|
||||
/** true, wenn die neue Verknüpfung einen Kreis bilden würde (Vorgänger hängt schon am Vorgang). */
|
||||
export function bildetKreis(neu: Pick<Verknuepfung, "vorgang_id" | "vorgaenger_id">, links: Verknuepfung[]): boolean {
|
||||
if (neu.vorgang_id === neu.vorgaenger_id) return true;
|
||||
const nachfolger = new Map<string, string[]>();
|
||||
for (const k of links) nachfolger.set(k.vorgaenger_id, [...(nachfolger.get(k.vorgaenger_id) ?? []), k.vorgang_id]);
|
||||
const offen = [neu.vorgang_id];
|
||||
const gesehen = new Set<string>();
|
||||
while (offen.length) {
|
||||
const x = offen.pop()!;
|
||||
if (x === neu.vorgaenger_id) return true;
|
||||
if (gesehen.has(x)) continue;
|
||||
gesehen.add(x);
|
||||
offen.push(...(nachfolger.get(x) ?? []));
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/** Reihenfolge, in der Vorgänger vor ihren Nachfolgern kommen. Wirft bei einem Kreis. */
|
||||
function topologisch(vorgaenge: PlanVorgang[], links: Verknuepfung[]): PlanVorgang[] {
|
||||
const ids = new Set(vorgaenge.map((v) => v.id));
|
||||
const rest = new Map(vorgaenge.map((v) => [v.id, 0]));
|
||||
const nach = new Map<string, string[]>();
|
||||
for (const k of links) {
|
||||
if (!ids.has(k.vorgang_id) || !ids.has(k.vorgaenger_id)) continue;
|
||||
rest.set(k.vorgang_id, rest.get(k.vorgang_id)! + 1);
|
||||
nach.set(k.vorgaenger_id, [...(nach.get(k.vorgaenger_id) ?? []), k.vorgang_id]);
|
||||
}
|
||||
const byId = new Map(vorgaenge.map((v) => [v.id, v]));
|
||||
const bereit = vorgaenge.filter((v) => rest.get(v.id) === 0).map((v) => v.id);
|
||||
const aus: PlanVorgang[] = [];
|
||||
while (bereit.length) {
|
||||
const id = bereit.shift()!;
|
||||
aus.push(byId.get(id)!);
|
||||
for (const n of nach.get(id) ?? []) {
|
||||
rest.set(n, rest.get(n)! - 1);
|
||||
if (rest.get(n) === 0) bereit.push(n);
|
||||
}
|
||||
}
|
||||
if (aus.length !== vorgaenge.length) throw new Error("Die Verknüpfungen bilden einen Kreis.");
|
||||
return aus;
|
||||
}
|
||||
|
||||
export interface Ergebnis {
|
||||
/** neuer Start je verschobenem Vorgang */
|
||||
starts: Map<string, Datum>;
|
||||
}
|
||||
|
||||
/**
|
||||
* Plant alle Nachfolger neu. `eng` sind die Vorgänge, die vor der Änderung direkt am Vorgänger hingen
|
||||
* (engeVorgaenge auf dem alten Stand); nur sie dürfen nach vorn rücken. `fest` werden nicht bewegt
|
||||
* (der Vorgang, den der Benutzer gerade gezogen hat, wird vorher auf seinen frühesten Start begrenzt).
|
||||
*/
|
||||
export function planeNeu(vorgaenge: PlanVorgang[], links: Verknuepfung[], woche: Arbeitswoche, eng: Set<string> = new Set()): Ergebnis {
|
||||
const stand = new Map(vorgaenge.map((v) => [v.id, { ...v }]));
|
||||
const starts = new Map<string, Datum>();
|
||||
for (const v of topologisch(vorgaenge, links)) {
|
||||
const x = stand.get(v.id)!;
|
||||
const f = fruehesterStart(x, stand, links, woche);
|
||||
if (!f) continue;
|
||||
const a = anfang(x, woche);
|
||||
if (f > a || (f < a && eng.has(v.id))) {
|
||||
x.start = f;
|
||||
starts.set(v.id, f);
|
||||
}
|
||||
}
|
||||
return { starts };
|
||||
}
|
||||
85
src/domain/uebersicht.ts
Normal file
85
src/domain/uebersicht.ts
Normal file
@@ -0,0 +1,85 @@
|
||||
// Startseite (Ü3, Ü7, Ü8): Aufgaben wie in V70 gruppiert, Warnungen und wer was wann wo macht.
|
||||
|
||||
import { type Datum, plusTage, wochentag } from "./datum.js";
|
||||
import { type Arbeitswoche, istArbeitstag } from "./kalender.js";
|
||||
import { type Besetzung, wer } from "./einsatz.js";
|
||||
|
||||
export interface Aufgabe {
|
||||
id: string;
|
||||
text: string;
|
||||
faellig_am?: Datum | null;
|
||||
langfristig?: boolean;
|
||||
erledigt_am?: string | null;
|
||||
}
|
||||
|
||||
/** V70: „Diese Woche“ (fällig bis Sonntag), „Noch nicht abgearbeitet“ (überfällig), „Langfristig“ (später oder ohne Datum). */
|
||||
export function aufgabenGruppen<T extends Aufgabe>(aufgaben: T[], heute: Datum) {
|
||||
const sonntag = plusTage(heute, (7 - wochentag(heute)) % 7);
|
||||
const g = { dieseWoche: [] as T[], ueberfaellig: [] as T[], langfristig: [] as T[] };
|
||||
for (const a of aufgaben) {
|
||||
if (a.erledigt_am) continue;
|
||||
const d = a.faellig_am;
|
||||
if (d && d < heute) g.ueberfaellig.push(a);
|
||||
else if (d && d <= sonntag && !a.langfristig) g.dieseWoche.push(a);
|
||||
else g.langfristig.push(a);
|
||||
}
|
||||
const nachDatum = (a: T, b: T) => (a.faellig_am ?? "9999") < (b.faellig_am ?? "9999") ? -1 : (a.faellig_am ?? "9999") > (b.faellig_am ?? "9999") ? 1 : a.text.localeCompare(b.text, "de");
|
||||
g.dieseWoche.sort(nachDatum);
|
||||
g.ueberfaellig.sort(nachDatum);
|
||||
g.langfristig.sort(nachDatum);
|
||||
return g;
|
||||
}
|
||||
|
||||
export interface UeVorgang {
|
||||
id: string;
|
||||
name: string;
|
||||
anfang: Datum;
|
||||
ende: Datum;
|
||||
projekt: string;
|
||||
}
|
||||
|
||||
export interface UeBesetzung extends Besetzung {
|
||||
anzeige: string;
|
||||
kurz: string;
|
||||
}
|
||||
|
||||
/** Arbeitstage ab heute, so viele wie gewünscht (Freitag ist Reserve und fehlt deshalb). */
|
||||
export function naechsteArbeitstage(heute: Datum, anzahl: number, woche: Arbeitswoche): Datum[] {
|
||||
const aus: Datum[] = [];
|
||||
for (let d = heute; aus.length < anzahl; d = plusTage(d, 1)) if (istArbeitstag(d, woche)) aus.push(d);
|
||||
return aus;
|
||||
}
|
||||
|
||||
export interface Einsatzzeile {
|
||||
wer: string;
|
||||
anzeige: string;
|
||||
/** je Tag die Vorgänge dieser Person */
|
||||
tage: { vorgang: string; name: string; projekt: string; vorgemerkt: boolean }[][];
|
||||
}
|
||||
|
||||
/** Ü8: je Person (und Platzhalter) die Vorgänge an den nächsten Arbeitstagen; dazu Vorgänge ohne Besetzung. */
|
||||
export function einsatzMatrix(vorgaenge: UeVorgang[], besetzungen: UeBesetzung[], tage: Datum[]): { zeilen: Einsatzzeile[]; ohne: Einsatzzeile } {
|
||||
const zeilen = new Map<string, Einsatzzeile>();
|
||||
const ohne: Einsatzzeile = { wer: "", anzeige: "Noch nicht besetzt", tage: tage.map(() => []) };
|
||||
for (const v of vorgaenge) {
|
||||
const idx = tage.map((d, i) => (d >= v.anfang && d <= v.ende ? i : -1)).filter((i) => i >= 0);
|
||||
if (!idx.length) continue;
|
||||
const bs = besetzungen.filter((b) => b.vorgang_id === v.id);
|
||||
const eintrag = (vorgemerkt: boolean) => ({ vorgang: v.id, name: v.name, projekt: v.projekt, vorgemerkt });
|
||||
if (!bs.length) idx.forEach((i) => ohne.tage[i]!.push(eintrag(false)));
|
||||
for (const b of bs) {
|
||||
const w = wer(b) ?? `nn:${b.anzeige}`;
|
||||
const z = zeilen.get(w) ?? { wer: w, anzeige: b.anzeige, tage: tage.map(() => []) };
|
||||
idx.forEach((i) => z.tage[i]!.push(eintrag(!b.freigegeben)));
|
||||
zeilen.set(w, z);
|
||||
}
|
||||
}
|
||||
return { zeilen: [...zeilen.values()].sort((a, b) => a.anzeige.localeCompare(b.anzeige, "de")), ohne };
|
||||
}
|
||||
|
||||
export interface Warnung {
|
||||
art: "ueberschneidung" | "unbesetzt" | "freigabe" | "aufgabe" | "kontostand";
|
||||
text: string;
|
||||
/** Sprungziel in der App, z. B. "terminplan" */
|
||||
ziel: string;
|
||||
}
|
||||
@@ -76,7 +76,12 @@ export interface V70Sicherung {
|
||||
firmenkosten_monatlich: V70Firmenkosten[];
|
||||
firmenkosten_einmalig: V70Firmenkosten[];
|
||||
arbeitszeit?: { h?: number; eff?: number; rund?: string };
|
||||
aufgaben?: unknown[];
|
||||
aufgaben?: V70Aufgabe[];
|
||||
}
|
||||
|
||||
/** Aufgabe im Aufgabenblock: t Text, d fällig, k Kontakt (freier Text), p Projekt als Listenposition */
|
||||
export interface V70Aufgabe {
|
||||
id?: string; t?: string; d?: string; k?: string; p?: number | string | null; done?: boolean; doneAt?: number;
|
||||
}
|
||||
|
||||
// --- Ergebnis ---
|
||||
@@ -108,6 +113,7 @@ export interface Uebernahme {
|
||||
}[];
|
||||
kosten: { projekt: string; art: Kostenart; bezeichnung: string; netto: Cent; termin: Datum; mit_vorsteuer: boolean; zahlungsziel_tage: number }[];
|
||||
laufend: { bezeichnung: string; gruppe?: string; kategorie: string; betrag: Cent; rhythmus: Rhythmus; start: Datum }[];
|
||||
aufgaben: { text: string; faellig_am?: Datum; projekt?: string; erledigt_am?: string }[];
|
||||
hinweise: string[];
|
||||
}
|
||||
|
||||
@@ -199,7 +205,7 @@ export function uebernimmV70(roh: unknown, woche: Arbeitswoche = MO_BIS_DO): Ueb
|
||||
rundung,
|
||||
zahlungsziele: { kundenTage: zz, materialTage: mz, fremdTage: mz, sonstigeTage: mz },
|
||||
},
|
||||
kontakte: [], projekte: [], abschnitte: [], vorgaenge: [], verknuepfungen: [], zahlungen: [], kosten: [], laufend: [],
|
||||
kontakte: [], projekte: [], abschnitte: [], vorgaenge: [], verknuepfungen: [], zahlungen: [], kosten: [], laufend: [], aufgaben: [],
|
||||
hinweise,
|
||||
};
|
||||
|
||||
@@ -376,7 +382,17 @@ export function uebernimmV70(roh: unknown, woche: Arbeitswoche = MO_BIS_DO): Ueb
|
||||
}
|
||||
u.laufend.push({ bezeichnung: f.t.trim(), gruppe: f.g?.trim() || undefined, kategorie: f.c?.trim() || "Sonstiges", betrag: euroZuCent(f.b), rhythmus: "einmalig", start: f.d });
|
||||
}
|
||||
if (s.aufgaben?.length) hinweise.push(`${s.aufgaben.length} Aufgaben aus V70 werden mit Stufe 1 übernommen.`);
|
||||
for (const a of s.aufgaben ?? []) {
|
||||
const text = [a.t?.trim(), a.k?.trim() ? `(${a.k.trim()})` : ""].filter(Boolean).join(" ");
|
||||
if (!text) continue;
|
||||
const pi = a.p === "" || a.p === null || a.p === undefined ? -1 : Number(a.p);
|
||||
u.aufgaben.push({
|
||||
text,
|
||||
faellig_am: a.d && DATUM.test(a.d) ? a.d : undefined,
|
||||
projekt: pi >= 0 && pi < s.projekte.length ? `p${pi}` : undefined,
|
||||
erledigt_am: a.done ? new Date(a.doneAt || Date.now()).toISOString() : undefined,
|
||||
});
|
||||
}
|
||||
|
||||
return u;
|
||||
}
|
||||
|
||||
@@ -3,8 +3,13 @@ import fastifyStatic from "@fastify/static";
|
||||
import { fileURLToPath } from "node:url";
|
||||
import path from "node:path";
|
||||
import { existsSync } from "node:fs";
|
||||
import { randomBytes, timingSafeEqual } from "node:crypto";
|
||||
import { z, ZodError } from "zod";
|
||||
import { type Pool, transaktion } from "./db.js";
|
||||
import { type Client, type Pool, transaktion } from "./db.js";
|
||||
import { mitNeuplanung, pruefeVerknuepfung, terminplan } from "./terminplan.js";
|
||||
import { uebersicht } from "./uebersicht.js";
|
||||
import { aufgabenKalender, baustellenKalender } from "./kalender.js";
|
||||
import { type Nextcloud, ordnerAbgleichen } from "./nextcloud.js";
|
||||
import { TABELLEN } from "./tabellen.js";
|
||||
import { EinstellungenSchema, type Einstellungen } from "./einstellungen.js";
|
||||
import { liquiditaet } from "../domain/liquiditaet.js";
|
||||
@@ -15,6 +20,8 @@ import { VERSION } from "./version.js";
|
||||
|
||||
export interface Optionen {
|
||||
pool: Pool;
|
||||
/** P10: Projektordner in der Nextcloud; ohne Zugang wird nichts angelegt */
|
||||
nextcloud?: Nextcloud;
|
||||
webOrdner?: string;
|
||||
logger?: boolean;
|
||||
}
|
||||
@@ -52,6 +59,36 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
return { ok: true, version: VERSION };
|
||||
});
|
||||
|
||||
// P10: Ordner nach dem Speichern abgleichen. Ein Fehler in der Nextcloud macht die Änderung nicht
|
||||
// rückgängig; der Hinweis kommt mit zurück, und der Abgleich lässt sich wiederholen.
|
||||
async function mitOrdner(p: Record<string, any>, wer: string): Promise<Record<string, unknown>> {
|
||||
if (!o.nextcloud) return p;
|
||||
try {
|
||||
const pfad = await ordnerAbgleichen(o.nextcloud, p as { nummer: string; bezeichnung: string; status: string }, p.nextcloud_link ?? null);
|
||||
if (pfad === p.nextcloud_link) return p;
|
||||
return await transaktion(pool, wer, async (c) => (await c.query("update projekt set nextcloud_link = $2 where id = $1 returning *", [p.id, pfad])).rows[0]);
|
||||
} catch (err) {
|
||||
app.log.warn(err);
|
||||
return { ...p, ordner_fehler: `Projektordner in der Nextcloud: ${(err as Error).message}` };
|
||||
}
|
||||
}
|
||||
|
||||
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];
|
||||
if (!p) return reply.status(404).send({ fehler: "Nicht gefunden" });
|
||||
if (!o.nextcloud) return reply.status(409).send({ fehler: "Für die Projektordner ist kein Nextcloud-Zugang eingerichtet." });
|
||||
return mitOrdner(p, benutzer(req));
|
||||
});
|
||||
|
||||
// Änderungen an Vorgängen und Verknüpfungen planen die Nachfolger in derselben Transaktion neu
|
||||
const PLAN = new Set(["vorgang", "vorgang_vorgaenger"]);
|
||||
async function geplant<T>(c: Client, tabelle: string, fn: () => Promise<T>, bewegt: string[] = []): Promise<T> {
|
||||
if (!PLAN.has(tabelle)) return fn();
|
||||
const e = await ladeEinstellungen();
|
||||
return (await mitNeuplanung(c, { tage: e.arbeitstage }, fn, bewegt)).ergebnis;
|
||||
}
|
||||
|
||||
for (const t of TABELLEN) {
|
||||
const felder = Object.keys(t.schema.shape);
|
||||
const teil = t.schema.partial();
|
||||
@@ -67,14 +104,17 @@ 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>;
|
||||
const spalten = felder.filter((f) => daten[f] !== undefined);
|
||||
const row = await transaktion(pool, benutzer(req), async (c) =>
|
||||
(await c.query(
|
||||
spalten.length
|
||||
? `insert into ${t.name} (${spalten.join(", ")}) values (${spalten.map((_, i) => `$${i + 1}`).join(", ")}) returning *`
|
||||
: `insert into ${t.name} default values returning *`,
|
||||
spalten.map((s) => daten[s]),
|
||||
)).rows[0],
|
||||
);
|
||||
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 });
|
||||
return geplant(c, t.name, async () =>
|
||||
(await c.query(
|
||||
spalten.length
|
||||
? `insert into ${t.name} (${spalten.join(", ")}) values (${spalten.map((_, i) => `$${i + 1}`).join(", ")}) returning *`
|
||||
: `insert into ${t.name} default values returning *`,
|
||||
spalten.map((s) => daten[s]),
|
||||
)).rows[0]);
|
||||
});
|
||||
if (t.name === "projekt") return reply.status(201).send(await mitOrdner(row, benutzer(req)));
|
||||
return reply.status(201).send(row);
|
||||
});
|
||||
|
||||
@@ -83,18 +123,25 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
const daten = teil.parse(req.body) as Record<string, unknown>;
|
||||
const spalten = felder.filter((f) => daten[f] !== undefined);
|
||||
if (spalten.length === 0) return reply.status(400).send({ fehler: "Keine Änderung angegeben" });
|
||||
const row = await transaktion(pool, benutzer(req), async (c) =>
|
||||
(await c.query(
|
||||
`update ${t.name} set ${spalten.map((s, i) => `${s} = $${i + 2}`).join(", ")} where id = $1 returning *`,
|
||||
[id, ...spalten.map((s) => daten[s])],
|
||||
)).rows[0],
|
||||
);
|
||||
const row = await transaktion(pool, benutzer(req), async (c) => {
|
||||
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);
|
||||
}
|
||||
return geplant(c, t.name, async () =>
|
||||
(await c.query(
|
||||
`update ${t.name} set ${spalten.map((s, i) => `${s} = $${i + 2}`).join(", ")} where id = $1 returning *`,
|
||||
[id, ...spalten.map((s) => daten[s])],
|
||||
)).rows[0], t.name === "vorgang" && daten.start !== undefined ? [id] : []);
|
||||
});
|
||||
if (row && t.name === "projekt" && (daten.nummer || daten.bezeichnung || daten.status)) return mitOrdner(row, benutzer(req));
|
||||
return row ?? reply.status(404).send({ fehler: "Nicht gefunden" });
|
||||
});
|
||||
|
||||
app.delete(`/api/${t.pfad}/:id`, async (req, reply) => {
|
||||
const { id } = IdParam.parse(req.params);
|
||||
const n = await transaktion(pool, benutzer(req), async (c) => (await c.query(`delete from ${t.name} where id = $1`, [id])).rowCount);
|
||||
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));
|
||||
return n ? reply.status(204).send() : reply.status(404).send({ fehler: "Nicht gefunden" });
|
||||
});
|
||||
}
|
||||
@@ -118,8 +165,7 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
anzahl: z.coerce.number().int().min(1).max(104).default(12),
|
||||
});
|
||||
|
||||
app.get("/api/liquiditaet", async (req) => {
|
||||
const q = LiquiAnfrage.parse(req.query);
|
||||
async function berechneLiquiditaet(q: z.infer<typeof LiquiAnfrage>) {
|
||||
const e = await ladeEinstellungen();
|
||||
const [projekte, vorgaenge, zahlungen, kosten, laufend] = await Promise.all([
|
||||
pool.query("select * from projekt"),
|
||||
@@ -142,6 +188,50 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
);
|
||||
const start = q.start ?? new Date().toISOString().slice(0, 10);
|
||||
return liquiditaet(daten, { ansicht: q.ansicht, start, anzahl: q.anzahl, startsaldo: e.startsaldo, ziele: e.zahlungsziele, ust: e.ust });
|
||||
}
|
||||
|
||||
app.get("/api/liquiditaet", async (req) => berechneLiquiditaet(LiquiAnfrage.parse(req.query)));
|
||||
|
||||
// Startseite: Aufgaben, Warnungen, wer macht was in den nächsten zwei Wochen, Liquidität 4 Wochen
|
||||
app.get("/api/uebersicht", async (req) => {
|
||||
const heute = z.object({ heute: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional() }).parse(req.query).heute ?? new Date().toISOString().slice(0, 10);
|
||||
const e = await ladeEinstellungen();
|
||||
const woche = { tage: e.arbeitstage };
|
||||
const [tp, aufgaben, liqui] = await Promise.all([
|
||||
terminplan(pool, woche),
|
||||
pool.query(`select a.*, p.nummer as projekt_nummer from aufgabe a left join projekt p on p.id = a.projekt_id
|
||||
where a.erledigt_am is null order by a.faellig_am nulls last, a.angelegt_am`),
|
||||
berechneLiquiditaet({ ansicht: "woche", start: heute, anzahl: 4 }),
|
||||
]);
|
||||
return uebersicht({ heute, woche, tp, aufgaben: aufgaben.rows, liqui, mindestreserve: e.mindestreserve,
|
||||
kontostandErfasst: e.startsaldo !== 0 || e.startsaldoDatum !== null });
|
||||
});
|
||||
|
||||
// T11: Kalender-Abos. Ohne Anmeldung erreichbar (Outlook classic kann das nicht), geschützt durch das Geheimnis im Link
|
||||
const KalenderParam = z.object({ token: z.string().min(20).max(100), name: z.enum(["baustellen.ics", "aufgaben.ics"]) });
|
||||
app.get("/kalender/:token/:name", async (req, reply) => {
|
||||
const q = KalenderParam.safeParse(req.params);
|
||||
const e = await ladeEinstellungen();
|
||||
const soll = Buffer.from(e.kalenderToken ?? "");
|
||||
const ist = Buffer.from(q.success ? q.data.token : "");
|
||||
if (!q.success || !e.kalenderToken || soll.length !== ist.length || !timingSafeEqual(soll, ist)) {
|
||||
return reply.status(404).send({ fehler: "Nicht gefunden" });
|
||||
}
|
||||
const ics = q.data.name === "baustellen.ics" ? await baustellenKalender(pool, { tage: e.arbeitstage }) : await aufgabenKalender(pool);
|
||||
return reply.header("content-type", "text/calendar; charset=utf-8").header("cache-control", "no-store").send(ics);
|
||||
});
|
||||
|
||||
// Neues Geheimnis für die Kalender-Links; alte Abos hören dann auf zu funktionieren
|
||||
app.post("/api/kalender/neu", async (req) => {
|
||||
const e = await ladeEinstellungen();
|
||||
const neu = { ...e, kalenderToken: randomBytes(24).toString("base64url") };
|
||||
await transaktion(pool, benutzer(req), (c) => c.query("update einstellungen set daten = $1", [neu]));
|
||||
return { kalenderToken: neu.kalenderToken };
|
||||
});
|
||||
|
||||
app.get("/api/terminplan", async () => {
|
||||
const e = await ladeEinstellungen();
|
||||
return terminplan(pool, { tage: e.arbeitstage });
|
||||
});
|
||||
|
||||
// Übernahme aus dem Projektplaner V70 (JSON-Sicherung), nur in ein leeres Programm
|
||||
@@ -152,7 +242,9 @@ export async function baueApp(o: Optionen): Promise<FastifyInstance> {
|
||||
} catch (err) {
|
||||
return reply.status(400).send({ fehler: (err as Error).message });
|
||||
}
|
||||
const anzahl = await transaktion(pool, benutzer(req), (c) => speichereUebernahme(c, u));
|
||||
const e = await ladeEinstellungen();
|
||||
// nach der Übernahme gelten die Verknüpfungen: Nachfolger rücken hinter ihre Vorgänger wie in V70
|
||||
const anzahl = await transaktion(pool, benutzer(req), async (c) => (await mitNeuplanung(c, { tage: e.arbeitstage }, () => speichereUebernahme(c, u))).ergebnis);
|
||||
return reply.status(201).send({ anzahl, hinweise: u.hinweise });
|
||||
});
|
||||
|
||||
|
||||
@@ -27,6 +27,8 @@ export const EinstellungenSchema = z.object({
|
||||
startsaldo: z.number().int().default(0),
|
||||
startsaldoDatum: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).nullable().default(null),
|
||||
mindestreserve: z.number().int().default(0),
|
||||
// geheimer Teil der Kalender-Links (T11); Outlook classic kann sich nicht anmelden
|
||||
kalenderToken: z.string().min(20).nullable().default(null),
|
||||
});
|
||||
|
||||
export type Einstellungen = z.infer<typeof EinstellungenSchema>;
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
import { erstellePool } from "./db.js";
|
||||
import { migriere } from "./migrate.js";
|
||||
import { baueApp } from "./app.js";
|
||||
import { Nextcloud } from "./nextcloud.js";
|
||||
|
||||
const url = process.env.DATABASE_URL;
|
||||
if (!url) {
|
||||
@@ -10,7 +11,10 @@ if (!url) {
|
||||
|
||||
const pool = erstellePool(url);
|
||||
await migriere(pool, (t) => console.log(t));
|
||||
const app = await baueApp({ pool, logger: true });
|
||||
// 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;
|
||||
const app = await baueApp({ pool, logger: true, nextcloud });
|
||||
const port = Number(process.env.PORT ?? 3000);
|
||||
await app.listen({ host: "0.0.0.0", port });
|
||||
|
||||
|
||||
61
src/server/kalender.ts
Normal file
61
src/server/kalender.ts
Normal file
@@ -0,0 +1,61 @@
|
||||
// Kalender-Abos für Outlook classic (T11): Baustellen (Vorgänge) und fällige Aufgaben.
|
||||
// Die Links enthalten ein Geheimnis statt einer Anmeldung, weil Outlook classic sich bei
|
||||
// Internetkalendern nicht anmelden kann.
|
||||
import { type Datum, plusTage } from "../domain/datum.js";
|
||||
import { type Arbeitswoche, istArbeitstag } from "../domain/kalender.js";
|
||||
import { type Termin, kalender } from "../domain/ical.js";
|
||||
import type { Pool } from "./db.js";
|
||||
import { terminplan } from "./terminplan.js";
|
||||
|
||||
const IM_KALENDER = new Set(["auftrag", "ausfuehrung"]);
|
||||
|
||||
/** Vorgang in Abschnitte aus zusammenhängenden Arbeitstagen teilen, damit Freitag und Wochenende frei bleiben. */
|
||||
export function arbeitsbloecke(von: Datum, bis: Datum, woche: Arbeitswoche): [Datum, Datum][] {
|
||||
const bloecke: [Datum, Datum][] = [];
|
||||
let start: Datum | undefined;
|
||||
let letzter: Datum | undefined;
|
||||
for (let d = von; d <= bis; d = plusTage(d, 1)) {
|
||||
if (istArbeitstag(d, woche)) {
|
||||
start ??= d;
|
||||
letzter = d;
|
||||
} else if (start) {
|
||||
bloecke.push([start, letzter!]);
|
||||
start = undefined;
|
||||
}
|
||||
}
|
||||
if (start) bloecke.push([start, letzter!]);
|
||||
return bloecke.length ? bloecke : [[von, bis]];
|
||||
}
|
||||
|
||||
export async function baustellenKalender(pool: Pool, woche: Arbeitswoche): Promise<string> {
|
||||
const tp = await terminplan(pool, woche);
|
||||
const projektVon = new Map(tp.abschnitte.map((a) => [a.id, tp.projekte.find((p) => p.id === a.projekt_id)]));
|
||||
const termine: Termin[] = [];
|
||||
for (const v of tp.vorgaenge) {
|
||||
const p = projektVon.get(v.abschnitt_id);
|
||||
if (!p || !IM_KALENDER.has(p.status)) continue;
|
||||
const bs = tp.besetzungen.filter((b) => b.vorgang_id === v.id);
|
||||
const personen = (b: (typeof bs)[number]) => (Number(b.personen) !== 1 ? ` ×${String(b.personen).replace(".", ",")}` : "");
|
||||
const kurz = bs.map((b) => `${b.kurz}${personen(b)}${b.freigegeben ? "" : "?"}`).join(", ");
|
||||
const meilenstein = Number(v.dauer) === 0;
|
||||
const titel = `${meilenstein ? "◆ " : ""}${p.nummer} ${v.name}${kurz ? ` · ${kurz}` : ""}`;
|
||||
const beschreibung = [
|
||||
`Projekt: ${p.nummer} ${p.bezeichnung}`,
|
||||
p.bauherr ? `Bauherr: ${p.bauherr}` : "",
|
||||
bs.length ? `Besetzung: ${bs.map((b) => `${b.anzeige}${personen(b)}${b.freigegeben ? "" : " (vorgemerkt)"}`).join("; ")}` : meilenstein ? "" : "Besetzung: noch offen",
|
||||
meilenstein ? "Meilenstein" : `Dauer: ${Math.ceil(v.dauer)} ${Math.ceil(v.dauer) === 1 ? "Arbeitstag" : "Arbeitstage"}`,
|
||||
].filter(Boolean).join("\n");
|
||||
arbeitsbloecke(v.anfang, v.ende, woche).forEach(([von, bis], i) =>
|
||||
termine.push({ uid: `${v.id}-${i}@betrieb.schaarschmidt-holzbau.de`, von, bis, titel, beschreibung }));
|
||||
}
|
||||
return kalender("Baustellen", termine);
|
||||
}
|
||||
|
||||
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,
|
||||
})));
|
||||
}
|
||||
8
src/server/migrations/003_vorgangsnummer.sql
Normal file
8
src/server/migrations/003_vorgangsnummer.sql
Normal file
@@ -0,0 +1,8 @@
|
||||
-- Nummer je Vorgang wie in V70 (dort "no"), damit Vorgänger per Nummer eingetragen werden können
|
||||
create sequence vorgang_nummer_seq start 1001;
|
||||
alter table vorgang add column nummer integer;
|
||||
update vorgang set nummer = nextval('vorgang_nummer_seq');
|
||||
alter table vorgang alter column nummer set default nextval('vorgang_nummer_seq');
|
||||
alter table vorgang alter column nummer set not null;
|
||||
alter table vorgang add constraint vorgang_nummer_eindeutig unique (nummer);
|
||||
alter sequence vorgang_nummer_seq owned by vorgang.nummer;
|
||||
30
src/server/migrations/004_besetzung.sql
Normal file
30
src/server/migrations/004_besetzung.sql
Normal file
@@ -0,0 +1,30 @@
|
||||
-- T14: Besetzung je Vorgang. Mitarbeiter oder Subunternehmer aus den Kontakten oder ein
|
||||
-- Platzhalter wie „N.N.“ oder „Kolonne 2“, jeweils mit Personenzahl. Subunternehmer und
|
||||
-- Platzhalter sind nur vorgemerkt, bis Henning sie freigibt (E23); Mitarbeiter gelten sofort.
|
||||
create table besetzung (
|
||||
id uuid primary key default gen_random_uuid(),
|
||||
vorgang_id uuid not null references vorgang (id) on delete cascade,
|
||||
kontakt_id uuid references kontakt (id) on delete cascade,
|
||||
platzhalter text,
|
||||
personen numeric(4, 1) not null default 1 check (personen > 0),
|
||||
freigegeben boolean,
|
||||
angelegt_am timestamptz not null default now(),
|
||||
geaendert_am timestamptz not null default now(),
|
||||
geaendert_von text not null default 'system',
|
||||
check ((kontakt_id is null) <> (nullif(trim(platzhalter), '') is null))
|
||||
);
|
||||
create index besetzung_vorgang on besetzung (vorgang_id);
|
||||
create index besetzung_kontakt on besetzung (kontakt_id);
|
||||
|
||||
create function besetzung_freigabe() returns trigger language plpgsql as $$
|
||||
begin
|
||||
if new.freigegeben is null then
|
||||
new.freigegeben := exists (select 1 from kontakt k where k.id = new.kontakt_id and k.rolle = 'mitarbeiter');
|
||||
end if;
|
||||
return new;
|
||||
end $$;
|
||||
|
||||
create trigger besetzung_freigabe before insert or update on besetzung
|
||||
for each row execute function besetzung_freigabe();
|
||||
create trigger besetzung_protokoll before insert or update or delete on besetzung
|
||||
for each row execute function stempel_und_protokoll();
|
||||
103
src/server/nextcloud.ts
Normal file
103
src/server/nextcloud.ts
Normal file
@@ -0,0 +1,103 @@
|
||||
// P10: Projektordner in Hennings Nextcloud anlegen und je nach Status verschieben (WebDAV, App-Passwort).
|
||||
// Statusordner und Unterordner wie in seiner Ablage (Henning, 18./19.10.2026).
|
||||
|
||||
export interface NextcloudZugang {
|
||||
/** WebDAV-Adresse des Ordners, in dem „01 Angebot“ … „04 Archiv“ liegen */
|
||||
url: string;
|
||||
benutzer: string;
|
||||
passwort: string;
|
||||
}
|
||||
|
||||
export const STATUSORDNER: Record<string, string> = {
|
||||
anfrage: "01 Angebot",
|
||||
angebot: "01 Angebot",
|
||||
auftrag: "02 laufende Projekte",
|
||||
ausfuehrung: "02 laufende Projekte",
|
||||
abgerechnet: "02 laufende Projekte",
|
||||
gewaehrleistung: "03 Gewährl.-Projekte",
|
||||
abgeschlossen: "04 Archiv",
|
||||
};
|
||||
|
||||
export const UNTERORDNER = ["01 Auftrag", "01 Auftrag/03 Stundenlohnarb.", "02 Umsetzung", "03 Bilder"];
|
||||
|
||||
/** „P-26-020 Terrassendachsanierung“; Schrägstriche und Steuerzeichen sind in Ordnernamen nicht erlaubt. */
|
||||
export function ordnerName(nummer: string, bezeichnung: string): string {
|
||||
return `${nummer} ${bezeichnung}`.replace(/[\\/:*?"<>|\u0000-\u001f]/g, "-").replace(/\s+/g, " ").trim();
|
||||
}
|
||||
|
||||
export function zielPfad(p: { nummer: string; bezeichnung: string; status: string }): string {
|
||||
return `${STATUSORDNER[p.status] ?? STATUSORDNER.anfrage}/${ordnerName(p.nummer, p.bezeichnung)}`;
|
||||
}
|
||||
|
||||
const kodiert = (pfad: string) => pfad.split("/").map(encodeURIComponent).join("/");
|
||||
|
||||
export class Nextcloud {
|
||||
constructor(private z: NextcloudZugang, private abruf: typeof fetch = fetch) {}
|
||||
|
||||
private adresse(pfad: string): string {
|
||||
return `${this.z.url.replace(/\/+$/, "")}/${kodiert(pfad)}`;
|
||||
}
|
||||
|
||||
private async anfrage(methode: string, pfad: string, kopf: Record<string, string> = {}, body?: string): Promise<Response> {
|
||||
return this.abruf(this.adresse(pfad), {
|
||||
method: methode,
|
||||
headers: { authorization: `Basic ${btoa(`${this.z.benutzer}:${this.z.passwort}`)}`, ...kopf },
|
||||
body,
|
||||
});
|
||||
}
|
||||
|
||||
async gibtEs(pfad: string): Promise<boolean> {
|
||||
const r = await this.anfrage("PROPFIND", pfad, { depth: "0" });
|
||||
if (r.status === 404) return false;
|
||||
if (r.ok || r.status === 207) return true;
|
||||
throw new Error(`Nextcloud antwortet mit ${r.status} für ${pfad}`);
|
||||
}
|
||||
|
||||
/** Namen der Unterordner (eine Ebene) */
|
||||
async liste(pfad: string): Promise<string[]> {
|
||||
const r = await this.anfrage("PROPFIND", pfad, { depth: "1" });
|
||||
if (r.status === 404) return [];
|
||||
if (r.status !== 207) throw new Error(`Nextcloud antwortet mit ${r.status} für ${pfad}`);
|
||||
const xml = await r.text();
|
||||
const basis = new URL(this.adresse(pfad)).pathname.replace(/\/+$/, "");
|
||||
return [...xml.matchAll(/<d:href>([^<]+)<\/d:href>/gi)]
|
||||
.map((m) => decodeURIComponent(m[1]!).replace(/\/+$/, ""))
|
||||
.filter((h) => h !== decodeURIComponent(basis) && h.startsWith(decodeURIComponent(basis)))
|
||||
.map((h) => h.slice(decodeURIComponent(basis).length + 1));
|
||||
}
|
||||
|
||||
async ordner(pfad: string): Promise<void> {
|
||||
const r = await this.anfrage("MKCOL", pfad);
|
||||
if (!(r.status === 201 || r.status === 405)) throw new Error(`Ordner ${pfad} ließ sich nicht anlegen (${r.status})`);
|
||||
}
|
||||
|
||||
async verschiebe(von: string, nach: string): Promise<void> {
|
||||
const r = await this.anfrage("MOVE", von, { destination: this.adresse(nach), overwrite: "F" });
|
||||
if (!(r.status === 201 || r.status === 204)) throw new Error(`${von} ließ sich nicht nach ${nach} verschieben (${r.status})`);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Bringt den Ordner eines Projekts an die richtige Stelle. `bisher` ist der zuletzt bekannte Pfad
|
||||
* (projekt.nextcloud_link). Ohne bekannten Pfad wird ein vorhandener Ordner mit derselben Nummer in
|
||||
* den Statusordnern gesucht und übernommen, sonst ein neuer mit Unterordnern angelegt.
|
||||
* Gibt den neuen Pfad zurück.
|
||||
*/
|
||||
export async function ordnerAbgleichen(nc: Nextcloud, p: { nummer: string; bezeichnung: string; status: string }, bisher: string | null): Promise<string> {
|
||||
const ziel = zielPfad(p);
|
||||
if (bisher === ziel && (await nc.gibtEs(ziel))) return ziel;
|
||||
let quelle = bisher && (await nc.gibtEs(bisher)) ? bisher : null;
|
||||
if (!quelle) {
|
||||
for (const s of new Set(Object.values(STATUSORDNER))) {
|
||||
const treffer = (await nc.liste(s)).find((n) => n === p.nummer || n.startsWith(`${p.nummer} `));
|
||||
if (treffer) { quelle = `${s}/${treffer}`; break; }
|
||||
}
|
||||
}
|
||||
await nc.ordner(ziel.split("/")[0]!);
|
||||
if (quelle && quelle !== ziel) await nc.verschiebe(quelle, ziel);
|
||||
if (!quelle) {
|
||||
await nc.ordner(ziel);
|
||||
for (const u of UNTERORDNER) await nc.ordner(`${ziel}/${u}`);
|
||||
}
|
||||
return ziel;
|
||||
}
|
||||
@@ -71,6 +71,7 @@ export const TABELLEN: Tabelle[] = [
|
||||
sortierung: "abschnitt_id, reihenfolge, start",
|
||||
schema: z.object({
|
||||
abschnitt_id: id,
|
||||
nummer: z.number().int().positive().optional(),
|
||||
name: text,
|
||||
start: datum,
|
||||
dauer: z.number().min(0).optional(),
|
||||
@@ -92,6 +93,18 @@ export const TABELLEN: Tabelle[] = [
|
||||
verzoegerung: z.number().int().optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "besetzung",
|
||||
pfad: "besetzungen",
|
||||
sortierung: "vorgang_id, angelegt_am",
|
||||
schema: z.object({
|
||||
vorgang_id: id,
|
||||
kontakt_id: id.nullable().optional(),
|
||||
platzhalter: optText,
|
||||
personen: z.number().positive().optional(),
|
||||
freigegeben: z.boolean().optional(),
|
||||
}),
|
||||
},
|
||||
{
|
||||
name: "zahlung",
|
||||
pfad: "zahlungen",
|
||||
|
||||
81
src/server/terminplan.ts
Normal file
81
src/server/terminplan.ts
Normal file
@@ -0,0 +1,81 @@
|
||||
// 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 type { Client, Pool } from "./db.js";
|
||||
import type { Arbeitswoche } from "../domain/kalender.js";
|
||||
import { kuerzel, ueberschneidungen } from "../domain/einsatz.js";
|
||||
import { type PlanVorgang, type Verknuepfung, anfang, bildetKreis, ende, engeVorgaenge, planeNeu } from "../domain/terminplan.js";
|
||||
|
||||
export class PlanFehler extends Error {
|
||||
statusCode = 409;
|
||||
}
|
||||
|
||||
async function ladeStand(c: Client | Pool): Promise<{ vorgaenge: PlanVorgang[]; links: Verknuepfung[] }> {
|
||||
const [v, k] = await Promise.all([
|
||||
c.query<PlanVorgang>("select id, start, dauer from vorgang"),
|
||||
c.query<Verknuepfung>("select vorgang_id, vorgaenger_id, art, verzoegerung from vorgang_vorgaenger"),
|
||||
]);
|
||||
return { vorgaenge: v.rows, links: k.rows };
|
||||
}
|
||||
|
||||
/**
|
||||
* Führt eine Änderung aus und plant danach die Nachfolger neu. Vorgänge, die vorher direkt an ihrem
|
||||
* Vorgänger hingen, rücken auch nach vorn, außer sie wurden gerade selbst verschoben (`bewegt`).
|
||||
* Gibt die IDs der verschobenen Vorgänge zurück.
|
||||
*/
|
||||
export async function mitNeuplanung<T>(
|
||||
c: Client, woche: Arbeitswoche, aenderung: () => Promise<T>, bewegt: string[] = [],
|
||||
): Promise<{ ergebnis: T; verschoben: string[] }> {
|
||||
const vorher = await ladeStand(c);
|
||||
const eng = engeVorgaenge(vorher.vorgaenge, vorher.links, woche);
|
||||
// wer von Hand verschoben wurde, bleibt dort (höchstens bis zum frühesten Start zurückgesetzt)
|
||||
for (const id of bewegt) eng.delete(id);
|
||||
const ergebnis = await aenderung();
|
||||
const nachher = await ladeStand(c);
|
||||
let starts;
|
||||
try {
|
||||
({ starts } = planeNeu(nachher.vorgaenge, nachher.links, woche, eng));
|
||||
} catch (e) {
|
||||
throw new PlanFehler((e as Error).message);
|
||||
}
|
||||
for (const [id, start] of starts) await c.query("update vorgang set start = $2 where id = $1", [id, start]);
|
||||
return { ergebnis, verschoben: [...starts.keys()] };
|
||||
}
|
||||
|
||||
/** Prüft eine neue Verknüpfung vor dem Speichern. */
|
||||
export async function pruefeVerknuepfung(c: Client, neu: { vorgang_id: string; vorgaenger_id: string }, ausser?: string): Promise<void> {
|
||||
const r = await c.query<Verknuepfung & { id: string }>("select id, vorgang_id, vorgaenger_id, art, verzoegerung from vorgang_vorgaenger");
|
||||
if (bildetKreis(neu, r.rows.filter((k) => k.id !== ausser))) {
|
||||
throw new PlanFehler("Diese Verknüpfung ergäbe einen Kreis: der Vorgänger hängt schon (über andere Vorgänge) an diesem Vorgang.");
|
||||
}
|
||||
}
|
||||
|
||||
/** Alles, was das Gantt braucht, mit berechnetem Anfang und Ende je Vorgang. */
|
||||
export async function terminplan(pool: Pool, woche: Arbeitswoche) {
|
||||
const [projekte, abschnitte, vorgaenge, links, besetzungen, leute] = await Promise.all([
|
||||
pool.query(`select p.id, p.nummer, p.bezeichnung, p.status, p.farbe, p.reihenfolge, 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"),
|
||||
pool.query("select id, abschnitt_id, nummer, name, start, dauer, stunden, personen, kontakt_id, fortschritt, reihenfolge from vorgang order by reihenfolge, nummer"),
|
||||
pool.query("select id, vorgang_id, vorgaenger_id, art, verzoegerung from vorgang_vorgaenger"),
|
||||
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"),
|
||||
]);
|
||||
const vs = vorgaenge.rows.map((v) => ({ ...v, anfang: anfang(v, woche), ende: ende(v, woche) }));
|
||||
const bs = besetzungen.rows.map((b) => ({
|
||||
...b,
|
||||
kurz: b.kontakt_id ? kuerzel(b.rolle === "subunternehmer" && b.firma ? b.firma : b.name, b.rolle) : b.platzhalter,
|
||||
anzeige: b.kontakt_id ? (b.firma && b.rolle === "subunternehmer" ? b.firma : b.name) : b.platzhalter,
|
||||
}));
|
||||
const anzeige = new Map(bs.map((b) => [b.kontakt_id ?? `platzhalter:${String(b.platzhalter).trim().toLowerCase()}`, b.anzeige]));
|
||||
return {
|
||||
projekte: projekte.rows,
|
||||
abschnitte: abschnitte.rows,
|
||||
vorgaenge: vs,
|
||||
verknuepfungen: links.rows,
|
||||
besetzungen: bs,
|
||||
leute: leute.rows,
|
||||
ueberschneidungen: ueberschneidungen(vs, bs).map((u) => ({ ...u, name: anzeige.get(u.wer) ?? u.wer })),
|
||||
arbeitstage: woche.tage,
|
||||
};
|
||||
}
|
||||
73
src/server/uebersicht.ts
Normal file
73
src/server/uebersicht.ts
Normal file
@@ -0,0 +1,73 @@
|
||||
// Startseite zusammenstellen: in fünf Minuten sehen, was heute und in den nächsten Tagen ansteht.
|
||||
import { type Datum, formatDatum, plusTage } from "../domain/datum.js";
|
||||
import { formatEuro } from "../domain/geld.js";
|
||||
import type { Arbeitswoche } from "../domain/kalender.js";
|
||||
import { type Warnung, aufgabenGruppen, einsatzMatrix, naechsteArbeitstage } from "../domain/uebersicht.js";
|
||||
import type { terminplan } from "./terminplan.js";
|
||||
|
||||
/** Projekte, deren Vorgänge auf der Startseite und in den Warnungen zählen */
|
||||
const LAUFEND = new Set(["auftrag", "ausfuehrung"]);
|
||||
/** Wie weit vorausgeschaut wird: Besetzung und Freigabe müssen bis dahin stehen */
|
||||
const VORLAUF_TAGE = 14;
|
||||
|
||||
interface Eingabe {
|
||||
heute: Datum;
|
||||
woche: Arbeitswoche;
|
||||
tp: Awaited<ReturnType<typeof terminplan>>;
|
||||
aufgaben: { id: string; text: string; faellig_am: Datum | null; langfristig: boolean; erledigt_am: string | null; projekt_nummer: string | null }[];
|
||||
liqui: { von: Datum; saldo: number; kontostand: number; einnahmen: number; ausgaben: number }[];
|
||||
mindestreserve: number;
|
||||
/** false, solange Henning den aktuellen Kontostand nicht eingetragen hat */
|
||||
kontostandErfasst: boolean;
|
||||
}
|
||||
|
||||
export function uebersicht({ heute, woche, tp, aufgaben, liqui, mindestreserve, kontostandErfasst }: Eingabe) {
|
||||
const projektVon = new Map(tp.abschnitte.map((a) => [a.id, tp.projekte.find((p) => p.id === a.projekt_id)!]));
|
||||
const vorgaenge = tp.vorgaenge
|
||||
.map((v) => ({ ...v, p: projektVon.get(v.abschnitt_id)! }))
|
||||
.filter((v) => v.p && LAUFEND.has(v.p.status) && v.ende >= heute)
|
||||
.map((v) => ({ id: v.id, name: v.name, anfang: v.anfang, ende: v.ende, dauer: Number(v.dauer), projekt: `${v.p.nummer} ${v.p.bezeichnung}` }));
|
||||
const bald = plusTage(heute, VORLAUF_TAGE);
|
||||
const vName = (id: string) => {
|
||||
const v = tp.vorgaenge.find((x) => x.id === id)!;
|
||||
const p = projektVon.get(v.abschnitt_id);
|
||||
return `${p ? p.nummer + " " : ""}${v.name}`;
|
||||
};
|
||||
|
||||
const warnungen: Warnung[] = [];
|
||||
for (const u of tp.ueberschneidungen) {
|
||||
const ende = [u.vorgang_a, u.vorgang_b].map((id) => tp.vorgaenge.find((v) => v.id === id)!.ende).sort()[0]!;
|
||||
if (ende < heute) continue;
|
||||
warnungen.push({ art: "ueberschneidung", ziel: "terminplan",
|
||||
text: `${u.name} ist ab ${formatDatum(u.ab)} doppelt eingeplant: ${vName(u.vorgang_a)} und ${vName(u.vorgang_b)}` });
|
||||
}
|
||||
for (const v of vorgaenge) {
|
||||
if (v.anfang > bald || v.dauer === 0) continue;
|
||||
const bs = tp.besetzungen.filter((b) => b.vorgang_id === v.id);
|
||||
if (!bs.length) warnungen.push({ art: "unbesetzt", ziel: "terminplan", text: `${vName(v.id)} ab ${formatDatum(v.anfang)} ist noch nicht besetzt` });
|
||||
for (const b of bs.filter((b) => !b.freigegeben)) {
|
||||
warnungen.push({ art: "freigabe", ziel: "terminplan", text: `${b.anzeige} bei ${vName(v.id)} ab ${formatDatum(v.anfang)} ist nur vorgemerkt, Freigabe fehlt` });
|
||||
}
|
||||
}
|
||||
const gruppen = aufgabenGruppen(aufgaben, heute);
|
||||
if (gruppen.ueberfaellig.length) {
|
||||
warnungen.push({ art: "aufgabe", ziel: "aufgaben", text: `${gruppen.ueberfaellig.length} ${gruppen.ueberfaellig.length === 1 ? "Aufgabe ist" : "Aufgaben sind"} überfällig` });
|
||||
}
|
||||
const knapp = liqui.find((w) => w.kontostand < mindestreserve);
|
||||
if (!kontostandErfasst) {
|
||||
warnungen.push({ art: "kontostand", ziel: "daten", text: "Aktueller Kontostand ist noch nicht eingetragen, die Liquidität rechnet ab 0 €" });
|
||||
} else if (knapp) {
|
||||
warnungen.push({ art: "kontostand", ziel: "liquiditaet",
|
||||
text: `Kontostand in der Woche ab ${formatDatum(knapp.von)} bei ${formatEuro(knapp.kontostand)}${mindestreserve ? `, unter der Mindestreserve von ${formatEuro(mindestreserve)}` : ""}` });
|
||||
}
|
||||
|
||||
const tage = naechsteArbeitstage(heute, 8, woche);
|
||||
return {
|
||||
heute,
|
||||
aufgaben: gruppen,
|
||||
warnungen,
|
||||
// Meilensteine brauchen keine Besetzung und bleiben aus „Wer macht was“ heraus
|
||||
einsatz: { tage, ...einsatzMatrix(vorgaenge.filter((v) => v.dauer > 0), tp.besetzungen, tage) },
|
||||
liquiditaet: liqui.map(({ von, saldo, kontostand }) => ({ von, saldo, kontostand })),
|
||||
};
|
||||
}
|
||||
@@ -36,8 +36,11 @@ export async function speichereUebernahme(c: Client, u: Uebernahme): Promise<Rec
|
||||
for (const { schluessel, projekt, ...a } of u.abschnitte) {
|
||||
id.set(schluessel, await einfuegen(c, "abschnitt", { ...a, projekt_id: ref(projekt) }));
|
||||
}
|
||||
// V70-Nummern bleiben, damit Henning seine Vorgänger-Nummern wiederfindet; neue zählen danach weiter
|
||||
const hoechste = Math.max(1000, ...u.vorgaenge.map((v) => v.reihenfolge));
|
||||
await c.query("select setval('vorgang_nummer_seq', $1)", [hoechste]);
|
||||
for (const { schluessel, abschnitt, ...v } of u.vorgaenge) {
|
||||
id.set(schluessel, await einfuegen(c, "vorgang", { ...v, abschnitt_id: ref(abschnitt) }));
|
||||
id.set(schluessel, await einfuegen(c, "vorgang", { ...v, nummer: v.reihenfolge > 0 ? v.reihenfolge : undefined, abschnitt_id: ref(abschnitt) }));
|
||||
}
|
||||
for (const k of u.verknuepfungen) {
|
||||
await einfuegen(c, "vorgang_vorgaenger", { vorgang_id: ref(k.vorgang), vorgaenger_id: ref(k.vorgaenger), art: k.art, verzoegerung: k.verzoegerung });
|
||||
@@ -47,6 +50,7 @@ export async function speichereUebernahme(c: Client, u: Uebernahme): Promise<Rec
|
||||
}
|
||||
for (const { projekt, ...k } of u.kosten) await einfuegen(c, "kosten", { ...k, projekt_id: ref(projekt) });
|
||||
for (const l of u.laufend) await einfuegen(c, "laufende_kosten", l);
|
||||
for (const { projekt, ...a } of u.aufgaben) await einfuegen(c, "aufgabe", { ...a, projekt_id: ref(projekt) });
|
||||
|
||||
const alt = await c.query<{ daten: unknown }>("select daten from einstellungen limit 1");
|
||||
const bisher = EinstellungenSchema.parse(alt.rows[0]?.daten ?? {});
|
||||
@@ -55,6 +59,6 @@ export async function speichereUebernahme(c: Client, u: Uebernahme): Promise<Rec
|
||||
|
||||
return {
|
||||
kontakte: u.kontakte.length, projekte: u.projekte.length, abschnitte: u.abschnitte.length, vorgaenge: u.vorgaenge.length,
|
||||
verknuepfungen: u.verknuepfungen.length, zahlungen: u.zahlungen.length, kosten: u.kosten.length, laufendeKosten: u.laufend.length,
|
||||
verknuepfungen: u.verknuepfungen.length, zahlungen: u.zahlungen.length, kosten: u.kosten.length, laufendeKosten: u.laufend.length, aufgaben: u.aufgaben.length,
|
||||
};
|
||||
}
|
||||
|
||||
160
src/web/app.ts
160
src/web/app.ts
@@ -3,6 +3,7 @@
|
||||
|
||||
import { formatEuro, parseEuro } from "../domain/geld.js";
|
||||
import { formatDatum } from "../domain/datum.js";
|
||||
import { terminplanSeite } from "./gantt.js";
|
||||
|
||||
type Zeile = Record<string, any>;
|
||||
|
||||
@@ -117,12 +118,17 @@ function bestaetigen(frage: string): Promise<boolean> {
|
||||
async function bearbeiten(pfad: string, titel: string, felder: Feld[], zeile: Zeile | null, vorgaben: Zeile = {}): Promise<boolean> {
|
||||
const e = await dialog(titel, felder, zeile ?? vorgaben, !!zeile);
|
||||
if (!e) return false;
|
||||
let antwort: Zeile | undefined;
|
||||
if (e.aktion === "loeschen") await api(`${pfad}/${zeile!.id}`, "DELETE");
|
||||
else if (zeile) await api(`${pfad}/${zeile.id}`, "PATCH", e.daten);
|
||||
else await api(pfad, "POST", { ...vorgaben, ...e.daten });
|
||||
else if (zeile) antwort = await api(`${pfad}/${zeile.id}`, "PATCH", e.daten);
|
||||
else antwort = await api(pfad, "POST", { ...vorgaben, ...e.daten });
|
||||
// gespeichert, aber z. B. der Projektordner in der Nextcloud hat nicht geklappt
|
||||
if (antwort?.ordner_fehler) hinweisNachLaden = antwort.ordner_fehler;
|
||||
return true;
|
||||
}
|
||||
|
||||
let hinweisNachLaden = "";
|
||||
|
||||
function tabelle(spalten: { titel: string; wert: (z: Zeile) => string; klasse?: string }[], zeilen: Zeile[], klick?: (z: Zeile) => void): HTMLTableElement {
|
||||
const t = document.createElement("table");
|
||||
t.innerHTML = `<thead><tr>${spalten.map((s) => `<th class="${s.klasse ?? ""}">${esc(s.titel)}</th>`).join("")}</tr></thead>
|
||||
@@ -134,17 +140,19 @@ function tabelle(spalten: { titel: string; wert: (z: Zeile) => string; klasse?:
|
||||
return t;
|
||||
}
|
||||
|
||||
// Kopf wie bei Plancraft: Titel links, Hauptknopf rechts; darunter eine Leiste für Filter
|
||||
function seite(titel: string, knopf?: { text: string; aktion: () => void }): HTMLElement {
|
||||
inhalt.innerHTML = `<h1>${esc(titel)}</h1>`;
|
||||
const leiste = document.createElement("div");
|
||||
leiste.className = "leiste";
|
||||
inhalt.innerHTML = `<div class="kopf"><h1>${esc(titel)}</h1></div>${hinweisNachLaden ? `<div class="warnung">${esc(hinweisNachLaden)}</div>` : ""}`;
|
||||
hinweisNachLaden = "";
|
||||
if (knopf) {
|
||||
const b = document.createElement("button");
|
||||
b.className = "haupt";
|
||||
b.textContent = knopf.text;
|
||||
b.onclick = knopf.aktion;
|
||||
leiste.appendChild(b);
|
||||
inhalt.firstElementChild!.appendChild(b);
|
||||
}
|
||||
const leiste = document.createElement("div");
|
||||
leiste.className = "leiste";
|
||||
inhalt.appendChild(leiste);
|
||||
return leiste;
|
||||
}
|
||||
@@ -175,10 +183,18 @@ async function kontakte(): Promise<void> {
|
||||
], zeilen, async (z) => (await bearbeiten("kontakte", "Kontakt bearbeiten", KONTAKT_FELDER, z)) && kontakte()));
|
||||
}
|
||||
|
||||
const STATUS: [string, string][] = [
|
||||
["anfrage", "Anfrage"], ["angebot", "Angebot"], ["auftrag", "Auftrag erhalten"], ["ausfuehrung", "Ausführung"],
|
||||
["abgerechnet", "Abgerechnet"], ["gewaehrleistung", "Gewährleistung"], ["abgeschlossen", "Abgeschlossen"],
|
||||
];
|
||||
const STATUS_TEXT = Object.fromEntries(STATUS);
|
||||
const etikett = (status: string) => `<span class="etikett ${esc(status)}">${esc(STATUS_TEXT[status] ?? status)}</span>`;
|
||||
|
||||
async function projekte(): Promise<void> {
|
||||
const kontaktListe = await api<Zeile[]>("kontakte");
|
||||
const felder: Feld[] = [
|
||||
{ name: "nummer", titel: "Nummer", pflicht: true }, { name: "bezeichnung", titel: "Baustelle", pflicht: true },
|
||||
{ name: "status", titel: "Status", art: "auswahl", optionen: STATUS },
|
||||
{ name: "bauherr_id", titel: "Bauherr", art: "auswahl", optionen: [["", "–"], ...kontaktListe.map((k): [string, string] => [k.id, k.name])] },
|
||||
{ name: "umsatz_netto", titel: "Umsatz netto", art: "euro" }, { name: "material_kosten", titel: "Materialkosten", art: "euro" },
|
||||
{ name: "fremd_kosten", titel: "Fremdkosten", art: "euro" }, { name: "sonstige_kosten", titel: "Sonstige Kosten", art: "euro" },
|
||||
@@ -192,21 +208,20 @@ async function projekte(): Promise<void> {
|
||||
const name = Object.fromEntries(kontaktListe.map((k) => [k.id, k.name]));
|
||||
const kostenSumme = (z: Zeile) => z.material_kosten + z.fremd_kosten + z.sonstige_kosten;
|
||||
inhalt.appendChild(tabelle([
|
||||
{ titel: "Nr.", wert: (z) => esc(z.nummer) },
|
||||
{ titel: "Baustelle", wert: (z) => esc(z.bezeichnung) },
|
||||
{ titel: "Bauherr", wert: (z) => esc(name[z.bauherr_id]), klasse: "optional" },
|
||||
{ titel: "Umsatz netto", wert: (z) => euro(z.umsatz_netto), klasse: "zahl" },
|
||||
{ titel: "Name", wert: (z) => `<strong>${esc(z.bezeichnung)}</strong><span class="unter"><span class="nur-schmal">${esc(z.nummer)} · </span>${esc(name[z.bauherr_id] ?? "–")}</span>` },
|
||||
{ titel: "Nummer", wert: (z) => esc(z.nummer), klasse: "optional" },
|
||||
{ titel: "Status", wert: (z) => etikett(z.status) },
|
||||
{ titel: "Umsatz netto", wert: (z) => euro(z.umsatz_netto), klasse: "zahl optional" },
|
||||
{ titel: "Kosten", wert: (z) => euro(kostenSumme(z)), klasse: "zahl optional" },
|
||||
{ titel: "Rohertrag", wert: (z) => euro(z.umsatz_netto - kostenSumme(z)), klasse: "zahl" },
|
||||
{ titel: "Rohertrag", wert: (z) => euro(z.umsatz_netto - kostenSumme(z)), klasse: "zahl optional" },
|
||||
], zeilen, (z) => speichern(ohneNull(z))));
|
||||
const gesamt = zeilen.reduce((s, z) => s + z.umsatz_netto - kostenSumme(z), 0);
|
||||
inhalt.insertAdjacentHTML("beforeend", `<p>Rohertrag gesamt: <strong>${euro(gesamt)}</strong></p>
|
||||
inhalt.insertAdjacentHTML("beforeend", `<p class="anzahl">${zeilen.length} Projekte</p><p>Rohertrag gesamt: <strong>${euro(gesamt)}</strong></p>
|
||||
<p class="hinweis">Projektdetailseite, Einzelposten und Zahlungsplan folgen mit der V70-Übernahme.</p>`);
|
||||
}
|
||||
|
||||
async function terminplan(): Promise<void> {
|
||||
seite("Terminplan");
|
||||
inhalt.insertAdjacentHTML("beforeend", `<p class="hinweis">Der Gantt-Terminplan aus V70 wird als Nächstes übernommen. Arbeitstage (Mo–Do, Feiertage Schleswig-Holstein) und Stundenumrechnung sind bereits fertig und geprüft.</p>`);
|
||||
await terminplanSeite({ api, dialog, esc, seite: (t) => seite(t), inhalt });
|
||||
}
|
||||
|
||||
async function liquiditaetSeite(ansicht = "woche", anzahl = 8): Promise<void> {
|
||||
@@ -278,19 +293,92 @@ async function aufgaben(): Promise<void> {
|
||||
inhalt.appendChild(aufgabenTabelle(await api<Zeile[]>("aufgaben"), aufgaben));
|
||||
}
|
||||
|
||||
const WOCHENTAG = ["", "Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"];
|
||||
const WOCHENTAG_LANG = ["", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag"];
|
||||
const wtag = (d: string) => new Date(`${d}T00:00:00Z`).getUTCDay() || 7;
|
||||
|
||||
// Startseite in der Reihenfolge, die Henning festgelegt hat: Aufgaben und Warnungen gleichrangig
|
||||
// nebeneinander, darunter wer was wann wo macht, dann die Liquidität
|
||||
async function uebersicht(): Promise<void> {
|
||||
const u = await api<Zeile>(`uebersicht?heute=${heute()}`);
|
||||
seite("Übersicht");
|
||||
const [alle, perioden] = await Promise.all([api<Zeile[]>("aufgaben"), api<Zeile[]>(`liquiditaet?ansicht=woche&anzahl=4&start=${heute()}`)]);
|
||||
const bisSonntag = new Date(Date.now() + 7 * 86400000).toISOString().slice(0, 10);
|
||||
const anstehend = alle.filter((a) => !a.erledigt_am && a.faellig_am && a.faellig_am <= bisSonntag);
|
||||
inhalt.insertAdjacentHTML("beforeend", `<h2>Anstehende Aufgaben</h2>`);
|
||||
inhalt.appendChild(anstehend.length ? aufgabenTabelle(anstehend, uebersicht) : Object.assign(document.createElement("p"), { className: "hinweis", textContent: "Nichts fällig in den nächsten 7 Tagen." }));
|
||||
inhalt.insertAdjacentHTML("beforeend", `<h2>Liquidität 4 Wochen</h2>`);
|
||||
inhalt.appendChild(tabelle([
|
||||
{ titel: "Woche ab", wert: (p) => dat(p.von) },
|
||||
{ titel: "Saldo", wert: (p) => euro(p.saldo), klasse: "zahl" },
|
||||
{ titel: "Kontostand", wert: (p) => `<span class="${p.kontostand < 0 ? "fehler" : ""}">${euro(p.kontostand)}</span>`, klasse: "zahl" },
|
||||
], perioden));
|
||||
inhalt.querySelector(".kopf h1")!.insertAdjacentHTML("beforeend", ` <small class="datum">${WOCHENTAG_LANG[wtag(u.heute)]}, ${dat(u.heute)}</small>`);
|
||||
|
||||
const aufgabeLi = (a: Zeile) => `<li><label><input type="checkbox" data-erledigt="${a.id}"> <span>${esc(a.text)}</span></label>
|
||||
<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)}` : ""}</small></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: "€" };
|
||||
|
||||
const raster = document.createElement("div");
|
||||
raster.className = "start";
|
||||
raster.innerHTML = `
|
||||
<section class="karte"><div class="karte-kopf"><h2>Aufgaben</h2><button class="neben" data-a="neue-aufgabe">+ Aufgabe</button></div>
|
||||
${gruppe("Noch nicht abgearbeitet", u.aufgaben.ueberfaellig, "Nichts liegen geblieben.", true)}
|
||||
${gruppe(`Diese Woche`, u.aufgaben.dieseWoche, "Keine Aufgaben mehr in dieser Woche.")}
|
||||
${gruppe("Langfristig", u.aufgaben.langfristig, "Keine langfristigen Aufgaben.")}</section>
|
||||
<section class="karte"><div class="karte-kopf"><h2>Warnungen</h2></div>
|
||||
${u.warnungen.length ? `<ul class="warnungen">${u.warnungen.map((w: Zeile) => `<li class="${w.art}"><a href="#${w.ziel}"><span class="symbol">${SYMBOL[w.art] ?? "!"}</span>${esc(w.text)}</a></li>`).join("")}</ul>`
|
||||
: '<p class="hinweis">Alles im grünen Bereich.</p>'}</section>
|
||||
<section class="karte breit"><div class="karte-kopf"><h2>Wer macht was</h2><a class="neben" href="#terminplan">Terminplan</a></div>${einsatzHtml(u.einsatz)}</section>
|
||||
<section class="karte breit"><div class="karte-kopf"><h2>Liquidität 4 Wochen</h2><a class="neben" href="#liquiditaet">Details</a></div>
|
||||
<div class="liqui">${u.liquiditaet.map((p: Zeile) => `<div><small>ab ${dat(p.von).slice(0, 6)}</small><b class="${p.kontostand < 0 ? "fehler" : ""}">${euro(p.kontostand)}</b><small>Saldo ${euro(p.saldo)}</small></div>`).join("")}</div></section>`;
|
||||
inhalt.appendChild(raster);
|
||||
|
||||
raster.addEventListener("change", async (ev) => {
|
||||
const box = ev.target as HTMLInputElement;
|
||||
if (!box.dataset.erledigt) return;
|
||||
await api(`aufgaben/${box.dataset.erledigt}`, "PATCH", { erledigt_am: box.checked ? new Date().toISOString() : null });
|
||||
uebersicht();
|
||||
});
|
||||
raster.querySelector<HTMLElement>('[data-a="neue-aufgabe"]')!.onclick = async () => {
|
||||
if (await bearbeiten("aufgaben", "Neue Aufgabe", AUFGABE_FELDER, null)) uebersicht();
|
||||
};
|
||||
}
|
||||
|
||||
function einsatzHtml(e: Zeile): string {
|
||||
if (!e.zeilen.length && e.ohne.tage.every((t: Zeile[]) => !t.length)) return '<p class="hinweis">In den nächsten zwei Wochen ist nichts eingeplant.</p>';
|
||||
const zeilen = [...e.zeilen, ...(e.ohne.tage.some((t: Zeile[]) => t.length) ? [e.ohne] : [])];
|
||||
const kopf = e.tage.map((d: string, i: number) => `<th class="${i > 0 && wtag(d) < wtag(e.tage[i - 1]) ? "neue-woche" : ""}">${WOCHENTAG[wtag(d)]} ${dat(d).slice(0, 6)}</th>`).join("");
|
||||
const zelle = (eintraege: Zeile[], d: string, i: number) => `<td class="${i > 0 && wtag(d) < wtag(e.tage[i - 1]) ? "neue-woche" : ""}">${eintraege.map((x) =>
|
||||
`<span class="einsatz${x.vorgemerkt ? " vorgemerkt" : ""}" title="${esc(x.projekt)}: ${esc(x.name)}${x.vorgemerkt ? " (vorgemerkt)" : ""}">${esc(x.projekt.split(" ")[0])} ${esc(x.name)}</span>`).join("")}</td>`;
|
||||
const tabelle = `<div class="einsatz-tabelle"><table><thead><tr><th>Wer</th>${kopf}</tr></thead><tbody>${zeilen.map((z: Zeile) =>
|
||||
`<tr class="${z.wer ? "" : "ohne"}"><th>${esc(z.anzeige)}</th>${z.tage.map((t: Zeile[], i: number) => zelle(t, e.tage[i], i)).join("")}</tr>`).join("")}</tbody></table></div>`;
|
||||
// am Handy: je Tag eine Liste
|
||||
const liste = `<div class="einsatz-liste">${e.tage.map((d: string, i: number) => {
|
||||
const eintraege = zeilen.flatMap((z: Zeile) => z.tage[i].map((x: Zeile) => ({ ...x, wer: z.anzeige })));
|
||||
return eintraege.length ? `<h3>${WOCHENTAG_LANG[wtag(d)]}, ${dat(d)}</h3><ul>${eintraege.map((x: Zeile) =>
|
||||
`<li><b>${esc(x.wer)}</b> ${esc(x.projekt)} · ${esc(x.name)}${x.vorgemerkt ? " <i>(vorgemerkt)</i>" : ""}</li>`).join("")}</ul>` : "";
|
||||
}).join("")}</div>`;
|
||||
return tabelle + liste;
|
||||
}
|
||||
|
||||
// T11: Kalender-Abos für Outlook classic (nur lesen, Outlook holt Änderungen selbst ab)
|
||||
function kalenderLinks(token: string | null): void {
|
||||
const ziel = document.getElementById("kalender")!;
|
||||
const neu = async () => {
|
||||
if (token && !(await bestaetigen("Neue Links erzeugen? Die bisherigen Abos in Outlook funktionieren dann nicht mehr."))) return;
|
||||
kalenderLinks((await api<{ kalenderToken: string }>("kalender/neu", "POST")).kalenderToken);
|
||||
};
|
||||
if (!token) {
|
||||
ziel.innerHTML = `<p class="hinweis">Die Vorgänge aus dem Terminplan und fällige Aufgaben lassen sich als Internetkalender in Outlook einbinden.</p>
|
||||
<p><button class="haupt">Kalender-Links erzeugen</button></p>`;
|
||||
ziel.querySelector("button")!.onclick = neu;
|
||||
return;
|
||||
}
|
||||
const link = (name: string) => `${location.origin}/kalender/${token}/${name}`;
|
||||
ziel.innerHTML = `${[["Baustellen", "baustellen.ics"], ["Aufgaben", "aufgaben.ics"]].map(([titel, datei]) =>
|
||||
`<div class="kalender-link"><b>${titel}</b><input readonly value="${esc(link(datei!))}"><button class="neben" data-kopie="${esc(link(datei!))}">Kopieren</button></div>`).join("")}
|
||||
<p class="hinweis">In Outlook: Datei → Kontoeinstellungen → Kontoeinstellungen → Internetkalender → Neu, Link einfügen, Name „Baustellen“ bzw. „Aufgaben“.
|
||||
Outlook holt Änderungen etwa stündlich ab. Wer den Link hat, kann die Termine lesen; gib ihn deshalb nicht weiter.</p>
|
||||
<p><button class="neben" data-a="neu">Neue Links erzeugen</button></p>`;
|
||||
ziel.onclick = async (ev) => {
|
||||
const b = ev.target as HTMLElement;
|
||||
if (b.dataset.kopie) {
|
||||
try { await navigator.clipboard.writeText(b.dataset.kopie); b.textContent = "Kopiert"; } catch { (b.previousElementSibling as HTMLInputElement).select(); }
|
||||
}
|
||||
if (b.dataset.a === "neu") neu();
|
||||
};
|
||||
}
|
||||
|
||||
async function daten(): Promise<void> {
|
||||
@@ -303,7 +391,10 @@ async function daten(): Promise<void> {
|
||||
<p class="hinweis">Sicherungsdatei aus V70 wählen (projektplaner-sicherung-….json). Geht nur, solange noch nichts erfasst ist.</p>
|
||||
<p><input type="file" id="v70-datei" accept=".json,application/json"></p>
|
||||
<div id="v70-ergebnis"></div>
|
||||
<h2>Kalender in Outlook</h2>
|
||||
<div id="kalender"></div>
|
||||
<h2>Einstellungen</h2>`);
|
||||
kalenderLinks(e.kalenderToken);
|
||||
const datei = document.getElementById("v70-datei") as HTMLInputElement;
|
||||
datei.onchange = async () => {
|
||||
const f = datei.files?.[0];
|
||||
@@ -336,6 +427,8 @@ async function daten(): Promise<void> {
|
||||
const d = r.daten;
|
||||
await api("einstellungen", "PUT", {
|
||||
...e, startsaldo: d.startsaldo ?? 0, stundenProTag: d.stundenProTag ?? e.stundenProTag,
|
||||
// Datum merken, damit die Startseite weiß, dass der Kontostand eingetragen ist
|
||||
startsaldoDatum: (d.startsaldo ?? 0) !== e.startsaldo ? heute() : e.startsaldoDatum,
|
||||
zahlungsziele: { ...e.zahlungsziele, kundenTage: d.kundenTage ?? 0, materialTage: d.materialTage ?? 0, fremdTage: d.fremdTage ?? 0 },
|
||||
ust: { ...e.ust, versteuerung: d.versteuerung, voranmeldung: d.voranmeldung },
|
||||
});
|
||||
@@ -352,10 +445,23 @@ const REITER: [string, string, () => Promise<void>][] = [
|
||||
["daten", "Daten", daten],
|
||||
];
|
||||
|
||||
// Einfache Strichsymbole (24er Raster), Farbe kommt aus der Schrift
|
||||
const SYMBOLE: Record<string, string> = {
|
||||
uebersicht: '<path d="M3 11l9-7 9 7"/><path d="M5 10v10h14V10"/>',
|
||||
aufgaben: '<path d="M9 11l3 3 8-8"/><path d="M20 12v7a1 1 0 0 1-1 1H5a1 1 0 0 1-1-1V5a1 1 0 0 1 1-1h11"/>',
|
||||
projekte: '<path d="M3 6a1 1 0 0 1 1-1h5l2 2h9a1 1 0 0 1 1 1v10a1 1 0 0 1-1 1H4a1 1 0 0 1-1-1z"/>',
|
||||
terminplan: '<rect x="3" y="5" width="18" height="16" rx="1"/><path d="M3 10h18M8 3v4M16 3v4"/>',
|
||||
kontakte: '<circle cx="12" cy="8" r="4"/><path d="M4 21c1-4 4-6 8-6s7 2 8 6"/>',
|
||||
liquiditaet: '<path d="M3 17l6-6 4 4 8-8"/><path d="M15 7h6v6"/>',
|
||||
"laufende-kosten": '<rect x="3" y="6" width="18" height="13" rx="1"/><path d="M3 10h18M7 15h4"/>',
|
||||
daten: '<ellipse cx="12" cy="6" rx="8" ry="3"/><path d="M4 6v12c0 1.7 3.6 3 8 3s8-1.3 8-3V6M4 12c0 1.7 3.6 3 8 3s8-1.3 8-3"/>',
|
||||
};
|
||||
const symbol = (id: string) => `<svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">${SYMBOLE[id] ?? ""}</svg>`;
|
||||
|
||||
const nav = document.getElementById("reiter")!;
|
||||
nav.innerHTML = REITER.map(([id, titel]) => `<button data-r="${id}">${titel}</button>`).join("");
|
||||
nav.innerHTML = REITER.map(([id, titel]) => `<button data-r="${id}">${symbol(id)}<span>${titel}</span></button>`).join("");
|
||||
nav.addEventListener("click", (ev) => {
|
||||
const r = (ev.target as HTMLElement).dataset.r;
|
||||
const r = ((ev.target as HTMLElement).closest("button[data-r]") as HTMLElement | null)?.dataset.r;
|
||||
if (r) location.hash = r;
|
||||
});
|
||||
|
||||
|
||||
BIN
src/web/bilder/logo.png
Normal file
BIN
src/web/bilder/logo.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 19 KiB |
420
src/web/gantt.ts
Normal file
420
src/web/gantt.ts
Normal file
@@ -0,0 +1,420 @@
|
||||
// Terminplan als Gantt wie in V70 (T1–T5): Projekt → Abschnitt → Vorgang, Balken ziehen
|
||||
// verschiebt, rechter Griff ändert die Dauer, Vorgänger per Nummer mit Art und Verzögerung.
|
||||
// Die Neuplanung der Nachfolger macht der Server.
|
||||
|
||||
import { type Datum, formatDatum, plusTage, tageZwischen, wochentag, montagDerWoche } from "../domain/datum.js";
|
||||
import { wer } from "../domain/einsatz.js";
|
||||
import { type Arbeitswoche, arbeitstageZwischen, feiertag, istArbeitstag, naechsterArbeitstag } from "../domain/kalender.js";
|
||||
|
||||
type Zeile = Record<string, any>;
|
||||
|
||||
export interface Hilfen {
|
||||
api<T = any>(pfad: string, methode?: string, body?: unknown): Promise<T>;
|
||||
dialog(titel: string, felder: { name: string; titel: string; art?: "text" | "datum" | "zahl" | "auswahl"; optionen?: [string, string][]; pflicht?: boolean }[], werte: Zeile, mitLoeschen: boolean):
|
||||
Promise<{ aktion: "speichern"; daten: Zeile } | { aktion: "loeschen" } | null>;
|
||||
esc(v: unknown): string;
|
||||
seite(titel: string): HTMLElement;
|
||||
inhalt: HTMLElement;
|
||||
}
|
||||
|
||||
interface Plan {
|
||||
projekte: Zeile[];
|
||||
abschnitte: Zeile[];
|
||||
vorgaenge: Zeile[];
|
||||
verknuepfungen: Zeile[];
|
||||
besetzungen: Zeile[];
|
||||
leute: Zeile[];
|
||||
ueberschneidungen: Zeile[];
|
||||
arbeitstage: number[];
|
||||
}
|
||||
|
||||
const ZOOM: Record<string, number> = { tag: 24, woche: 10, monat: 4 };
|
||||
const ZEILE = 34;
|
||||
const FARBEN = ["#1d5fa8", "#2f6b5a", "#b7791f", "#a26e3a", "#805ad5", "#c53030", "#2c7a7b", "#97266d", "#4a5568", "#6b8e23"];
|
||||
const MONATE = ["Jan", "Feb", "Mär", "Apr", "Mai", "Jun", "Jul", "Aug", "Sep", "Okt", "Nov", "Dez"];
|
||||
|
||||
// Ansichtseinstellungen nur für diesen Browser
|
||||
function merke<T>(schluessel: string, wert?: T): T | undefined {
|
||||
try {
|
||||
if (wert === undefined) return JSON.parse(localStorage.getItem(`betrieb-${schluessel}`) ?? "null") ?? undefined;
|
||||
localStorage.setItem(`betrieb-${schluessel}`, JSON.stringify(wert));
|
||||
} catch { /* privates Fenster: dann eben ohne Gedächtnis */ }
|
||||
return wert;
|
||||
}
|
||||
|
||||
/** „1003, 1005 AA+2“ → Liste von Verknüpfungen; wirft bei unbekannter Nummer. */
|
||||
export function leseVorgaenger(text: string, nummern: Map<number, string>): { vorgaenger_id: string; art: string; verzoegerung: number }[] {
|
||||
return text.split(/[,;]/).map((s) => s.trim()).filter(Boolean).map((s) => {
|
||||
const m = /^(\d+)\s*(EA|AA|EE|AE)?\s*([+-]\s*\d+)?$/i.exec(s);
|
||||
if (!m) throw new Error(`„${s}“ verstehe ich nicht. Beispiele: 1003, 1003 AA, 1003 EA+2`);
|
||||
const id = nummern.get(Number(m[1]));
|
||||
if (!id) throw new Error(`Vorgang ${m[1]} gibt es nicht.`);
|
||||
return { vorgaenger_id: id, art: (m[2] ?? "EA").toUpperCase(), verzoegerung: m[3] ? Number(m[3].replace(/\s/g, "")) : 0 };
|
||||
});
|
||||
}
|
||||
|
||||
export function vorgaengerText(links: Zeile[], nummer: Map<string, number>): string {
|
||||
return links.map((k) => `${nummer.get(k.vorgaenger_id)}${k.art !== "EA" || k.verzoegerung ? ` ${k.art}` : ""}${k.verzoegerung ? (k.verzoegerung > 0 ? "+" : "") + k.verzoegerung : ""}`).join(", ");
|
||||
}
|
||||
|
||||
export async function terminplanSeite(h: Hilfen): Promise<void> {
|
||||
const { api, esc, inhalt } = h;
|
||||
const leiste = h.seite("Terminplan");
|
||||
const plan = await api<Plan>("terminplan");
|
||||
const woche: Arbeitswoche = { tage: plan.arbeitstage };
|
||||
let zoom = merke<string>("gantt-zoom") ?? "tag";
|
||||
const zu = new Set<string>(merke<string[]>("gantt-zu") ?? []);
|
||||
const mitFertigen = merke<boolean>("gantt-fertige") ?? false;
|
||||
// Ü5: nur die Vorgänge einer Person, eines Subunternehmers oder einer Kolonne zeigen
|
||||
const personen = new Map<string, string>();
|
||||
for (const k of plan.leute) personen.set(k.id, k.rolle === "subunternehmer" && k.firma ? k.firma : k.name);
|
||||
for (const b of plan.besetzungen) { const w = wer(b); if (w && !personen.has(w)) personen.set(w, b.anzeige); }
|
||||
let filter = merke<string>("gantt-person") ?? "";
|
||||
if (filter && !personen.has(filter)) filter = "";
|
||||
const passt = (v: Zeile) => !filter || plan.besetzungen.some((b) => b.vorgang_id === v.id && wer(b) === filter);
|
||||
|
||||
leiste.innerHTML = `${Object.keys(ZOOM).map((z) => `<button class="neben${z === zoom ? " an" : ""}" data-zoom="${z}">${z[0]!.toUpperCase() + z.slice(1)}</button>`).join("")}
|
||||
<button class="neben" data-a="heute">Heute</button>
|
||||
<select data-a="person" title="Nur Vorgänge dieser Person zeigen"><option value="">Alle Personen</option>${[...personen].sort((a, b) => a[1].localeCompare(b[1], "de")).map(([id, name]) => `<option value="${esc(id)}"${id === filter ? " selected" : ""}>${esc(name)}</option>`).join("")}</select>
|
||||
<label class="schalter"><input type="checkbox" data-a="fertige"${mitFertigen ? " checked" : ""}> Abgeschlossene zeigen</label>
|
||||
<span class="hinweis">Balken ziehen verschiebt, rechter Rand ändert die Dauer. Freitag ist Reserve.</span>`;
|
||||
|
||||
const nummerVon = new Map<string, number>(plan.vorgaenge.map((v) => [v.id, v.nummer]));
|
||||
const idVon = new Map<number, string>(plan.vorgaenge.map((v) => [v.nummer, v.id]));
|
||||
const linksVon = (id: string) => plan.verknuepfungen.filter((k) => k.vorgang_id === id);
|
||||
|
||||
const projekte = plan.projekte.filter((p) => mitFertigen || p.status !== "abgeschlossen");
|
||||
const farbe = (p: Zeile, i: number) => (/^#[0-9a-f]{6}$/i.test(p.farbe ?? "") ? p.farbe : FARBEN[i % FARBEN.length]);
|
||||
|
||||
// Zeitraum: vom frühesten Vorgang (oder heute) bis zum spätesten plus Luft
|
||||
const heute = new Date().toISOString().slice(0, 10);
|
||||
const sichtbar = plan.vorgaenge.filter((v) => projekte.some((p) => plan.abschnitte.some((a) => a.id === v.abschnitt_id && a.projekt_id === p.id)));
|
||||
let von = montagDerWoche(plusTage(sichtbar.reduce((m, v) => (v.anfang < m ? v.anfang : m), heute), -7));
|
||||
let bis = plusTage(sichtbar.reduce((m, v) => (v.ende > m ? v.ende : m), plusTage(heute, 30)), 21);
|
||||
const minTage = zoom === "monat" ? 400 : zoom === "woche" ? 160 : 0;
|
||||
if (tageZwischen(von, bis) + 1 < minTage) bis = plusTage(von, minTage - 1);
|
||||
const W = ZOOM[zoom]!;
|
||||
const tage = tageZwischen(von, bis) + 1;
|
||||
const x = (d: Datum) => tageZwischen(von, d) * W;
|
||||
|
||||
// Besetzung (T14): Kürzel je Vorgang, vorgemerkte (noch nicht freigegebene) gestrichelt
|
||||
const besetzungVon = (id: string) => plan.besetzungen.filter((b) => b.vorgang_id === id);
|
||||
const leuteHtml = (id: string) => besetzungVon(id).map((b) =>
|
||||
`<span class="person${b.freigegeben ? "" : " vorgemerkt"}" title="${esc(b.anzeige)}${Number(b.personen) !== 1 ? `, ${String(b.personen).replace(".", ",")} Personen` : ""}${b.freigegeben ? "" : " (vorgemerkt, noch nicht freigegeben)"}">${esc(b.kurz)}${Number(b.personen) !== 1 ? ` ×${String(b.personen).replace(".", ",")}` : ""}</span>`).join("");
|
||||
const imKonflikt = new Set(plan.ueberschneidungen.flatMap((u) => [u.vorgang_a, u.vorgang_b]));
|
||||
|
||||
// Zeilen aufbauen
|
||||
type Reihe = { art: "p" | "a" | "v"; obj: Zeile; projekt: Zeile; farbe: string; von?: Datum; bis?: Datum };
|
||||
const reihen: Reihe[] = [];
|
||||
projekte.forEach((p, i) => {
|
||||
const f = farbe(p, i);
|
||||
const abs = plan.abschnitte.filter((a) => a.projekt_id === p.id);
|
||||
const vs = plan.vorgaenge.filter((v) => abs.some((a) => a.id === v.abschnitt_id) && passt(v));
|
||||
if (filter && !vs.length) return;
|
||||
const spanne = (l: Zeile[]) => (l.length ? { von: l.reduce((m, v) => (v.anfang < m ? v.anfang : m), l[0]!.anfang), bis: l.reduce((m, v) => (v.ende > m ? v.ende : m), l[0]!.ende) } : {});
|
||||
reihen.push({ art: "p", obj: p, projekt: p, farbe: f, ...spanne(vs) });
|
||||
if (zu.has(p.id)) return;
|
||||
for (const a of abs) {
|
||||
const av = vs.filter((v) => v.abschnitt_id === a.id);
|
||||
if (filter && !av.length) continue;
|
||||
reihen.push({ art: "a", obj: a, projekt: p, farbe: f, ...spanne(av) });
|
||||
if (zu.has(a.id)) continue;
|
||||
for (const v of av) reihen.push({ art: "v", obj: v, projekt: p, farbe: f, von: v.anfang, bis: v.ende });
|
||||
}
|
||||
});
|
||||
const zeileVon = new Map<string, number>();
|
||||
reihen.forEach((r, i) => zeileVon.set(r.obj.id, i));
|
||||
|
||||
// Kopf: Monate, Kalenderwochen, Tage
|
||||
let monate = "", kw = "", tagKopf = "", schatten = "";
|
||||
for (let i = 0, mStart = 0, wStart = 0; i < tage; i++) {
|
||||
const d = plusTage(von, i);
|
||||
const naechster = plusTage(d, 1);
|
||||
if (naechster.slice(0, 7) !== d.slice(0, 7) || i === tage - 1) {
|
||||
const n = i - mStart + 1;
|
||||
monate += `<div style="width:${n * W}px">${n * W > 50 ? `${MONATE[Number(d.slice(5, 7)) - 1]} ${d.slice(0, 4)}` : ""}</div>`;
|
||||
mStart = i + 1;
|
||||
}
|
||||
if (wochentag(naechster) === 1 || i === tage - 1) {
|
||||
const n = i - wStart + 1;
|
||||
kw += `<div style="width:${n * W}px">${n * W > 34 ? `KW ${kalenderwoche(d)}` : ""}</div>`;
|
||||
wStart = i + 1;
|
||||
}
|
||||
const ft = feiertag(d);
|
||||
const frei = !istArbeitstag(d, woche);
|
||||
const freitag = wochentag(d) === 5 && !ft;
|
||||
const klasse = ft ? "feiertag" : freitag ? "reserve" : frei ? "frei" : "";
|
||||
const titel = ft ? ft.name : freitag ? "Freitag: Reserve und Bürotag" : "";
|
||||
tagKopf += `<div class="${klasse}" style="width:${W}px"${titel ? ` title="${esc(titel)}"` : ""}>${W >= 18 ? Number(d.slice(8)) : ""}</div>`;
|
||||
if (klasse) schatten += `<i class="${klasse}" style="left:${i * W}px;width:${W}px"></i>`;
|
||||
}
|
||||
if (heute >= von && heute <= bis) schatten += `<i class="heute" style="left:${x(heute) + W / 2}px"></i>`;
|
||||
|
||||
// Linke Spalten und Balken je Zeile
|
||||
const zeilenHtml = reihen.map((r, i) => {
|
||||
const o = r.obj;
|
||||
let links = "", balken = "";
|
||||
const datumZelle = (d?: Datum) => `<span class="dat">${d ? formatDatum(d).slice(0, 6) + d.slice(2, 4) : "–"}</span>`;
|
||||
if (r.art === "p") {
|
||||
links = `<span class="griff" draggable="true" data-zieh="${o.id}" title="Ziehen, um die Reihenfolge zu ändern">⋮⋮</span>
|
||||
<button class="klapp" data-klapp="${o.id}">${zu.has(o.id) ? "▸" : "▾"}</button>
|
||||
<span class="name" title="${esc(o.bezeichnung)}"><b>${esc(o.nummer)}</b> ${esc(o.bezeichnung)}${o.bauherr ? ` <small>${esc(o.bauherr)}</small>` : ""}</span>
|
||||
${datumZelle(r.von)}${datumZelle(r.bis)}<span class="at">${r.von ? arbeitstageZwischen(r.von, r.bis!, woche) : ""}</span><span class="vg"></span><span></span>
|
||||
<button class="plus" data-neu-abschnitt="${o.id}" title="Abschnitt hinzufügen">+</button>`;
|
||||
if (r.von) balken = `<div class="balken projekt" style="left:${x(r.von)}px;width:${(tageZwischen(r.von, r.bis!) + 1) * W}px;background:${r.farbe}"></div>`;
|
||||
} else if (r.art === "a") {
|
||||
links = `<span></span><button class="klapp" data-klapp="${o.id}">${zu.has(o.id) ? "▸" : "▾"}</button>
|
||||
<span class="name abschnitt" data-abschnitt="${o.id}" title="Umbenennen">${esc(o.name)}</span>
|
||||
${datumZelle(r.von)}${datumZelle(r.bis)}<span class="at">${r.von ? arbeitstageZwischen(r.von, r.bis!, woche) : ""}</span><span class="vg"></span><span></span>
|
||||
<button class="plus" data-neu-vorgang="${o.id}" title="Vorgang hinzufügen">+</button>`;
|
||||
if (r.von) balken = `<div class="balken abschnitt" style="left:${x(r.von)}px;width:${(tageZwischen(r.von, r.bis!) + 1) * W}px;background:${r.farbe}"></div>`;
|
||||
} else {
|
||||
const ms = Number(o.dauer) === 0;
|
||||
links = `<span class="nr">${o.nummer}</span><span></span>
|
||||
<span class="name vorgang" data-vorgang="${o.id}" title="Bearbeiten">${esc(o.name)}</span>
|
||||
${datumZelle(o.anfang)}${datumZelle(o.ende)}<span class="at">${ms ? "◆" : Math.ceil(o.dauer)}</span>
|
||||
<span class="vg" title="Vorgänger">${esc(vorgaengerText(linksVon(o.id), nummerVon))}</span>
|
||||
<span class="leute" data-besetzung="${o.id}" title="Besetzung bearbeiten">${leuteHtml(o.id) || '<span class="leer">+ Personal</span>'}</span><span></span>`;
|
||||
const breite = (tageZwischen(o.anfang, o.ende) + 1) * W;
|
||||
const konflikt = imKonflikt.has(o.id) ? " konflikt" : "";
|
||||
const nachBalken = leuteHtml(o.id) ? `<div class="balken-leute" style="left:${x(o.ende) + W + 6}px">${leuteHtml(o.id)}</div>` : "";
|
||||
balken = nachBalken + (ms
|
||||
? `<div class="balken meilenstein" data-bar="${o.id}" style="left:${x(o.anfang) + W / 2 - 7}px;background:${r.farbe}" title="${esc(o.name)} · ${formatDatum(o.anfang)}"></div>`
|
||||
: `<div class="balken vorgang${konflikt}" data-bar="${o.id}" style="left:${x(o.anfang)}px;width:${breite}px;background:${r.farbe}" title="${esc(o.name)} · ${formatDatum(o.anfang)} – ${formatDatum(o.ende)} · ${Math.ceil(o.dauer)} AT">${breite > 40 ? `${Math.ceil(o.dauer)} AT` : ""}<i class="griff-rechts" data-dauer="${o.id}"></i></div>`);
|
||||
}
|
||||
return `<div class="g-zeile ${r.art}" style="top:${i * ZEILE}px"><div class="g-links" style="box-shadow:inset 4px 0 0 ${r.art === "p" ? r.farbe : "transparent"}">${links}</div></div>
|
||||
<div class="g-balken" style="top:${i * ZEILE}px">${balken}</div>`;
|
||||
}).join("");
|
||||
|
||||
// Pfeile für die Verknüpfungen
|
||||
const pfeile = plan.verknuepfungen.map((k) => {
|
||||
const a = plan.vorgaenge.find((v) => v.id === k.vorgaenger_id);
|
||||
const b = plan.vorgaenge.find((v) => v.id === k.vorgang_id);
|
||||
const ya = zeileVon.get(k.vorgaenger_id), yb = zeileVon.get(k.vorgang_id);
|
||||
if (!a || !b || ya === undefined || yb === undefined) return "";
|
||||
const vonAnfang = k.art === "AA" || k.art === "AE", zuEnde = k.art === "EE" || k.art === "AE";
|
||||
const x1 = vonAnfang ? x(a.anfang) : x(a.ende) + W, x2 = zuEnde ? x(b.ende) + W : x(b.anfang);
|
||||
const y1 = ya * ZEILE + ZEILE / 2, y2 = yb * ZEILE + ZEILE / 2;
|
||||
const knick = vonAnfang ? Math.min(x1, x2) - 8 : zuEnde ? Math.max(x1, x2) + 8 : x1 + 6;
|
||||
const spitze = zuEnde ? `${x2},${y2} ${x2 + 5},${y2 - 3} ${x2 + 5},${y2 + 3}` : `${x2},${y2} ${x2 - 5},${y2 - 3} ${x2 - 5},${y2 + 3}`;
|
||||
return `<path d="M${x1} ${y1}H${knick}V${y2}H${x2}"/><polygon points="${spitze}"/>`;
|
||||
}).join("");
|
||||
|
||||
const hoehe = reihen.length * ZEILE;
|
||||
const box = document.createElement("div");
|
||||
box.className = "gantt";
|
||||
box.innerHTML = `<div class="g-inhalt" style="width:calc(var(--links) + ${tage * W}px)">
|
||||
<div class="g-kopf"><div class="g-links kopf"><span>Nr.</span><span></span><span>Projekt / Vorgang</span><span>Start</span><span>Ende</span><span>AT</span><span>Vorgänger</span><span>Personal</span><span></span></div>
|
||||
<div class="g-zeit"><div class="reihe">${monate}</div><div class="reihe">${kw}</div><div class="reihe tage">${tagKopf}</div></div></div>
|
||||
<div class="g-koerper" style="height:${hoehe}px">
|
||||
<div class="g-schatten" style="width:${tage * W}px">${schatten}</div>
|
||||
<svg class="g-pfeile" width="${tage * W}" height="${hoehe}">${pfeile}</svg>
|
||||
${zeilenHtml}
|
||||
</div></div>
|
||||
${reihen.length ? "" : '<p class="hinweis" style="padding:16px">Noch keine Projekte im Terminplan.</p>'}`;
|
||||
if (plan.ueberschneidungen.length) {
|
||||
const vName = (id: string) => {
|
||||
const v = plan.vorgaenge.find((x) => x.id === id)!;
|
||||
const p = plan.projekte.find((p) => plan.abschnitte.some((a) => a.id === v.abschnitt_id && a.projekt_id === p.id));
|
||||
return `${p ? p.nummer + " " : ""}${v.name}`;
|
||||
};
|
||||
inhalt.insertAdjacentHTML("beforeend", `<div class="warnung"><b>Terminüberschneidung</b><ul>${plan.ueberschneidungen.map((u) =>
|
||||
`<li>${esc(u.name)} ab ${formatDatum(u.ab)}: ${esc(vName(u.vorgang_a))} und ${esc(vName(u.vorgang_b))}</li>`).join("")}</ul></div>`);
|
||||
}
|
||||
inhalt.appendChild(box);
|
||||
|
||||
const linksBreite = () => box.querySelector<HTMLElement>(".g-kopf .g-links")?.offsetWidth ?? 0;
|
||||
const nachHeute = () => (box.scrollLeft = Math.max(0, x(heute) - (box.clientWidth - linksBreite()) / 3));
|
||||
const gespeichert = merke<number>("gantt-scroll");
|
||||
if (gespeichert !== undefined) box.scrollLeft = gespeichert; else nachHeute();
|
||||
box.addEventListener("scroll", () => merke("gantt-scroll", box.scrollLeft), { passive: true });
|
||||
const neuLaden = () => terminplanSeite(h);
|
||||
|
||||
leiste.addEventListener("click", (ev) => {
|
||||
const b = (ev.target as HTMLElement).closest("button");
|
||||
if (b?.dataset.zoom) { merke("gantt-zoom", b.dataset.zoom); merke("gantt-scroll", null as unknown as number); neuLaden(); }
|
||||
if (b?.dataset.a === "heute") nachHeute();
|
||||
});
|
||||
leiste.querySelector<HTMLSelectElement>('[data-a="person"]')!.onchange = (ev) => { merke("gantt-person", (ev.target as HTMLSelectElement).value); neuLaden(); };
|
||||
leiste.querySelector<HTMLInputElement>('[data-a="fertige"]')!.onchange = (ev) => { merke("gantt-fertige", (ev.target as HTMLInputElement).checked); neuLaden(); };
|
||||
|
||||
// Klicks in der linken Spalte
|
||||
box.addEventListener("click", async (ev) => {
|
||||
const t = ev.target as HTMLElement;
|
||||
if (t.dataset.klapp) {
|
||||
zu.has(t.dataset.klapp) ? zu.delete(t.dataset.klapp) : zu.add(t.dataset.klapp);
|
||||
merke("gantt-zu", [...zu]);
|
||||
return neuLaden();
|
||||
}
|
||||
if (t.dataset.neuAbschnitt) {
|
||||
const r = await h.dialog("Neuer Abschnitt", [{ name: "name", titel: "Name", pflicht: true }], {}, false);
|
||||
if (r?.aktion !== "speichern") return;
|
||||
const reihenfolge = Math.max(0, ...plan.abschnitte.filter((a) => a.projekt_id === t.dataset.neuAbschnitt).map((a) => a.reihenfolge)) + 1;
|
||||
await api("abschnitte", "POST", { projekt_id: t.dataset.neuAbschnitt, name: r.daten.name, reihenfolge });
|
||||
zu.delete(t.dataset.neuAbschnitt);
|
||||
return neuLaden();
|
||||
}
|
||||
if (t.dataset.neuVorgang) return vorgangDialog(null, t.dataset.neuVorgang);
|
||||
const besetzungId = t.closest<HTMLElement>("[data-besetzung]")?.dataset.besetzung;
|
||||
if (besetzungId) return besetzungDialog(plan.vorgaenge.find((v) => v.id === besetzungId)!);
|
||||
const abschnittId = t.closest<HTMLElement>("[data-abschnitt]")?.dataset.abschnitt;
|
||||
if (abschnittId) {
|
||||
const a = plan.abschnitte.find((x) => x.id === abschnittId)!;
|
||||
const r = await h.dialog("Abschnitt", [{ name: "name", titel: "Name", pflicht: true }], a, true);
|
||||
if (r?.aktion === "loeschen") await api(`abschnitte/${a.id}`, "DELETE");
|
||||
else if (r?.aktion === "speichern") await api(`abschnitte/${a.id}`, "PATCH", { name: r.daten.name });
|
||||
if (r) neuLaden();
|
||||
return;
|
||||
}
|
||||
const vorgangId = t.closest<HTMLElement>("[data-vorgang]")?.dataset.vorgang;
|
||||
if (vorgangId) vorgangDialog(plan.vorgaenge.find((v) => v.id === vorgangId)!, null);
|
||||
});
|
||||
|
||||
// Besetzung bearbeiten: Liste mit Freigabe, darunter Person oder Platzhalter hinzufügen
|
||||
function besetzungDialog(v: Zeile): void {
|
||||
const huelle = document.getElementById("dialog-huelle")!;
|
||||
const zeichne = () => {
|
||||
const liste = besetzungVon(v.id);
|
||||
huelle.innerHTML = `<div class="dialog besetzung"><h2>Besetzung: ${esc(v.name)}</h2>
|
||||
<p class="hinweis">${formatDatum(v.anfang)} – ${formatDatum(v.ende)}</p>
|
||||
${liste.length ? `<table><tbody>${liste.map((b) => `<tr><td>${esc(b.anzeige)}${b.rolle ? ` <small class="hinweis">${b.rolle === "mitarbeiter" ? "Mitarbeiter" : "Subunternehmer"}</small>` : ""}</td>
|
||||
<td class="zahl">${String(b.personen).replace(".", ",")} P.</td>
|
||||
<td>${b.rolle === "mitarbeiter" ? "" : `<label class="schalter"><input type="checkbox" data-frei="${b.id}"${b.freigegeben ? " checked" : ""}> freigegeben</label>`}</td>
|
||||
<td><button class="neben" data-weg="${b.id}" title="Entfernen">×</button></td></tr>`).join("")}</tbody></table>` : '<p class="hinweis">Noch niemand eingeteilt.</p>'}
|
||||
<label for="b-wer">Hinzufügen</label>
|
||||
<select id="b-wer"><option value="">– auswählen –</option>
|
||||
${plan.leute.map((k) => `<option value="${k.id}">${esc(k.rolle === "subunternehmer" && k.firma ? k.firma : k.name)} (${k.rolle === "mitarbeiter" ? "Mitarbeiter" : "Subunternehmer"})</option>`).join("")}
|
||||
<option value="platzhalter">Platzhalter, z. B. N.N. oder Kolonne 2 …</option></select>
|
||||
<input id="b-platzhalter" placeholder="Name des Platzhalters" hidden>
|
||||
<label for="b-personen">Personen</label><input id="b-personen" value="1" inputmode="decimal">
|
||||
<p class="hinweis">Subunternehmer und Platzhalter sind vorgemerkt, bis du sie freigibst. Mitarbeiter und Subunternehmer legst du unter Kontakte an.</p>
|
||||
<p class="fehler" id="b-fehler"></p>
|
||||
<div class="knoepfe"><button class="neben" data-a="zu">Fertig</button><button class="haupt" data-a="dazu">Hinzufügen</button></div></div>`;
|
||||
huelle.hidden = false;
|
||||
const wahl = huelle.querySelector<HTMLSelectElement>("#b-wer")!;
|
||||
wahl.onchange = () => (huelle.querySelector<HTMLInputElement>("#b-platzhalter")!.hidden = wahl.value !== "platzhalter");
|
||||
};
|
||||
const neu = async () => { Object.assign(plan, await api<Plan>("terminplan")); zeichne(); };
|
||||
zeichne();
|
||||
const schliessen = () => { huelle.hidden = true; huelle.innerHTML = ""; huelle.onclick = huelle.onchange = null; neuLaden(); };
|
||||
huelle.onclick = async (ev) => {
|
||||
const t = ev.target as HTMLElement;
|
||||
try {
|
||||
if (t.dataset.a === "zu") return schliessen();
|
||||
if (t.dataset.weg) { await api(`besetzungen/${t.dataset.weg}`, "DELETE"); return neu(); }
|
||||
if (t.dataset.a === "dazu") {
|
||||
const w = huelle.querySelector<HTMLSelectElement>("#b-wer")!.value;
|
||||
const platzhalter = huelle.querySelector<HTMLInputElement>("#b-platzhalter")!.value.trim();
|
||||
const personen = Number(huelle.querySelector<HTMLInputElement>("#b-personen")!.value.replace(",", "."));
|
||||
if (!w || (w === "platzhalter" && !platzhalter)) throw new Error("Bitte eine Person oder einen Platzhalter wählen.");
|
||||
if (!(personen > 0)) throw new Error("Personen muss größer als 0 sein.");
|
||||
await api("besetzungen", "POST", { vorgang_id: v.id, personen, ...(w === "platzhalter" ? { platzhalter } : { kontakt_id: w }) });
|
||||
return neu();
|
||||
}
|
||||
} catch (e) {
|
||||
huelle.querySelector("#b-fehler")!.textContent = (e as Error).message;
|
||||
}
|
||||
};
|
||||
huelle.onchange = async (ev) => {
|
||||
const t = ev.target as HTMLInputElement;
|
||||
if (t.dataset.frei) { await api(`besetzungen/${t.dataset.frei}`, "PATCH", { freigegeben: t.checked }); neu(); }
|
||||
};
|
||||
}
|
||||
|
||||
async function vorgangDialog(v: Zeile | null, abschnittId: string | null): Promise<void> {
|
||||
const geschwister = plan.vorgaenge.filter((x) => x.abschnitt_id === (v?.abschnitt_id ?? abschnittId));
|
||||
const letzter = geschwister[geschwister.length - 1];
|
||||
const vorschlag = letzter ? naechsterArbeitstag(plusTage(letzter.ende, 1), woche) : naechsterArbeitstag(heute, woche);
|
||||
const werte = v
|
||||
? { name: v.name, start: v.anfang, dauer: String(Math.ceil(v.dauer)), vorgaenger: vorgaengerText(linksVon(v.id), nummerVon) }
|
||||
: { name: "", start: vorschlag, dauer: "5", vorgaenger: letzter ? String(letzter.nummer) : "" };
|
||||
const r = await h.dialog(v ? `Vorgang ${v.nummer}` : "Neuer Vorgang", [
|
||||
{ name: "name", titel: "Bezeichnung", pflicht: true },
|
||||
{ name: "start", titel: "Start", art: "datum", pflicht: true },
|
||||
{ name: "dauer", titel: "Dauer in Arbeitstagen (0 = Meilenstein)", art: "zahl", pflicht: true },
|
||||
{ name: "vorgaenger", titel: "Vorgänger: Nummer, Art und Verzögerung, z. B. 1003, 1005 AA+2" },
|
||||
], werte, !!v);
|
||||
if (!r) return;
|
||||
if (r.aktion === "loeschen") { await api(`vorgaenge/${v!.id}`, "DELETE"); return neuLaden(); }
|
||||
const neu = leseVorgaenger(r.daten.vorgaenger ?? "", idVon);
|
||||
const dauer = Math.max(0, Math.round(Number(r.daten.dauer)));
|
||||
let id = v?.id;
|
||||
if (v) await api(`vorgaenge/${v.id}`, "PATCH", { name: r.daten.name, start: r.daten.start, dauer });
|
||||
else id = (await api<Zeile>("vorgaenge", "POST", { abschnitt_id: abschnittId, name: r.daten.name, start: r.daten.start, dauer, reihenfolge: geschwister.length + 1 })).id;
|
||||
// Verknüpfungen abgleichen: entfernte löschen, geänderte anpassen, neue anlegen
|
||||
const alt = id ? linksVon(id) : [];
|
||||
for (const k of alt) if (!neu.some((n) => n.vorgaenger_id === k.vorgaenger_id)) await api(`verknuepfungen/${k.id}`, "DELETE");
|
||||
for (const n of neu) {
|
||||
const k = alt.find((a) => a.vorgaenger_id === n.vorgaenger_id);
|
||||
if (!k) await api("verknuepfungen", "POST", { vorgang_id: id, ...n });
|
||||
else if (k.art !== n.art || k.verzoegerung !== n.verzoegerung) await api(`verknuepfungen/${k.id}`, "PATCH", { art: n.art, verzoegerung: n.verzoegerung });
|
||||
}
|
||||
neuLaden();
|
||||
}
|
||||
|
||||
// Balken ziehen: verschieben oder (rechter Griff) Dauer ändern
|
||||
box.addEventListener("pointerdown", (ev) => {
|
||||
const t = ev.target as HTMLElement;
|
||||
const bar = t.closest<HTMLElement>("[data-bar]");
|
||||
if (!bar || ev.button !== 0) return;
|
||||
const v = plan.vorgaenge.find((x) => x.id === bar.dataset.bar)!;
|
||||
const dauerAendern = !!t.dataset.dauer;
|
||||
const startX = ev.clientX;
|
||||
const links0 = bar.offsetLeft, breite0 = bar.offsetWidth;
|
||||
let bewegt = false;
|
||||
bar.setPointerCapture(ev.pointerId);
|
||||
bar.classList.add("zieht");
|
||||
const tage = (e: PointerEvent) => Math.round((e.clientX - startX) / W);
|
||||
const zieh = (e: PointerEvent) => {
|
||||
const n = tage(e);
|
||||
if (n !== 0) bewegt = true;
|
||||
if (dauerAendern) bar.style.width = `${Math.max(W, breite0 + n * W)}px`;
|
||||
else bar.style.left = `${links0 + n * W}px`;
|
||||
};
|
||||
const los = async (e: PointerEvent) => {
|
||||
bar.removeEventListener("pointermove", zieh);
|
||||
bar.classList.remove("zieht");
|
||||
const n = tage(e);
|
||||
if (!bewegt || n === 0) { if (!bewegt) vorgangDialog(v, null); return; }
|
||||
if (dauerAendern) {
|
||||
const neuesEnde = plusTage(v.ende, n);
|
||||
const dauer = Math.max(1, arbeitstageZwischen(v.anfang, neuesEnde < v.anfang ? v.anfang : neuesEnde, woche));
|
||||
await api(`vorgaenge/${v.id}`, "PATCH", { dauer });
|
||||
} else {
|
||||
const ziel = plusTage(v.anfang, n);
|
||||
await api(`vorgaenge/${v.id}`, "PATCH", { start: n > 0 ? naechsterArbeitstag(ziel, woche) : vorherigerArbeitstag(ziel, woche) });
|
||||
}
|
||||
neuLaden();
|
||||
};
|
||||
bar.addEventListener("pointermove", zieh);
|
||||
bar.addEventListener("pointerup", los, { once: true });
|
||||
});
|
||||
|
||||
// Projekte per Drag & Drop umsortieren (T1)
|
||||
let gezogen: string | null = null;
|
||||
box.addEventListener("dragstart", (ev) => { gezogen = (ev.target as HTMLElement).dataset.zieh ?? null; });
|
||||
box.addEventListener("dragover", (ev) => { if (gezogen && (ev.target as HTMLElement).closest(".g-zeile.p")) ev.preventDefault(); });
|
||||
box.addEventListener("drop", async (ev) => {
|
||||
const ziel = (ev.target as HTMLElement).closest(".g-zeile.p")?.querySelector<HTMLElement>("[data-zieh]")?.dataset.zieh;
|
||||
if (!gezogen || !ziel || ziel === gezogen) return;
|
||||
ev.preventDefault();
|
||||
const ids = plan.projekte.map((p) => p.id).filter((id) => id !== gezogen);
|
||||
ids.splice(ids.indexOf(ziel), 0, gezogen);
|
||||
await Promise.all(ids.map((id, i) => (plan.projekte.find((p) => p.id === id)!.reihenfolge !== i ? api(`projekte/${id}`, "PATCH", { reihenfolge: i }) : null)));
|
||||
gezogen = null;
|
||||
neuLaden();
|
||||
});
|
||||
}
|
||||
|
||||
function vorherigerArbeitstag(d: Datum, woche: Arbeitswoche): Datum {
|
||||
let x = d;
|
||||
while (!istArbeitstag(x, woche)) x = plusTage(x, -1);
|
||||
return x;
|
||||
}
|
||||
|
||||
function kalenderwoche(d: Datum): number {
|
||||
const t = new Date(`${d}T00:00:00Z`);
|
||||
t.setUTCDate(t.getUTCDate() + 4 - (t.getUTCDay() || 7));
|
||||
const jahresanfang = Date.UTC(t.getUTCFullYear(), 0, 1);
|
||||
return Math.ceil(((t.getTime() - jahresanfang) / 86400000 + 1) / 7);
|
||||
}
|
||||
@@ -5,13 +5,14 @@
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1">
|
||||
<title>Betrieb · Schaarschmidt Holzbau</title>
|
||||
<link rel="stylesheet" href="/styles.css">
|
||||
<link rel="icon" href="/bilder/logo.png">
|
||||
</head>
|
||||
<body>
|
||||
<header>
|
||||
<strong>Schaarschmidt Holzbau</strong>
|
||||
<aside id="seitenleiste">
|
||||
<div id="marke"><img src="/bilder/logo.png" alt="Holzbau Schaarschmidt"></div>
|
||||
<nav id="reiter"></nav>
|
||||
<span id="version"></span>
|
||||
</header>
|
||||
</aside>
|
||||
<main id="inhalt"></main>
|
||||
<div id="dialog-huelle" hidden></div>
|
||||
<script type="module" src="/app.js"></script>
|
||||
|
||||
@@ -1,37 +1,212 @@
|
||||
/* Aufbau ähnlich Plancraft (Henning, 19.10.2026): dunkle Seitenleiste, helle Fläche,
|
||||
weiße Karten, farbige Status-Etiketten. Farben: Blautöne, dazu die Markenfarbe aus dem Logo
|
||||
(--marke dunkles Braun, --holz helles Braun) für Logo und Markierungen. */
|
||||
:root {
|
||||
--bg: #f6f5f2; --fl: #ffffff; --text: #1f1f1d; --leise: #6b6a65; --linie: #dedcd5;
|
||||
--akzent: #8a4b14; --akzent-text: #ffffff; --warn: #b42318;
|
||||
--marke: #451e0c; --holz: #a26e3a;
|
||||
--leiste: #13294a; --leiste-text: #b9c7da; --leiste-aktiv: #234a7c;
|
||||
--bg: #f2f4f8; --fl: #ffffff; --text: #18202c; --leise: #5f6b7a; --linie: #e0e5ec;
|
||||
--akzent: #1d5fa8; --akzent-hover: #174d89; --akzent-text: #ffffff; --akzent-hell: #e4eefa;
|
||||
--warn: #b42318;
|
||||
font-family: system-ui, -apple-system, "Segoe UI", sans-serif; font-size: 15px;
|
||||
}
|
||||
@media (prefers-color-scheme: dark) {
|
||||
:root { --bg: #1b1b1a; --fl: #262624; --text: #ecebe6; --leise: #a3a29b; --linie: #3a3936; --akzent: #d9893f; --akzent-text: #1b1b1a; --warn: #f97066; }
|
||||
:root {
|
||||
--leiste: #0d1a2e; --leiste-aktiv: #1d3a62;
|
||||
--bg: #111822; --fl: #1a2331; --text: #e8edf4; --leise: #9aa7b8; --linie: #2b3747;
|
||||
--akzent: #5a9be0; --akzent-hover: #78b0ea; --akzent-text: #0d1a2e; --akzent-hell: #1d3352; --warn: #f97066;
|
||||
}
|
||||
}
|
||||
* { box-sizing: border-box; }
|
||||
body { margin: 0; background: var(--bg); color: var(--text); }
|
||||
header { display: flex; gap: 16px; align-items: center; flex-wrap: wrap; padding: 10px 16px; background: var(--fl); border-bottom: 1px solid var(--linie); }
|
||||
header nav { display: flex; gap: 4px; flex-wrap: wrap; flex: 1; }
|
||||
header nav button { background: none; border: 0; padding: 6px 10px; border-radius: 6px; color: var(--leise); cursor: pointer; font: inherit; }
|
||||
header nav button.aktiv { background: var(--bg); color: var(--text); font-weight: 600; }
|
||||
#version { color: var(--leise); font-size: 12px; }
|
||||
main { padding: 16px; max-width: 1200px; margin: 0 auto; }
|
||||
h1 { font-size: 20px; margin: 4px 0 16px; }
|
||||
.leiste { display: flex; gap: 8px; margin-bottom: 12px; align-items: center; }
|
||||
button.haupt { background: var(--akzent); color: var(--akzent-text); border: 0; border-radius: 6px; padding: 7px 14px; font: inherit; cursor: pointer; }
|
||||
button.neben { background: var(--fl); color: var(--text); border: 1px solid var(--linie); border-radius: 6px; padding: 6px 12px; font: inherit; cursor: pointer; }
|
||||
table { width: 100%; border-collapse: collapse; background: var(--fl); border: 1px solid var(--linie); border-radius: 8px; overflow: hidden; }
|
||||
th, td { text-align: left; padding: 7px 10px; border-bottom: 1px solid var(--linie); }
|
||||
th { font-size: 12px; color: var(--leise); font-weight: 600; }
|
||||
body { margin: 0; background: var(--bg); color: var(--text); display: flex; min-height: 100vh; }
|
||||
|
||||
/* Seitenleiste */
|
||||
#seitenleiste { width: 200px; flex: none; background: var(--leiste); color: var(--leiste-text); display: flex; flex-direction: column; padding: 14px 10px; position: sticky; top: 0; height: 100vh; }
|
||||
#marke { background: #fff; border-radius: 10px; padding: 10px 14px; margin: 0 4px 18px; display: grid; place-items: center; }
|
||||
#marke img { width: 96px; height: auto; display: block; }
|
||||
#reiter { display: flex; flex-direction: column; gap: 2px; flex: 1; }
|
||||
#reiter button { display: flex; align-items: center; gap: 11px; background: none; border: 0; padding: 9px 10px; border-radius: 8px; color: inherit; cursor: pointer; font: inherit; text-align: left; }
|
||||
#reiter button svg { width: 19px; height: 19px; flex: none; }
|
||||
#reiter button:hover { background: rgb(255 255 255 / 0.06); color: #fff; }
|
||||
#reiter button.aktiv { background: var(--leiste-aktiv); color: #fff; font-weight: 600; box-shadow: inset 3px 0 0 var(--holz); }
|
||||
#version { font-size: 12px; padding: 8px 10px 0; opacity: 0.7; }
|
||||
|
||||
/* Inhalt */
|
||||
main { flex: 1; min-width: 0; padding: 22px 28px; max-width: 1280px; }
|
||||
.kopf { display: flex; align-items: center; gap: 12px; margin-bottom: 18px; flex-wrap: wrap; }
|
||||
.kopf h1 { font-size: 24px; margin: 0; flex: 1; color: var(--text); }
|
||||
h2 { font-size: 16px; margin: 26px 0 10px; }
|
||||
.leiste { display: flex; gap: 8px; margin-bottom: 14px; align-items: center; flex-wrap: wrap; }
|
||||
.leiste select, .leiste input { padding: 8px 10px; border: 1px solid var(--linie); border-radius: 8px; background: var(--fl); color: var(--text); font: inherit; }
|
||||
button.haupt { background: var(--akzent); color: var(--akzent-text); border: 0; border-radius: 8px; padding: 10px 18px; font: inherit; font-weight: 600; cursor: pointer; }
|
||||
button.haupt:hover { background: var(--akzent-hover); }
|
||||
button.neben, a.neben { display: inline-block; background: var(--fl); color: var(--text); border: 1px solid var(--linie); border-radius: 8px; padding: 8px 14px; font: inherit; cursor: pointer; text-decoration: none; }
|
||||
button.neben:hover, a.neben:hover { border-color: var(--leise); }
|
||||
|
||||
/* Tabellen als Karte */
|
||||
table { width: 100%; border-collapse: separate; border-spacing: 0; background: var(--fl); border: 1px solid var(--linie); border-radius: 10px; overflow: hidden; }
|
||||
th, td { text-align: left; padding: 13px 16px; border-bottom: 1px solid var(--linie); vertical-align: middle; }
|
||||
tbody tr:last-child td { border-bottom: 0; }
|
||||
th { font-size: 13px; color: var(--leise); font-weight: 600; }
|
||||
td.zahl, th.zahl { text-align: right; font-variant-numeric: tabular-nums; }
|
||||
td .unter { display: block; color: var(--leise); font-size: 13px; margin-top: 2px; }
|
||||
tr.klickbar { cursor: pointer; }
|
||||
tr.klickbar:hover td { background: var(--bg); }
|
||||
.nur-schmal { display: none; }
|
||||
td { overflow-wrap: break-word; }
|
||||
td.zahl { white-space: nowrap; }
|
||||
.anzahl { color: var(--leise); font-size: 13px; margin: 10px 2px; }
|
||||
|
||||
/* Status-Etiketten */
|
||||
.etikett { display: inline-block; padding: 4px 11px; border-radius: 999px; font-size: 13px; white-space: nowrap; background: #eef1f5; color: #4a5565; }
|
||||
.etikett.angebot { background: #e4eefa; color: #1d5fa8; }
|
||||
.etikett.auftrag { background: #d7ecfa; color: #0b5f96; }
|
||||
.etikett.ausfuehrung { background: #fcefc3; color: #7a5600; }
|
||||
.etikett.abgerechnet { background: #dcf1f4; color: #0f6674; }
|
||||
.etikett.gewaehrleistung { background: #e6e8fb; color: #3c47a8; }
|
||||
.etikett.abgeschlossen { background: #daf3e3; color: #19703f; }
|
||||
|
||||
.hinweis { color: var(--leise); }
|
||||
.fehler { color: var(--warn); }
|
||||
#dialog-huelle { position: fixed; inset: 0; background: rgb(0 0 0 / 0.35); display: grid; place-items: center; padding: 16px; }
|
||||
|
||||
/* Dialoge */
|
||||
#dialog-huelle { position: fixed; inset: 0; background: rgb(10 20 35 / 0.4); display: grid; place-items: center; padding: 16px; z-index: 10; }
|
||||
#dialog-huelle[hidden] { display: none; }
|
||||
.dialog { background: var(--fl); border-radius: 10px; padding: 18px; width: min(460px, 100%); box-shadow: 0 10px 30px rgb(0 0 0 / 0.25); }
|
||||
.dialog h2 { font-size: 17px; margin: 0 0 12px; }
|
||||
.dialog label { display: block; font-size: 12px; color: var(--leise); margin: 10px 0 3px; }
|
||||
.dialog input, .dialog select, .dialog textarea { width: 100%; padding: 7px 8px; border: 1px solid var(--linie); border-radius: 6px; background: var(--bg); color: var(--text); font: inherit; }
|
||||
.dialog .knoepfe { display: flex; justify-content: flex-end; gap: 8px; margin-top: 16px; }
|
||||
.dialog { background: var(--fl); border-radius: 12px; padding: 22px; width: min(480px, 100%); max-height: calc(100vh - 32px); overflow: auto; box-shadow: 0 12px 34px rgb(0 0 0 / 0.25); }
|
||||
.dialog h2 { font-size: 18px; margin: 0 0 14px; }
|
||||
.dialog label { display: block; font-size: 13px; color: var(--leise); margin: 12px 0 4px; }
|
||||
.dialog input, .dialog select, .dialog textarea { width: 100%; padding: 9px 10px; border: 1px solid var(--linie); border-radius: 8px; background: var(--fl); color: var(--text); font: inherit; }
|
||||
.dialog input:focus, .dialog select:focus, .dialog textarea:focus { outline: 2px solid var(--akzent-hell); border-color: var(--akzent); }
|
||||
.dialog .knoepfe { display: flex; justify-content: flex-end; gap: 8px; margin-top: 18px; }
|
||||
.dialog .knoepfe .links { margin-right: auto; }
|
||||
@media (max-width: 640px) { th.optional, td.optional { display: none; } }
|
||||
|
||||
/* Schmale Bildschirme: Leiste oben, waagerecht scrollbar */
|
||||
@media (max-width: 800px) {
|
||||
body { flex-direction: column; }
|
||||
#seitenleiste { width: auto; height: auto; position: static; flex-direction: row; align-items: center; padding: 8px; gap: 6px; overflow-x: auto; }
|
||||
#marke { padding: 4px 6px; margin: 0 4px 0 0; }
|
||||
#marke img { width: 34px; }
|
||||
#version { display: none; }
|
||||
#reiter { flex-direction: row; }
|
||||
#reiter button { padding: 8px 10px; white-space: nowrap; }
|
||||
main { padding: 16px; }
|
||||
th.optional, td.optional { display: none; }
|
||||
.nur-schmal { display: inline; }
|
||||
th, td { padding: 11px 10px; }
|
||||
td .unter { font-size: 12px; }
|
||||
}
|
||||
|
||||
/* Terminplan (Gantt) */
|
||||
button.neben.an { background: var(--akzent-hell); border-color: var(--akzent); color: var(--akzent); font-weight: 600; }
|
||||
.schalter { display: inline-flex; align-items: center; gap: 6px; color: var(--leise); font-size: 14px; }
|
||||
.leiste .hinweis { font-size: 13px; margin-left: auto; }
|
||||
.gantt { --links: 600px; overflow: auto; max-height: calc(100vh - 150px); background: var(--fl); border: 1px solid var(--linie); border-radius: 10px; position: relative; }
|
||||
.g-inhalt { position: relative; }
|
||||
.g-kopf { position: sticky; top: 0; z-index: 4; display: flex; background: var(--fl); border-bottom: 1px solid var(--linie); }
|
||||
.g-links { position: sticky; left: 0; z-index: 2; width: var(--links); flex: none; display: grid; grid-template-columns: 44px 22px 1fr 64px 64px 30px 80px 84px 24px; align-items: center; gap: 4px; padding: 0 6px 0 8px; height: 34px; background: var(--fl); border-right: 1px solid var(--linie); font-size: 13px; }
|
||||
.g-links.kopf { height: 63px; align-items: end; padding-bottom: 6px; font-size: 12px; color: var(--leise); font-weight: 600; z-index: 5; }
|
||||
.g-zeit .reihe { display: flex; height: 21px; font-size: 11px; color: var(--leise); }
|
||||
.g-zeit .reihe > div { border-left: 1px solid var(--linie); padding: 3px 4px; white-space: nowrap; overflow: hidden; flex: none; }
|
||||
.g-zeit .reihe.tage > div { padding: 3px 0; text-align: center; }
|
||||
.g-zeit .tage .frei, .g-zeit .tage .feiertag { color: var(--warn); }
|
||||
.g-zeit .tage .reserve { color: var(--holz); }
|
||||
.g-koerper { position: relative; }
|
||||
.g-zeile { position: absolute; left: 0; right: 0; height: 34px; border-bottom: 1px solid var(--linie); }
|
||||
.g-zeile.p .g-links { font-weight: 600; background: var(--bg); }
|
||||
.g-zeile.p { background: var(--bg); }
|
||||
.g-zeile .name { overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
|
||||
.g-zeile .name small { font-weight: 400; color: var(--leise); }
|
||||
.g-zeile.a .name { font-weight: 600; padding-left: 4px; cursor: pointer; }
|
||||
.g-zeile.v .name { padding-left: 18px; cursor: pointer; }
|
||||
.g-zeile .name.vorgang:hover, .g-zeile .name.abschnitt:hover { color: var(--akzent); text-decoration: underline; }
|
||||
.g-zeile .nr { color: var(--leise); font-variant-numeric: tabular-nums; }
|
||||
.g-zeile .dat, .g-zeile .at { font-variant-numeric: tabular-nums; color: var(--leise); }
|
||||
.g-zeile .vg { color: var(--leise); overflow: hidden; text-overflow: ellipsis; white-space: nowrap; font-size: 12px; }
|
||||
.g-links .klapp, .g-links .plus { background: none; border: 0; color: var(--leise); cursor: pointer; font: inherit; padding: 0; width: 22px; height: 22px; border-radius: 5px; }
|
||||
.g-links .plus { font-size: 17px; color: var(--akzent); }
|
||||
.g-links .klapp:hover, .g-links .plus:hover { background: var(--akzent-hell); }
|
||||
.g-links .griff { cursor: grab; color: var(--leise); user-select: none; text-align: center; }
|
||||
.g-balken { position: absolute; height: 34px; left: var(--links); right: 0; pointer-events: none; z-index: 1; }
|
||||
.balken { position: absolute; top: 9px; height: 16px; border-radius: 4px; color: #fff; font-size: 11px; line-height: 16px; padding-left: 5px; white-space: nowrap; overflow: hidden; pointer-events: auto; }
|
||||
.balken.projekt { top: 14px; height: 6px; padding: 0; pointer-events: none; }
|
||||
.balken.abschnitt { top: 12px; height: 10px; opacity: 0.55; padding: 0; pointer-events: none; }
|
||||
.balken.vorgang { cursor: grab; touch-action: none; box-shadow: 0 1px 2px rgb(0 0 0 / 0.2); }
|
||||
.balken.zieht { cursor: grabbing; opacity: 0.8; outline: 2px solid var(--akzent); }
|
||||
.balken .griff-rechts { position: absolute; right: 0; top: 0; bottom: 0; width: 7px; cursor: ew-resize; background: rgb(255 255 255 / 0.35); }
|
||||
.balken.meilenstein { width: 14px; height: 14px; top: 10px; transform: rotate(45deg); border-radius: 2px; padding: 0; cursor: grab; touch-action: none; }
|
||||
.g-schatten { position: absolute; top: 0; bottom: 0; left: var(--links); }
|
||||
.g-schatten i { position: absolute; top: 0; bottom: 0; }
|
||||
.g-schatten .frei { background: rgb(120 130 150 / 0.10); }
|
||||
.g-schatten .feiertag { background: rgb(180 35 24 / 0.10); }
|
||||
.g-schatten .reserve { background: repeating-linear-gradient(135deg, rgb(162 110 58 / 0.10) 0 4px, transparent 4px 8px); }
|
||||
.g-schatten .heute { width: 2px; background: var(--warn); }
|
||||
.g-pfeile { position: absolute; top: 0; left: var(--links); pointer-events: none; z-index: 1; overflow: visible; }
|
||||
.g-pfeile path { fill: none; stroke: var(--leise); stroke-width: 1.2; }
|
||||
.g-pfeile polygon { fill: var(--leise); }
|
||||
@media (max-width: 800px) {
|
||||
.gantt { --links: 220px; }
|
||||
.g-links { grid-template-columns: 22px 1fr 22px; }
|
||||
.g-links > :nth-child(1), .g-links > :nth-child(4), .g-links > :nth-child(5), .g-links > :nth-child(6), .g-links > :nth-child(7), .g-links > :nth-child(8) { display: none; }
|
||||
}
|
||||
.g-zeile .leute { display: flex; gap: 3px; overflow: hidden; cursor: pointer; white-space: nowrap; }
|
||||
.g-zeile .leute .leer { color: var(--leise); font-size: 12px; opacity: 0; }
|
||||
.g-zeile:hover .leute .leer { opacity: 1; }
|
||||
.person { display: inline-block; font-size: 11px; line-height: 16px; padding: 0 5px; border-radius: 4px; background: var(--akzent-hell); color: var(--akzent); border: 1px solid transparent; }
|
||||
.person.vorgemerkt { background: transparent; border: 1px dashed var(--leise); color: var(--leise); font-style: italic; }
|
||||
.balken-leute { position: absolute; top: 9px; display: flex; gap: 3px; pointer-events: none; white-space: nowrap; }
|
||||
.balken.konflikt { outline: 2px solid var(--warn); outline-offset: 1px; }
|
||||
.warnung { background: #fdecea; color: #7a1c14; border: 1px solid #f5c2bd; border-radius: 10px; padding: 10px 14px; margin-bottom: 12px; font-size: 14px; }
|
||||
.warnung ul { margin: 4px 0 0; padding-left: 18px; }
|
||||
.dialog.besetzung table { margin: 8px 0; font-size: 14px; }
|
||||
.dialog.besetzung td { padding: 6px 8px; }
|
||||
.dialog.besetzung td .neben { padding: 2px 8px; }
|
||||
@media (prefers-color-scheme: dark) { .warnung { background: #3a1714; color: #f9c9c3; border-color: #6b2620; } }
|
||||
|
||||
/* Startseite */
|
||||
.kopf h1 .datum { font-size: 15px; font-weight: 400; color: var(--leise); margin-left: 8px; }
|
||||
.start { display: grid; grid-template-columns: 1fr 1fr; gap: 16px; align-items: start; }
|
||||
.karte { background: var(--fl); border: 1px solid var(--linie); border-radius: 10px; padding: 14px 16px; min-width: 0; }
|
||||
.karte.breit { grid-column: 1 / -1; }
|
||||
.karte-kopf { display: flex; align-items: center; justify-content: space-between; margin-bottom: 6px; }
|
||||
.karte-kopf h2 { margin: 0; }
|
||||
.karte-kopf .neben { padding: 5px 10px; font-size: 13px; }
|
||||
.gruppe h3 { font-size: 13px; color: var(--leise); margin: 12px 0 4px; display: flex; gap: 6px; align-items: center; }
|
||||
.gruppe h3 b { background: var(--bg); border-radius: 999px; padding: 0 7px; font-size: 12px; }
|
||||
.gruppe.warn h3 { color: var(--warn); }
|
||||
.gruppe .hinweis { margin: 2px 0; font-size: 14px; }
|
||||
ul.aufgaben { list-style: none; margin: 0; padding: 0; }
|
||||
ul.aufgaben li { display: flex; justify-content: space-between; gap: 10px; padding: 6px 0; border-bottom: 1px solid var(--linie); }
|
||||
ul.aufgaben li:last-child { border-bottom: 0; }
|
||||
ul.aufgaben label { display: flex; gap: 8px; align-items: baseline; }
|
||||
ul.aufgaben small { color: var(--leise); white-space: nowrap; }
|
||||
ul.warnungen { list-style: none; margin: 8px 0 0; padding: 0; }
|
||||
ul.warnungen li a { display: flex; gap: 10px; padding: 8px 10px; border-radius: 8px; color: inherit; text-decoration: none; margin-bottom: 6px; background: var(--bg); border-left: 3px solid var(--leise); }
|
||||
ul.warnungen li a:hover { background: var(--akzent-hell); }
|
||||
ul.warnungen li.ueberschneidung a, ul.warnungen li.kontostand a { border-left-color: var(--warn); }
|
||||
ul.warnungen li.unbesetzt a, ul.warnungen li.freigabe a { border-left-color: var(--holz); }
|
||||
ul.warnungen li.aufgabe a { border-left-color: var(--akzent); }
|
||||
ul.warnungen .symbol { width: 18px; text-align: center; flex: none; }
|
||||
.einsatz-tabelle { overflow-x: auto; }
|
||||
.einsatz-tabelle table { border: 0; border-radius: 0; font-size: 13px; }
|
||||
.einsatz-tabelle th, .einsatz-tabelle td { padding: 6px 6px; vertical-align: top; min-width: 96px; }
|
||||
.einsatz-tabelle tbody th { color: var(--text); font-size: 13px; min-width: 120px; }
|
||||
.einsatz-tabelle .neue-woche { border-left: 2px solid var(--linie); }
|
||||
.einsatz-tabelle tr.ohne th { color: var(--warn); }
|
||||
.einsatz { display: block; background: var(--akzent-hell); color: var(--akzent); border-radius: 5px; padding: 2px 6px; margin-bottom: 3px; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; max-width: 150px; }
|
||||
.einsatz.vorgemerkt { background: transparent; border: 1px dashed var(--leise); color: var(--leise); }
|
||||
tr.ohne .einsatz { background: #fdecea; color: #7a1c14; }
|
||||
.einsatz-liste { display: none; }
|
||||
.einsatz-liste h3 { font-size: 14px; margin: 12px 0 4px; }
|
||||
.einsatz-liste ul { margin: 0; padding-left: 18px; font-size: 14px; }
|
||||
.liqui { display: grid; grid-template-columns: repeat(4, 1fr); gap: 10px; }
|
||||
.liqui > div { background: var(--bg); border-radius: 8px; padding: 10px; display: flex; flex-direction: column; gap: 2px; }
|
||||
.liqui b { font-size: 17px; font-variant-numeric: tabular-nums; }
|
||||
.liqui small { color: var(--leise); font-size: 12px; }
|
||||
@media (max-width: 800px) {
|
||||
.start { grid-template-columns: 1fr; }
|
||||
.einsatz-tabelle { display: none; }
|
||||
.einsatz-liste { display: block; }
|
||||
.liqui { grid-template-columns: 1fr 1fr; }
|
||||
}
|
||||
.kalender-link { display: flex; gap: 8px; align-items: center; margin-bottom: 8px; flex-wrap: wrap; }
|
||||
.kalender-link b { width: 90px; }
|
||||
.kalender-link input { flex: 1; min-width: 220px; padding: 8px 10px; border: 1px solid var(--linie); border-radius: 8px; background: var(--bg); color: var(--text); font: inherit; font-size: 13px; }
|
||||
|
||||
117
test/api.test.ts
117
test/api.test.ts
@@ -1,5 +1,6 @@
|
||||
// Prüft Server und Datenbank zusammen. Läuft nur mit TEST_DATABASE_URL (lokal und in der CI).
|
||||
import { describe, it, expect, beforeAll, afterAll } from "vitest";
|
||||
import { falscheNextcloud } from "./falsche-nextcloud.js";
|
||||
import type { FastifyInstance } from "fastify";
|
||||
import { erstellePool, type Pool } from "../src/server/db.js";
|
||||
import { migriere } from "../src/server/migrate.js";
|
||||
@@ -149,4 +150,120 @@ describe.skipIf(!url)("Übernahme aus V70 über die API", () => {
|
||||
expect(kurz(l)).toEqual(kurz(erwartet));
|
||||
expect(erwartet.some((p) => p.einnahmen > 0)).toBe(true);
|
||||
});
|
||||
|
||||
it("Terminplan: Verknüpfungen eingehalten, V70-Nummern bleiben", async () => {
|
||||
const t = (await app.inject("/api/terminplan")).json();
|
||||
expect(t.vorgaenge).toHaveLength(13);
|
||||
expect(t.vorgaenge.every((v: { nummer: number }) => v.nummer > 1000)).toBe(true);
|
||||
const nr = new Map(t.vorgaenge.map((v: { id: string }) => [v.id, v]));
|
||||
for (const k of t.verknuepfungen.filter((k: { art: string }) => k.art === "EA")) {
|
||||
const a = nr.get(k.vorgaenger_id) as { ende: string };
|
||||
const b = nr.get(k.vorgang_id) as { anfang: string; dauer: number };
|
||||
if (b.dauer > 0) expect(b.anfang > a.ende, `${a.ende} → ${b.anfang}`).toBe(true);
|
||||
}
|
||||
});
|
||||
|
||||
it("längerer Vorgang schiebt Nachfolger, Kreis wird abgelehnt", async () => {
|
||||
const t = (await app.inject("/api/terminplan")).json();
|
||||
const k = t.verknuepfungen.find((k: { art: string; verzoegerung: number }) => k.art === "EA");
|
||||
const vor = t.vorgaenge.find((v: { id: string }) => v.id === k.vorgaenger_id);
|
||||
const nach = t.vorgaenge.find((v: { id: string }) => v.id === k.vorgang_id);
|
||||
const r = await app.inject({ method: "PATCH", url: `/api/vorgaenge/${vor.id}`, payload: { dauer: Number(vor.dauer) + 10 } });
|
||||
expect(r.statusCode, r.body).toBe(200);
|
||||
const t2 = (await app.inject("/api/terminplan")).json();
|
||||
const nach2 = t2.vorgaenge.find((v: { id: string }) => v.id === nach.id);
|
||||
const vor2 = t2.vorgaenge.find((v: { id: string }) => v.id === vor.id);
|
||||
expect(nach2.anfang > vor2.ende).toBe(true);
|
||||
expect(nach2.anfang > nach.anfang).toBe(true);
|
||||
const kreis = await app.inject({ method: "POST", url: "/api/verknuepfungen", payload: { vorgang_id: vor.id, vorgaenger_id: nach.id } });
|
||||
expect(kreis.statusCode).toBe(409);
|
||||
expect(kreis.json().fehler).toMatch(/Kreis/);
|
||||
// kürzer machen: der enge Nachfolger rückt wieder nach vorn
|
||||
await app.inject({ method: "PATCH", url: `/api/vorgaenge/${vor.id}`, payload: { dauer: Number(vor.dauer) } });
|
||||
const t3 = (await app.inject("/api/terminplan")).json();
|
||||
expect(t3.vorgaenge.find((v: { id: string }) => v.id === nach.id).anfang).toBe(nach.anfang);
|
||||
// von Hand nach hinten gezogen: bleibt dort und zieht den Nachfolger mit
|
||||
const spaeter = "2027-06-07";
|
||||
await app.inject({ method: "PATCH", url: `/api/vorgaenge/${vor.id}`, payload: { start: spaeter } });
|
||||
const t4 = (await app.inject("/api/terminplan")).json();
|
||||
expect(t4.vorgaenge.find((v: { id: string }) => v.id === vor.id).anfang).toBe(spaeter);
|
||||
expect(t4.vorgaenge.find((v: { id: string }) => v.id === nach.id).anfang > spaeter).toBe(true);
|
||||
});
|
||||
|
||||
it("Besetzung: Mitarbeiter gelten sofort, Subunternehmer erst nach Freigabe; Überschneidung wird gemeldet", async () => {
|
||||
const neu = async (pfad: string, body: object) => (await app.inject({ method: "POST", url: `/api/${pfad}`, payload: body })).json();
|
||||
const ma = await neu("kontakte", { name: "Henning Schaarschmidt", rolle: "mitarbeiter" });
|
||||
const sub = await neu("kontakte", { name: "Jens Meier", firma: "Meier Bedachungen GmbH", rolle: "subunternehmer" });
|
||||
const t = (await app.inject("/api/terminplan")).json();
|
||||
const frei = (v: { id: string; dauer: number }) => Number(v.dauer) > 0 && !t.verknuepfungen.some((k: { vorgang_id: string }) => k.vorgang_id === v.id);
|
||||
const [a, b] = t.vorgaenge.filter(frei);
|
||||
await app.inject({ method: "PATCH", url: `/api/vorgaenge/${b.id}`, payload: { start: a.anfang } });
|
||||
expect((await neu("besetzungen", { vorgang_id: a.id, kontakt_id: ma.id })).freigegeben).toBe(true);
|
||||
expect((await neu("besetzungen", { vorgang_id: a.id, kontakt_id: sub.id, personen: 2 })).freigegeben).toBe(false);
|
||||
expect((await neu("besetzungen", { vorgang_id: b.id, kontakt_id: ma.id })).freigegeben).toBe(true);
|
||||
const ohne = await app.inject({ method: "POST", url: "/api/besetzungen", payload: { vorgang_id: a.id } });
|
||||
expect(ohne.statusCode).toBe(400);
|
||||
const t2 = (await app.inject("/api/terminplan")).json();
|
||||
expect(t2.ueberschneidungen).toEqual([expect.objectContaining({ name: "Henning Schaarschmidt", ab: a.anfang })]);
|
||||
expect(t2.besetzungen.map((x: { kurz: string }) => x.kurz).sort()).toEqual(["HS", "HS", "Meier"]);
|
||||
});
|
||||
|
||||
it("Startseite: Aufgaben, Warnungen und wer macht was", async () => {
|
||||
await app.inject({ method: "POST", url: "/api/aufgaben", payload: { text: "Statik anfragen", faellig_am: "2026-10-16" } });
|
||||
const t = (await app.inject("/api/terminplan")).json();
|
||||
const u = (await app.inject(`/api/uebersicht?heute=${t.ueberschneidungen[0].ab}`)).json();
|
||||
expect(u.aufgaben.ueberfaellig.map((a: { text: string }) => a.text)).toContain("Statik anfragen");
|
||||
const arten = u.warnungen.map((w: { art: string }) => w.art);
|
||||
expect(arten).toEqual(expect.arrayContaining(["aufgabe", "kontostand"]));
|
||||
expect(u.warnungen.find((w: { art: string }) => w.art === "kontostand").text).toMatch(/nicht eingetragen/);
|
||||
expect(u.einsatz.tage).toHaveLength(8);
|
||||
expect(u.einsatz.zeilen.map((z: { anzeige: string }) => z.anzeige)).toContain("Henning Schaarschmidt");
|
||||
});
|
||||
|
||||
it("Kalender-Abo nur mit gültigem Geheimnis", async () => {
|
||||
expect((await app.inject("/kalender/xxxxxxxxxxxxxxxxxxxxxxxx/baustellen.ics")).statusCode).toBe(404);
|
||||
const { kalenderToken } = (await app.inject({ method: "POST", url: "/api/kalender/neu" })).json();
|
||||
const r = await app.inject(`/kalender/${kalenderToken}/baustellen.ics`);
|
||||
expect(r.statusCode).toBe(200);
|
||||
expect(r.headers["content-type"]).toMatch(/text\/calendar/);
|
||||
expect(r.body).toContain("X-WR-CALNAME:Baustellen");
|
||||
expect(r.body).toMatch(/SUMMARY:P-26-\d+/);
|
||||
expect((await app.inject(`/kalender/${kalenderToken}/aufgaben.ics`)).body).toContain("Aufgabe: Statik anfragen");
|
||||
expect((await app.inject(`/kalender/${kalenderToken.slice(0, -1)}${kalenderToken.endsWith("x") ? "y" : "x"}/baustellen.ics`)).statusCode).toBe(404);
|
||||
});
|
||||
});
|
||||
|
||||
describe.skipIf(!url)("Projektordner in der Nextcloud über die API", () => {
|
||||
let pool: Pool;
|
||||
let app: FastifyInstance;
|
||||
const f = falscheNextcloud();
|
||||
|
||||
beforeAll(async () => {
|
||||
pool = erstellePool(url!);
|
||||
await pool.query("drop schema public cascade; create schema public;");
|
||||
await migriere(pool);
|
||||
app = await baueApp({ pool, webOrdner: "/gibt-es-nicht", nextcloud: f.nc });
|
||||
});
|
||||
afterAll(async () => {
|
||||
await app?.close();
|
||||
await pool?.end();
|
||||
});
|
||||
|
||||
it("neues Projekt bekommt einen Ordner, Statuswechsel verschiebt ihn", async () => {
|
||||
const p = (await app.inject({ method: "POST", url: "/api/projekte", payload: { nummer: "A-26-130", bezeichnung: "Carport Most", status: "angebot" } })).json();
|
||||
expect(p.nextcloud_link).toBe("01 Angebot/A-26-130 Carport Most");
|
||||
const q = (await app.inject({ method: "PATCH", url: `/api/projekte/${p.id}`, payload: { nummer: "P-26-021", status: "auftrag" } })).json();
|
||||
expect(q.nextcloud_link).toBe("02 laufende Projekte/P-26-021 Carport Most");
|
||||
expect(f.relativ()).toContain("02 laufende Projekte/P-26-021 Carport Most/02 Umsetzung");
|
||||
});
|
||||
|
||||
it("Fehler der Nextcloud verhindert das Speichern nicht", async () => {
|
||||
f.ordner.clear(); // Wurzel fehlt: jede Anlage schlägt fehl
|
||||
const r = await app.inject({ method: "POST", url: "/api/projekte", payload: { nummer: "A-26-131", bezeichnung: "Gaube", status: "angebot" } });
|
||||
expect(r.statusCode).toBe(201);
|
||||
expect(r.json().ordner_fehler).toMatch(/Nextcloud/);
|
||||
f.ordner.add(f.wurzel);
|
||||
const nochmal = (await app.inject({ method: "POST", url: `/api/projekte/${r.json().id}/ordner` })).json();
|
||||
expect(nochmal.nextcloud_link).toBe("01 Angebot/A-26-131 Gaube");
|
||||
});
|
||||
});
|
||||
|
||||
27
test/einsatz.test.ts
Normal file
27
test/einsatz.test.ts
Normal file
@@ -0,0 +1,27 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { kuerzel, ueberschneidungen, wer } from "../src/domain/einsatz.js";
|
||||
|
||||
const v = (id: string, anfang: string, ende: string) => ({ id, anfang, ende });
|
||||
const b = (vorgang_id: string, k: string | null, platzhalter: string | null = null) => ({ vorgang_id, kontakt_id: k, platzhalter, personen: 1, freigegeben: true });
|
||||
|
||||
describe("Terminüberschneidung (T9)", () => {
|
||||
const vg = [v("a", "2026-10-19", "2026-10-21"), v("b", "2026-10-21", "2026-10-22"), v("c", "2026-10-26", "2026-10-27")];
|
||||
it("meldet dieselbe Person an zwei Stellen mit erstem gemeinsamem Tag", () => {
|
||||
expect(ueberschneidungen(vg, [b("a", "k1"), b("b", "k1"), b("c", "k1")])).toEqual([{ wer: "k1", vorgang_a: "a", vorgang_b: "b", ab: "2026-10-21" }]);
|
||||
});
|
||||
it("verschiedene Personen und aufeinanderfolgende Tage sind kein Konflikt", () => {
|
||||
expect(ueberschneidungen(vg, [b("a", "k1"), b("b", "k2"), b("c", "k2")])).toEqual([]);
|
||||
});
|
||||
it("Kolonnen als Platzhalter zählen, N.N. nicht", () => {
|
||||
expect(ueberschneidungen(vg, [b("a", null, "Kolonne 2"), b("b", null, "kolonne 2")])).toHaveLength(1);
|
||||
expect(ueberschneidungen(vg, [b("a", null, "N.N."), b("b", null, "N. N.")])).toHaveLength(0);
|
||||
expect(wer({ platzhalter: "NN" })).toBeUndefined();
|
||||
});
|
||||
});
|
||||
|
||||
describe("Kürzel", () => {
|
||||
it("Mitarbeiter mit Initialen, Subunternehmer mit erstem Wort", () => {
|
||||
expect(kuerzel("Henning Schaarschmidt", "mitarbeiter")).toBe("HS");
|
||||
expect(kuerzel("Meier Bedachungen GmbH", "subunternehmer")).toBe("Meier");
|
||||
});
|
||||
});
|
||||
36
test/falsche-nextcloud.ts
Normal file
36
test/falsche-nextcloud.ts
Normal file
@@ -0,0 +1,36 @@
|
||||
import { Nextcloud } from "../src/server/nextcloud.js";
|
||||
|
||||
/** Kleine WebDAV-Nachbildung im Speicher: nur Ordner, wie Nextcloud sie beantwortet */
|
||||
export function falscheNextcloud(basis = "https://cloud.test/remote.php/dav/files/henning/Projekte") {
|
||||
const ordner = new Set<string>();
|
||||
const pfad = (u: string) => decodeURIComponent(new URL(u).pathname).replace(/\/+$/, "");
|
||||
const wurzel = pfad(basis);
|
||||
ordner.add(wurzel);
|
||||
const abruf = (async (u: string | URL, init?: RequestInit) => {
|
||||
const p = pfad(String(u));
|
||||
const kopf = (init?.headers ?? {}) as Record<string, string>;
|
||||
const eltern = p.slice(0, p.lastIndexOf("/"));
|
||||
switch (init?.method) {
|
||||
case "PROPFIND": {
|
||||
if (!ordner.has(p)) return new Response(null, { status: 404 });
|
||||
const kinder = kopf.depth === "1" ? [...ordner].filter((o) => o.startsWith(p + "/") && !o.slice(p.length + 1).includes("/")) : [];
|
||||
const hrefs = [p, ...kinder].map((o) => `<d:response><d:href>${o.split("/").map(encodeURIComponent).join("/")}/</d:href></d:response>`).join("");
|
||||
return new Response(`<?xml version="1.0"?><d:multistatus xmlns:d="DAV:">${hrefs}</d:multistatus>`, { status: 207 });
|
||||
}
|
||||
case "MKCOL":
|
||||
if (ordner.has(p)) return new Response(null, { status: 405 });
|
||||
if (!ordner.has(eltern)) return new Response(null, { status: 409 });
|
||||
ordner.add(p);
|
||||
return new Response(null, { status: 201 });
|
||||
case "MOVE": {
|
||||
const ziel = pfad(kopf.destination!);
|
||||
if (!ordner.has(p) || ordner.has(ziel) || !ordner.has(ziel.slice(0, ziel.lastIndexOf("/")))) return new Response(null, { status: 409 });
|
||||
for (const o of [...ordner]) if (o === p || o.startsWith(p + "/")) { ordner.delete(o); ordner.add(ziel + o.slice(p.length)); }
|
||||
return new Response(null, { status: 201 });
|
||||
}
|
||||
}
|
||||
return new Response(null, { status: 400 });
|
||||
}) as typeof fetch;
|
||||
const relativ = () => [...ordner].filter((o) => o !== wurzel).map((o) => o.slice(wurzel.length + 1)).sort();
|
||||
return { nc: new Nextcloud({ url: basis, benutzer: "henning", passwort: "geheim" }, abruf), ordner, wurzel, relativ };
|
||||
}
|
||||
22
test/ical.test.ts
Normal file
22
test/ical.test.ts
Normal file
@@ -0,0 +1,22 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { kalender } from "../src/domain/ical.js";
|
||||
import { arbeitsbloecke } from "../src/server/kalender.js";
|
||||
import { STANDARDWOCHE as W } from "../src/domain/kalender.js";
|
||||
|
||||
describe("Kalender-Abo (T11)", () => {
|
||||
it("ganztägige Termine, Ende am Folgetag, Sonderzeichen maskiert", () => {
|
||||
const ics = kalender("Baustellen", [{ uid: "v1@x", von: "2026-10-26", bis: "2026-10-27", titel: "P-26-014 Abbund, Montage; HS" }], new Date("2026-10-19T08:00:00Z"));
|
||||
expect(ics).toContain("DTSTART;VALUE=DATE:20261026\r\nDTEND;VALUE=DATE:20261028");
|
||||
expect(ics).toContain("SUMMARY:P-26-014 Abbund\\, Montage\\; HS");
|
||||
expect(ics).toContain("DTSTAMP:20261019T080000Z");
|
||||
expect(ics.endsWith("END:VCALENDAR\r\n")).toBe(true);
|
||||
});
|
||||
it("lange Zeilen werden nach 75 Byte gefaltet", () => {
|
||||
const ics = kalender("K", [{ uid: "u", von: "2026-10-26", bis: "2026-10-26", titel: "Ä".repeat(60) }]);
|
||||
for (const z of ics.split("\r\n")) expect(new TextEncoder().encode(z).length).toBeLessThanOrEqual(75);
|
||||
expect(ics.replace(/\r\n /g, "")).toContain("SUMMARY:" + "Ä".repeat(60));
|
||||
});
|
||||
it("Vorgang über Freitag und Wochenende wird in Arbeitsblöcke geteilt", () => {
|
||||
expect(arbeitsbloecke("2026-10-21", "2026-10-27", W)).toEqual([["2026-10-21", "2026-10-22"], ["2026-10-26", "2026-10-27"]]);
|
||||
});
|
||||
});
|
||||
35
test/nextcloud.test.ts
Normal file
35
test/nextcloud.test.ts
Normal file
@@ -0,0 +1,35 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { ordnerAbgleichen, ordnerName } from "../src/server/nextcloud.js";
|
||||
import { falscheNextcloud } from "./falsche-nextcloud.js";
|
||||
|
||||
describe("Projektordner in der Nextcloud (P10)", () => {
|
||||
it("Ordnername ohne verbotene Zeichen", () => {
|
||||
expect(ordnerName("P-26-020", "Terrassendach / Carport")).toBe("P-26-020 Terrassendach - Carport");
|
||||
});
|
||||
|
||||
it("legt neu an mit Unterordnern und verschiebt nach Status und Umbenennung", async () => {
|
||||
const f = falscheNextcloud();
|
||||
const p = { nummer: "A-26-120", bezeichnung: "Terrassendachsanierung", status: "angebot" };
|
||||
let pfad = await ordnerAbgleichen(f.nc, p, null);
|
||||
expect(pfad).toBe("01 Angebot/A-26-120 Terrassendachsanierung");
|
||||
expect(f.relativ()).toContain("01 Angebot/A-26-120 Terrassendachsanierung/01 Auftrag/03 Stundenlohnarb.");
|
||||
// Angebot angenommen: neue Nummer und Status Auftrag
|
||||
pfad = await ordnerAbgleichen(f.nc, { ...p, nummer: "P-26-020", status: "auftrag" }, pfad);
|
||||
expect(pfad).toBe("02 laufende Projekte/P-26-020 Terrassendachsanierung");
|
||||
expect(f.relativ()).toContain("02 laufende Projekte/P-26-020 Terrassendachsanierung/03 Bilder");
|
||||
expect(f.relativ().some((o) => o.startsWith("01 Angebot/"))).toBe(false);
|
||||
pfad = await ordnerAbgleichen(f.nc, { ...p, nummer: "P-26-020", status: "gewaehrleistung" }, pfad);
|
||||
expect(pfad).toBe("03 Gewährl.-Projekte/P-26-020 Terrassendachsanierung");
|
||||
});
|
||||
|
||||
it("übernimmt einen vorhandenen Ordner mit gleicher Nummer statt einen zweiten anzulegen", async () => {
|
||||
const f = falscheNextcloud();
|
||||
f.ordner.add(`${f.wurzel}/02 laufende Projekte`);
|
||||
f.ordner.add(`${f.wurzel}/02 laufende Projekte/P-26-014 Bohlentausch Stadt`);
|
||||
f.ordner.add(`${f.wurzel}/02 laufende Projekte/P-26-014 Bohlentausch Stadt/Fotos`);
|
||||
const pfad = await ordnerAbgleichen(f.nc, { nummer: "P-26-014", bezeichnung: "Bohlentausch", status: "abgeschlossen" }, null);
|
||||
expect(pfad).toBe("04 Archiv/P-26-014 Bohlentausch");
|
||||
expect(f.relativ()).toContain("04 Archiv/P-26-014 Bohlentausch/Fotos");
|
||||
expect(f.relativ().filter((o) => o.includes("P-26-014"))).toHaveLength(2);
|
||||
});
|
||||
});
|
||||
72
test/terminplan.test.ts
Normal file
72
test/terminplan.test.ts
Normal file
@@ -0,0 +1,72 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { type PlanVorgang, type Verknuepfung, bildetKreis, ende, engeVorgaenge, fruehesterStart, planeNeu, startNachVerknuepfung } from "../src/domain/terminplan.js";
|
||||
import { STANDARDWOCHE as W } from "../src/domain/kalender.js";
|
||||
|
||||
// 19.10.2026 ist ein Montag; gearbeitet wird Mo–Do
|
||||
const v = (id: string, start: string, dauer: number): PlanVorgang => ({ id, start, dauer });
|
||||
const k = (vorgang_id: string, vorgaenger_id: string, art: Verknuepfung["art"] = "EA", verzoegerung = 0): Verknuepfung => ({ vorgang_id, vorgaenger_id, art, verzoegerung });
|
||||
|
||||
describe("Verknüpfungsarten wie V70", () => {
|
||||
const a = v("a", "2026-10-19", 3); // Mo–Mi
|
||||
it("EA: am nächsten Arbeitstag nach dem Ende", () => {
|
||||
expect(ende(a, W)).toBe("2026-10-21");
|
||||
expect(startNachVerknuepfung(v("b", "2026-10-19", 2), a, k("b", "a"), W)).toBe("2026-10-22");
|
||||
});
|
||||
it("EA mit Verzögerung überspringt Freitag und Wochenende", () => {
|
||||
expect(startNachVerknuepfung(v("b", "2026-10-19", 2), a, k("b", "a", "EA", 1), W)).toBe("2026-10-26");
|
||||
});
|
||||
it("EA bei Meilenstein: am Ende des Vorgängers", () => {
|
||||
expect(startNachVerknuepfung(v("m", "2026-10-19", 0), a, k("m", "a"), W)).toBe("2026-10-21");
|
||||
});
|
||||
it("AA: gleicher Anfang plus Verzögerung", () => {
|
||||
expect(startNachVerknuepfung(v("b", "2026-10-19", 2), a, k("b", "a", "AA", 2), W)).toBe("2026-10-21");
|
||||
});
|
||||
it("EE: endet mit dem Vorgänger", () => {
|
||||
const b = v("b", "2026-10-19", 2);
|
||||
const s = startNachVerknuepfung(b, a, k("b", "a", "EE"), W);
|
||||
expect(s).toBe("2026-10-20");
|
||||
expect(ende({ ...b, start: s }, W)).toBe("2026-10-21");
|
||||
});
|
||||
it("AE: endet, wenn der Vorgänger anfängt", () => {
|
||||
const b = v("b", "2026-10-01", 2);
|
||||
expect(startNachVerknuepfung(b, a, k("b", "a", "AE"), W)).toBe("2026-10-15");
|
||||
});
|
||||
});
|
||||
|
||||
describe("mehrere Vorgänger (T5)", () => {
|
||||
it("der späteste Vorgänger bestimmt den Start", () => {
|
||||
const alle = new Map([v("a", "2026-10-19", 2), v("b", "2026-10-19", 4), v("c", "2026-10-19", 1)].map((x) => [x.id, x]));
|
||||
expect(fruehesterStart(alle.get("c")!, alle, [k("c", "a"), k("c", "b")], W)).toBe("2026-10-26");
|
||||
});
|
||||
});
|
||||
|
||||
describe("Neuplanung", () => {
|
||||
const links = [k("b", "a"), k("c", "b")];
|
||||
it("schiebt Nachfolger nach hinten, wenn der Vorgänger länger dauert", () => {
|
||||
const r = planeNeu([v("a", "2026-10-19", 5), v("b", "2026-10-22", 2), v("c", "2026-10-27", 1)], links, W);
|
||||
expect(r.starts.get("b")).toBe("2026-10-27");
|
||||
expect(r.starts.get("c")).toBe("2026-10-29");
|
||||
});
|
||||
it("zieht nur enge Nachfolger nach vorn", () => {
|
||||
const alt = [v("a", "2026-10-19", 3), v("b", "2026-10-22", 2), v("c", "2026-11-02", 1)];
|
||||
const eng = engeVorgaenge(alt, links, W);
|
||||
expect([...eng]).toEqual(["b"]);
|
||||
const r = planeNeu([v("a", "2026-10-19", 2), alt[1]!, alt[2]!], links, W, eng);
|
||||
expect(r.starts.get("b")).toBe("2026-10-21");
|
||||
expect(r.starts.has("c")).toBe(false);
|
||||
});
|
||||
it("lässt freie Vorgänge ohne Vorgänger in Ruhe", () => {
|
||||
expect(planeNeu([v("x", "2026-10-19", 2)], [], W).starts.size).toBe(0);
|
||||
});
|
||||
});
|
||||
|
||||
describe("Kreise", () => {
|
||||
const links = [k("b", "a"), k("c", "b")];
|
||||
it("erkennt einen Kreis über mehrere Glieder", () => {
|
||||
expect(bildetKreis({ vorgang_id: "a", vorgaenger_id: "c" }, links)).toBe(true);
|
||||
expect(bildetKreis({ vorgang_id: "a", vorgaenger_id: "a" }, links)).toBe(true);
|
||||
});
|
||||
it("erlaubt einen zweiten Vorgänger ohne Kreis", () => {
|
||||
expect(bildetKreis({ vorgang_id: "c", vorgaenger_id: "a" }, links)).toBe(false);
|
||||
});
|
||||
});
|
||||
32
test/uebersicht.test.ts
Normal file
32
test/uebersicht.test.ts
Normal file
@@ -0,0 +1,32 @@
|
||||
import { describe, expect, it } from "vitest";
|
||||
import { aufgabenGruppen, einsatzMatrix, naechsteArbeitstage } from "../src/domain/uebersicht.js";
|
||||
import { STANDARDWOCHE as W } from "../src/domain/kalender.js";
|
||||
|
||||
describe("Aufgaben wie in V70 gruppiert", () => {
|
||||
const a = (id: string, faellig_am: string | null, extra = {}) => ({ id, text: id, faellig_am, ...extra });
|
||||
it("überfällig, diese Woche bis Sonntag, langfristig; erledigte fallen weg", () => {
|
||||
// Mittwoch, 21.10.2026
|
||||
const g = aufgabenGruppen([a("alt", "2026-10-20"), a("so", "2026-10-25"), a("mo", "2026-10-26"), a("ohne", null), a("fertig", "2026-10-21", { erledigt_am: "x" }), a("lang", "2026-10-22", { langfristig: true })], "2026-10-21");
|
||||
expect(g.ueberfaellig.map((x) => x.id)).toEqual(["alt"]);
|
||||
expect(g.dieseWoche.map((x) => x.id)).toEqual(["so"]);
|
||||
expect(g.langfristig.map((x) => x.id)).toEqual(["lang", "mo", "ohne"]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("Wer macht was", () => {
|
||||
it("nächste Arbeitstage ohne Freitag und Feiertag", () => {
|
||||
expect(naechsteArbeitstage("2026-10-29", 3, W)).toEqual(["2026-10-29", "2026-11-02", "2026-11-03"]);
|
||||
});
|
||||
it("Person je Zeile, Vorgänge ohne Besetzung extra", () => {
|
||||
const tage = ["2026-10-19", "2026-10-20", "2026-10-21"];
|
||||
const vg = [
|
||||
{ id: "v1", name: "Abbund", anfang: "2026-10-19", ende: "2026-10-20", projekt: "P-26-014 Bohlentausch" },
|
||||
{ id: "v2", name: "Montage", anfang: "2026-10-21", ende: "2026-10-22", projekt: "P-26-015 Anbau" },
|
||||
];
|
||||
const bs = [{ vorgang_id: "v1", kontakt_id: "k1", personen: 1, freigegeben: true, anzeige: "Henning", kurz: "HS" }];
|
||||
const m = einsatzMatrix(vg, bs, tage);
|
||||
expect(m.zeilen).toHaveLength(1);
|
||||
expect(m.zeilen[0]!.tage.map((t) => t.map((x) => x.name))).toEqual([["Abbund"], ["Abbund"], []]);
|
||||
expect(m.ohne.tage.map((t) => t.length)).toEqual([0, 0, 1]);
|
||||
});
|
||||
});
|
||||
@@ -125,3 +125,19 @@ describe("Liquidität centgenau wie V70", () => {
|
||||
expect([...projekte(mit)].filter((p) => !projekte(ohne).has(p)).sort()).toEqual(["A-27-001", "A-OHNE-1"]);
|
||||
});
|
||||
});
|
||||
|
||||
describe("Aufgaben aus V70 (Stufe 1)", () => {
|
||||
it("übernimmt Text, Datum, Kontakt, Projekt und Erledigt", () => {
|
||||
const s = JSON.parse(readFileSync(new URL("./daten/v70-sicherung-2026-10-19.json", import.meta.url), "utf8"));
|
||||
s.aufgaben = [
|
||||
{ id: "a1", t: "Statik anfragen", d: "2026-10-22", k: "Ing.-Büro Lange", p: 0 },
|
||||
{ id: "a2", t: "Gerüst abbestellen", done: true, doneAt: Date.UTC(2026, 9, 1) },
|
||||
{ id: "a3", t: " " },
|
||||
];
|
||||
const u = uebernimmV70(s);
|
||||
expect(u.aufgaben).toEqual([
|
||||
{ text: "Statik anfragen (Ing.-Büro Lange)", faellig_am: "2026-10-22", projekt: "p0", erledigt_am: undefined },
|
||||
{ text: "Gerüst abbestellen", faellig_am: undefined, projekt: undefined, erledigt_am: "2026-10-01T00:00:00.000Z" },
|
||||
]);
|
||||
});
|
||||
});
|
||||
|
||||
Reference in New Issue
Block a user