Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AmyPfuNc4sCRfaF3oURXZz
95 lines
5.2 KiB
TypeScript
95 lines
5.2 KiB
TypeScript
// D1: einen kompletten Stand (GET /api/export) in ein leeres Programm einspielen, alle IDs bleiben.
|
|
// Damit ziehen die Daten aus der Testversion im Browser auf den Server um.
|
|
import type { Client } from "./db.js";
|
|
import { EinstellungenSchema } from "./einstellungen.js";
|
|
import { NUR_SICHERUNG, TABELLEN } from "./tabellen.js";
|
|
import { NichtLeer } from "./v70import.js";
|
|
|
|
export interface Stand {
|
|
programm: "betrieb";
|
|
einstellungen?: unknown;
|
|
daten: Record<string, Record<string, unknown>[]>;
|
|
}
|
|
|
|
export function pruefeStand(x: unknown): Stand {
|
|
const s = x as Partial<Stand>;
|
|
if (!s || s.programm !== "betrieb" || typeof s.daten !== "object" || s.daten === null) {
|
|
throw new Error("Das ist keine Sicherung aus diesem Programm.");
|
|
}
|
|
return s as Stand;
|
|
}
|
|
|
|
export async function speichereStand(c: Client, s: Stand): Promise<Record<string, number>> {
|
|
const belegt = await c.query<{ n: number }>(
|
|
`select ${[...TABELLEN, ...NUR_SICHERUNG].map((t) => `(select count(*) from ${t.name})`).join(" + ")} as n`,
|
|
);
|
|
if (Number(belegt.rows[0]!.n) > 0) throw new NichtLeer("Eine Sicherung lässt sich nur in ein leeres Programm einspielen.");
|
|
|
|
const anzahl: Record<string, number> = {};
|
|
// Zeitstempel aus der Sicherung behalten, kein Protokoll (Migration 017)
|
|
await c.query("select set_config('betrieb.einspielen', 'ja', true)");
|
|
// TABELLEN steht in der Reihenfolge der Fremdschlüssel, NUR_SICHERUNG hängt an ihnen
|
|
for (const t of [...TABELLEN, ...NUR_SICHERUNG]) {
|
|
const zeilen = s.daten[t.pfad] ?? [];
|
|
// nur Spalten, die es gibt und die in der Sicherung stehen: neue Spalten behalten ihren Vorgabewert,
|
|
// so passt eine ältere Sicherung auch nach einer Migration
|
|
const vorhanden = new Set((await c.query<{ column_name: string }>(
|
|
"select column_name from information_schema.columns where table_schema = current_schema() and table_name = $1", [t.name])).rows.map((r) => r.column_name));
|
|
// gleich aufgebaute Zeilen zu Hunderten auf einmal (der Materialstamm hat schnell 20.000 Artikel)
|
|
const pakete = new Map<string, Record<string, unknown>[]>();
|
|
for (const zeile of zeilen) {
|
|
// T15: Vorgänge aus einer Sicherung von vor 0.12 behalten ihre Dauer
|
|
const z = t.name === "vorgang" && !("dauer_fest" in zeile) ? { ...zeile, dauer_fest: true } : zeile;
|
|
const spalten = Object.keys(z).filter((k) => vorhanden.has(k)).join(", ");
|
|
const paket = pakete.get(spalten) ?? [];
|
|
paket.push(z);
|
|
pakete.set(spalten, paket);
|
|
}
|
|
for (const [spalten, paket] of pakete) {
|
|
for (let i = 0; i < paket.length; i += 500) {
|
|
await c.query(`insert into ${t.name} (${spalten}) select ${spalten} from json_populate_recordset(null::${t.name}, $1::json)`, [JSON.stringify(paket.slice(i, i + 500))]);
|
|
}
|
|
}
|
|
anzahl[t.pfad] = zeilen.length;
|
|
}
|
|
anzahl.benutzer = await speichereBenutzer(c, s.daten.benutzer ?? []);
|
|
anzahl.ansichten = await speichereAnsichten(c, s.daten.ansichten ?? []);
|
|
if (s.einstellungen !== undefined) {
|
|
await c.query("update einstellungen set daten = $1", [EinstellungenSchema.parse(s.einstellungen)]);
|
|
}
|
|
await c.query("select set_config('betrieb.einspielen', '', true)");
|
|
await c.query("select setval('vorgang_nummer_seq', greatest((select max(nummer) from vorgang), 1000))");
|
|
// Sicherung von vor 0.6.0: dieselbe Regel wie Migration 006, damit laufende Projekte keinen automatischen Zahlungsplan bekommen
|
|
if (!(s.daten.projekte ?? []).some((p) => "zahlungsplan" in p)) {
|
|
await c.query(`update projekt set zahlungsplan = 'fest'
|
|
where exists (select 1 from zahlung z where z.projekt_id = projekt.id)
|
|
or status in ('ausfuehrung', 'abgerechnet', 'gewaehrleistung', 'abgeschlossen')`);
|
|
}
|
|
return anzahl;
|
|
}
|
|
|
|
/** Benutzer gehören nicht zu TABELLEN (kein Passwort in der Sicherung). Wer schon da ist (gleicher
|
|
* Anmeldename, z. B. der Inhaber nach der Einrichtung auf dem Server), behält sein Passwort. */
|
|
async function speichereBenutzer(c: Client, zeilen: Record<string, unknown>[]): Promise<number> {
|
|
for (const z of zeilen) {
|
|
await c.query(`insert into benutzer (id, anmeldename, name, rolle, kontakt_id, aktiv) values ($1, $2, $3, $4, $5, $6)
|
|
on conflict (anmeldename) do update set name = excluded.name, rolle = excluded.rolle, kontakt_id = excluded.kontakt_id, aktiv = excluded.aktiv`,
|
|
[z.id, z.anmeldename, z.name, z.rolle, z.kontakt_id ?? null, z.aktiv ?? true]);
|
|
}
|
|
return zeilen.length;
|
|
}
|
|
|
|
/** Ansichten der Tabellen; die zählen nicht als Daten, wer schon eine hat (Server nach der Einrichtung), bekommt die aus der Sicherung */
|
|
async function speichereAnsichten(c: Client, zeilen: Record<string, unknown>[]): Promise<number> {
|
|
for (const z of zeilen) {
|
|
await c.query(`insert into ansicht (id, anmeldename, tabelle, daten) values ($1, $2, $3, $4)
|
|
on conflict (anmeldename, tabelle) do update set daten = excluded.daten`, [z.id, z.anmeldename, z.tabelle, z.daten]);
|
|
}
|
|
return zeilen.length;
|
|
}
|
|
|
|
/** Für die Sicherung: Benutzer ohne Passwort-Hash */
|
|
export async function benutzerFuerSicherung(c: { query: Client["query"] }): Promise<Record<string, unknown>[]> {
|
|
return (await c.query("select id, anmeldename, name, rolle, kontakt_id, aktiv, angelegt_am from benutzer order by angelegt_am")).rows;
|
|
}
|