Verbrauchsausweis Gewerbe

src/astro-typesafe-api-caller.ts

@@ -5,14 +5,15 @@ export const createCaller = createCallerFactory({
     "postleitzahlen": await import("../src/pages/api/postleitzahlen.ts"),
     "aufnahme/[uid]": await import("../src/pages/api/aufnahme/[uid].ts"),
     "aufnahme": await import("../src/pages/api/aufnahme/index.ts"),
-    "bilder/[uid]": await import("../src/pages/api/bilder/[uid].ts"),
     "auth/access-token": await import("../src/pages/api/auth/access-token.ts"),
     "auth/refresh-token": await import("../src/pages/api/auth/refresh-token.ts"),
     "bedarfsausweis-wohnen": await import("../src/pages/api/bedarfsausweis-wohnen/index.ts"),
+    "bilder/[uid]": await import("../src/pages/api/bilder/[uid].ts"),
     "objekt": await import("../src/pages/api/objekt/index.ts"),
     "ticket": await import("../src/pages/api/ticket/index.ts"),
     "user": await import("../src/pages/api/user/index.ts"),
     "user/self": await import("../src/pages/api/user/self.ts"),
+    "verbrauchsausweis-gewerbe/[uid]": await import("../src/pages/api/verbrauchsausweis-gewerbe/[uid].ts"),
     "verbrauchsausweis-gewerbe": await import("../src/pages/api/verbrauchsausweis-gewerbe/index.ts"),
     "verbrauchsausweis-wohnen/[uid]": await import("../src/pages/api/verbrauchsausweis-wohnen/[uid].ts"),
     "verbrauchsausweis-wohnen": await import("../src/pages/api/verbrauchsausweis-wohnen/index.ts"),

src/components/Ausweis/types.ts

@@ -3,6 +3,7 @@ import {
 	Aufnahme,
 	BedarfsausweisWohnen,
 	Benutzer,
+	Enums,
 	GebaeudeBilder,
 	Objekt,
 	Rechnung,
@@ -121,3 +122,21 @@ export const UUidWithPrefix = z.string().refine((value) => {
 
 	return false;
 })
+
+export function getAusweisartFromUUID(uid: string): Enums.Ausweisart | null {
+	if (!UUidWithPrefix.safeParse(uid).success) {
+		return null
+	}
+
+	if (uid.startsWith("vaw")) {
+		return Enums.Ausweisart.VerbrauchsausweisWohnen
+	} else if (uid.startsWith("vag")) {
+		return Enums.Ausweisart.VerbrauchsausweisGewerbe
+	} else if (uid.startsWith("baw")) {
+		return Enums.Ausweisart.BedarfsausweisWohnen
+	} else if (uid.startsWith("bag")) {
+		return Enums.Ausweisart.BedarfsausweisGewerbe
+	}
+
+	return null;
+} 

src/lib/pdf/pdfVerbrauchsausweisGewerbe.ts

@@ -0,0 +1,5 @@
+import { AufnahmeClient, BenutzerClient, ObjektClient, UploadedGebaeudeBild, VerbrauchsausweisGewerbeClient } from "#components/Ausweis/types.js";
+
+export async function pdfVerbrauchsausweisGewerbe(ausweis: VerbrauchsausweisGewerbeClient, aufnahme: AufnahmeClient, objekt: ObjektClient, bilder: UploadedGebaeudeBild[], user: BenutzerClient) {
+
+}

src/lib/pdf/pdfVerbrauchsausweisWohnen.ts

@@ -1,4 +1,4 @@
-import { VerbrauchsausweisWohnenClient } from "#components/Ausweis/types.js";
+import { AufnahmeClient, BenutzerClient, ObjektClient, UploadedGebaeudeBild, VerbrauchsausweisWohnenClient } from "#components/Ausweis/types.js";
 import { endEnergieVerbrauchVerbrauchsausweis_2016 } from "#lib/Berechnungen/VerbrauchsausweisWohnen/VerbrauchsausweisWohnen_2016.js";
 import { Enums } from "@ibcornelsen/database/server";
 import * as fs from "fs"
@@ -7,7 +7,7 @@ import { PDFDocument, PDFName, PDFNumber, PDFPage, StandardFonts, TextAlignment
 
 /* -------------------------------- Pdf Tools ------------------------------- */
 
-export async function pdfVerbrauchsausweisWohnen(ausweis: VerbrauchsausweisWohnenClient) {
+export async function pdfVerbrauchsausweisWohnen(ausweis: VerbrauchsausweisWohnenClient, aufnahme: AufnahmeClient, objekt: ObjektClient, bilder: UploadedGebaeudeBild[], user: BenutzerClient) {
 	const VerbrauchsausweisWohnenGEG2024PDF = fs.readFileSync(new URL("./templates/GEG24_Wohngebaeude_ohne_pfeile_form.pdf", import.meta.url), "base64");
 	const pdf = await PDFDocument.load(VerbrauchsausweisWohnenGEG2024PDF)
 	const pages = pdf.getPages()
@@ -41,38 +41,38 @@ export async function pdfVerbrauchsausweisWohnen(ausweis: VerbrauchsausweisWohne
 		}
 	}
 
-	const gebaeudetyp = fillFormField("gebaeudetyp", ausweis.aufnahme.gebaeudetyp)
+	const gebaeudetyp = fillFormField("gebaeudetyp", aufnahme.gebaeudetyp)
 
-	const adresse = fillFormField("adresse", ausweis.aufnahme.objekt.adresse)
+	const adresse = fillFormField("adresse", objekt.adresse)
 	
 
-	const gebaeudeteil = fillFormField("gebaeudeteil", ausweis.aufnahme.gebaeudeteil)
+	const gebaeudeteil = fillFormField("gebaeudeteil", aufnahme.gebaeudeteil)
 
-	const baujahr_gebaeude = fillFormField("baujahr_gebaeude", ausweis.aufnahme.baujahr_gebaeude.toString())
+	const baujahr_gebaeude = fillFormField("baujahr_gebaeude", aufnahme.baujahr_gebaeude.toString())
 
-	const baujahr_heizung = fillFormField("baujahr_heizung", ausweis.aufnahme.baujahr_heizung.toString())
+	const baujahr_heizung = fillFormField("baujahr_heizung", aufnahme.baujahr_heizung.toString())
 
-	const einheiten = fillFormField("einheiten", ausweis.aufnahme.einheiten.toString())
+	const einheiten = fillFormField("einheiten", aufnahme.einheiten.toString())
 
-	const nutzflaeche = fillFormField("nutzflaeche", `${ausweis.aufnahme.nutzflaeche.toString()}m²`)
+	const nutzflaeche = fillFormField("nutzflaeche", `${aufnahme.nutzflaeche.toString()}m²`)
 
-	fillFormField("energietraeger_heizung", `${ausweis.aufnahme.brennstoff_1}, ${ausweis.aufnahme.brennstoff_2 || ""}`)
+	fillFormField("energietraeger_heizung", `${aufnahme.brennstoff_1}, ${aufnahme.brennstoff_2 || ""}`)
 
 	if (ausweis.warmwasser_enthalten) {
-		fillFormField("energietraeger_warmwasser", `${ausweis.aufnahme.brennstoff_1}, ${ausweis.aufnahme.brennstoff_2 || ""}`)
+		fillFormField("energietraeger_warmwasser", `${aufnahme.brennstoff_1}, ${aufnahme.brennstoff_2 || ""}`)
 	}
 
-	toggleCheck("fensterlueftung", ausweis.aufnahme.lueftung == Enums.Lueftungskonzept.Fensterlueftung)
+	toggleCheck("fensterlueftung", aufnahme.lueftung == Enums.Lueftungskonzept.Fensterlueftung)
-	toggleCheck("schachtlueftung", ausweis.aufnahme.lueftung == Enums.Lueftungskonzept.Schachtlueftung)
+	toggleCheck("schachtlueftung", aufnahme.lueftung == Enums.Lueftungskonzept.Schachtlueftung)
-	toggleCheck("lueftungsanlage_ohne_waermerueckgewinnung", ausweis.aufnahme.lueftung == Enums.Lueftungskonzept.LueftungsanlageOhneWaermerueckgewinnung)
+	toggleCheck("lueftungsanlage_ohne_waermerueckgewinnung", aufnahme.lueftung == Enums.Lueftungskonzept.LueftungsanlageOhneWaermerueckgewinnung)
-	toggleCheck("lueftungsanlage_waermerueckgewinnung", ausweis.aufnahme.lueftung == Enums.Lueftungskonzept.LueftungsanlageMitWaermerueckgewinnung)
+	toggleCheck("lueftungsanlage_waermerueckgewinnung", aufnahme.lueftung == Enums.Lueftungskonzept.LueftungsanlageMitWaermerueckgewinnung)
 
 	toggleCheck("anlass_neubau", ausweis.ausstellgrund == "Neubau")
 	toggleCheck("anlass_vermietung", ausweis.ausstellgrund == "Vermietung" || ausweis.ausstellgrund == "Verkauf")
 	toggleCheck("anlass_modernisierung", ausweis.ausstellgrund == "Modernisierung")
 	toggleCheck("anlass_sonstiges", ausweis.ausstellgrund == "Sonstiges")
 
-	const gebaeudeBild = ausweis.aufnahme.objekt.gebaeude_bilder?.find(image => image.kategorie === "Gebaeude");
+	const gebaeudeBild = bilder.find(image => image.kategorie === "Gebaeude");
 	
 
 	/* -------------------------------- Seite 2 -------------------------------- */
@@ -247,7 +247,7 @@ export async function pdfVerbrauchsausweisWohnen(ausweis: VerbrauchsausweisWohne
 	addVerbrauch(
 		moment(ausweis.startdatum).format("MM.YYYY"),
 		moment(ausweis.startdatum).add(1, "year").format("MM.YYYY"),
-		ausweis.aufnahme.brennstoff_1,
+		aufnahme.brennstoff_1,
 		berechnungen?.primaerfaktorww.toString(),
 		Math.round(berechnungen?.verbrauch_1_kwh).toString(),
 		Math.round(
@@ -262,7 +262,7 @@ export async function pdfVerbrauchsausweisWohnen(ausweis: VerbrauchsausweisWohne
 	addVerbrauch(
 		moment(ausweis.startdatum).add(1, "year").format("MM.YYYY"),
 		moment(ausweis.startdatum).add(2, "year").format("MM.YYYY"),
-		ausweis.aufnahme.brennstoff_1,
+		aufnahme.brennstoff_1,
 		berechnungen?.primaerfaktorww.toString(),
 		Math.round(berechnungen?.verbrauch_2_kwh).toString(),
 		Math.round(
@@ -277,7 +277,7 @@ export async function pdfVerbrauchsausweisWohnen(ausweis: VerbrauchsausweisWohne
 	addVerbrauch(
 		moment(ausweis.startdatum).add(2, "year").format("MM.YYYY"),
 		moment(ausweis.startdatum).add(3, "year").format("MM.YYYY"),
-		ausweis.aufnahme.brennstoff_1,
+		aufnahme.brennstoff_1,
 		berechnungen?.primaerfaktorww.toString(),
 		Math.round(berechnungen?.verbrauch_3_kwh).toString(),
 		Math.round(

src/pages/api/verbrauchsausweis-gewerbe/[uid].ts

@@ -0,0 +1,217 @@
+import { OptionalNullable, UUidWithPrefix, VerbrauchsausweisGewerbeClient, ZodOverlap } from "#components/Ausweis/types.js";
+import { exclude } from "#lib/exclude.js";
+import { authorizationHeaders, authorizationMiddleware } from "#lib/middleware/authorization.js";
+import { prisma, VerbrauchsausweisGewerbeSchema } from "@ibcornelsen/database/server";
+import { APIError, defineApiRoute } from "astro-typesafe-api/server";
+import { z } from "zod";
+
+export const PATCH = defineApiRoute({
+	input: VerbrauchsausweisGewerbeSchema.omit({
+		uid: true,
+		id: true,
+		benutzer_id: true,
+		aufnahme_id: true,
+	}),
+	output: z.void(),
+	headers: {
+		"Authorization": z.string()
+	},
+	middleware: authorizationMiddleware,
+	async fetch(input, ctx, user) {
+		const objekt = await prisma.verbrauchsausweisGewerbe.findUnique({
+			where: {
+				uid: ctx.params.uid,
+				benutzer: {
+					id: user.id
+				}
+			}
+		})
+
+		if (!objekt) {
+			throw new APIError({
+				code: "NOT_FOUND",
+				message: "Ausweis konnte nicht gefunden werden oder gehört einem anderen Benutzer."
+			})
+		}
+
+		await prisma.verbrauchsausweisGewerbe.update({
+			where: {
+				uid: ctx.params.uid
+			},
+			data: input
+		})
+	},
+})
+
+export const DELETE = defineApiRoute({
+	meta: {
+		description: "Storniert einen Ausweis"
+	},
+	headers: authorizationHeaders,
+	middleware: authorizationMiddleware,
+	async fetch(input, ctx, user) {
+		const { uid } = ctx.params;
+
+		if (!UUidWithPrefix.safeParse(uid).success) {
+			throw new APIError({
+				code: "BAD_REQUEST",
+				message: "UID konnte nicht verifiziert werden."
+			})
+		}
+
+		// Wir holen uns den Verbrauchsausweis
+		// Dieser MUSS mit dem Nutzer verknüpft sein.
+		const ausweis = await prisma.verbrauchsausweisGewerbe.findUnique({
+			where: {
+				uid,
+			},
+			include: {
+				aufnahme: {
+					select: {
+						storniert: true
+					}
+				}
+			}
+		});
+
+		if (!ausweis) {
+			// Falls wir den Ausweis nicht finden können, werfen wir einen Fehler
+			throw new APIError({
+				code: "NOT_FOUND",
+				message: "Ausweis konnte nicht gefunden werden.",
+			});
+		}
+
+		// Wir dürfen den Ausweis nur stornieren, wenn er noch nicht ausgestellt wurde
+		// Außerdem müssen wir schauen, ob wir Admin oder der Besitzer des Ausweises sind.
+		if ((ausweis.benutzer_id !== user.id) && user.rolle !== "ADMIN") {
+			// Falls der Ausweis nicht dem Nutzer gehört, werfen wir einen Fehler
+			throw new APIError({
+				code: "FORBIDDEN",
+				message: "Ausweis gehört nicht dem Nutzer.",
+			});
+		}
+
+		// if (ausweis.erledigt) {
+		// 	// Falls der Ausweis bereits ausgestellt wurde, werfen wir einen Fehler
+		// 	throw new TRPCError({
+		// 		code: "BAD_REQUEST",
+		// 		message: "Ausweis wurde bereits ausgestellt.",
+		// 	});
+		// }
+
+		if (ausweis.aufnahme.storniert) {
+			// Falls der Ausweis bereits storniert ist, werfen wir einen Fehler
+			throw new APIError({
+				code: "BAD_REQUEST",
+				message: "Ausweis wurde bereits storniert.",
+			});
+		}
+
+		await prisma.aufnahme.update({
+			where: {
+				id: ausweis.aufnahme_id
+			},
+			data: {
+				storniert: true
+			}
+		})
+
+		// Wir erstellen ein Event, dass der Ausweis storniert wurde
+		// Dann können wir das in der Historie anzeigen
+		await prisma.event.create({
+			data: {
+				title: "Ausweis storniert",
+				description: ((user.rolle === "ADMIN") && (ausweis.benutzer_id !== user.id)) ? "Ausweis wurde von einem Administrator storniert." : "Ausweis wurde vom Besitzer storniert.",
+				benutzer: {
+					connect: {
+						id: user.id
+					}
+				},
+				aufnahme: {
+					connect: {
+						id: ausweis.aufnahme_id
+					}
+				}
+			}
+		})
+	},
+})
+
+export const GET = defineApiRoute({
+	meta: {
+		description: "Gibt ein spezifisches Gebäude des Benutzers zurück.",
+		tags: ["Gebäude"],
+		headers: {
+			"Authorization": {
+				description: "Ein gültiger Authentifizierungstoken",
+				required: true,
+				allowEmptyValue: false,
+				examples: {
+					Bearer: {
+						value: "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
+					}
+				}
+			}
+		}
+	},
+	output: ZodOverlap<OptionalNullable<VerbrauchsausweisGewerbeClient>>(VerbrauchsausweisGewerbeSchema.merge(z.object({
+		uid_aufnahme: UUidWithPrefix,
+		uid_objekt: UUidWithPrefix,
+		uid_benutzer: UUidWithPrefix.optional()
+	})).omit({
+		id: true,
+		aufnahme_id: true,
+		benutzer_id: true
+	})),
+	middleware: authorizationMiddleware,
+	async fetch(input, context, user) {
+		const { uid } = context.params;
+
+		if (!uid) {
+			throw new APIError({
+				code: "BAD_REQUEST",
+				message: "Missing uid in request params"
+			})
+		}
+
+		const ausweis = await prisma.verbrauchsausweisGewerbe.findUnique({
+			where: {
+				uid,
+				benutzer_id: user.id
+			},
+			include: {
+				benutzer: {
+					select: {
+						uid: true
+					}
+				},
+				aufnahme: {
+					select: {
+						uid: true,
+						objekt: {
+							select: {
+								uid: true
+							}
+						}
+					}
+				}
+			}
+		});
+
+		if (!ausweis) {
+			// Falls wir den Ausweis nicht finden können, werfen wir einen Fehler
+			throw new APIError({
+				code: "NOT_FOUND",
+				message: "Ausweis konnte nicht gefunden werden.",
+			});
+		}
+
+		return {
+			uid_aufnahme: ausweis.aufnahme.uid,
+			uid_objekt: ausweis.aufnahme.objekt.uid,
+			uid_benutzer: ausweis.benutzer?.uid,
+			...exclude(ausweis, ["id", "aufnahme_id", "benutzer_id", "aufnahme"])
+		}
+	},
+});

src/pages/api/verbrauchsausweis-gewerbe/index.ts

@@ -0,0 +1,150 @@
+import { UUidWithPrefix } from "#components/Ausweis/types.js";
+import { authorizationHeaders, authorizationMiddleware } from "#lib/middleware/authorization.js";
+import { prisma, VerbrauchsausweisGewerbeSchema } from "@ibcornelsen/database/server";
+import { APIError, defineApiRoute } from "astro-typesafe-api/server";
+import { z } from "zod";
+
+export const PATCH = defineApiRoute({
+	fetch(input, context) {},
+});
+
+export const PUT = defineApiRoute({
+	meta: {
+		contentTypes: ["application/json"],
+		description:
+			"Erstellt einen neuen Verbrauchsausweis für Gewerbegebäude nach dem Schema der EnEV von 2016. Als Input wird ein bestehendes Gebäude benötigt. Falls keine UID einer bestehenden Gebäudeaufnahme mitgegeben wird, wird automatisch eine erstellt.",
+		tags: ["Verbrauchsausweis Wohnen"],
+	},
+	input: z.object({
+		ausweis: VerbrauchsausweisGewerbeSchema.omit({
+			id: true,
+			benutzer_id: true,
+			uid: true,
+			aufnahme_id: true
+		}),
+		uid_aufnahme: UUidWithPrefix
+	}),
+	output: z.object({
+		uid: UUidWithPrefix,
+		objekt_uid: UUidWithPrefix,
+		aufnahme_uid: UUidWithPrefix,
+	}),
+	headers: authorizationHeaders,
+	middleware: authorizationMiddleware,
+	async fetch(input, ctx, user) {
+		const aufnahme = await prisma.aufnahme.findUnique({
+			where: {
+				uid: input.uid_aufnahme
+			}
+		})
+
+		if (!aufnahme || aufnahme.benutzer_id !== user.id) {
+			throw new APIError({
+				code: "FORBIDDEN",
+				message: "Aufnahme konnte nicht gefunden werden oder gehört nicht zu diesem Benutzer."
+			})
+		}
+
+			const createdAusweis = await prisma.verbrauchsausweisGewerbe.create({
+				data: {
+					...input.ausweis,
+					benutzer: {
+						connect: {
+							id: user.id,
+						},
+					},
+					aufnahme: {
+						connect: {
+							uid: aufnahme.uid,
+						},
+					},
+				},
+				select: {
+					uid: true,
+					aufnahme: {
+						select: {
+							uid: true,
+							objekt: {
+								select: {
+									uid: true,
+								},
+							},
+						},
+					},
+				},
+			});
+
+			return {
+				uid: createdAusweis.uid,
+				objekt_uid: createdAusweis.aufnahme.objekt.uid,
+				aufnahme_uid: createdAusweis.aufnahme.uid,
+			};
+	},
+});
+
+export const GET = defineApiRoute({
+	meta: {
+		description: "Gibt ein spezifisches Gebäude des Benutzers zurück.",
+		tags: ["Gebäude"],
+		headers: {
+			Authorization: {
+				description: "Ein gültiger Authentifizierungstoken",
+				required: true,
+				allowEmptyValue: false,
+				examples: {
+					Bearer: {
+						value: "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
+					},
+				},
+			},
+		},
+	},
+	middleware: authorizationMiddleware,
+	async fetch(input, context, user) {
+		const { uid } = context.params;
+
+		const ausweis = await prisma.verbrauchsausweisGewerbe.findUnique({
+			where: {
+				uid,
+			},
+			include: {
+				benutzer: true,
+				aufnahme: {
+					include: {
+						objekt: {
+							include: {
+								gebaeude_bilder: true,
+							},
+						},
+						rechnungen: true,
+						events: {
+							include: {
+								benutzer: {
+									select: {
+										uid: true,
+									},
+								},
+							},
+							orderBy: {
+								date: "asc",
+							},
+						},
+					},
+				},
+			},
+		});
+
+		if (
+			!ausweis ||
+			(ausweis.benutzer_id !== null && ausweis.benutzer_id !== user.id)
+		) {
+			// Falls wir den Ausweis nicht finden können, werfen wir einen Fehler
+			throw new APIError({
+				code: "NOT_FOUND",
+				message: "Ausweis konnte nicht gefunden werden.",
+			});
+		}
+
+		return ausweis;
+	},
+});

src/pages/pdf/ansichtsausweis.astro

@@ -1,10 +1,16 @@
 ---
-import { createCaller } from "#lib/caller";
+import { AufnahmeClient, BenutzerClient, getAusweisartFromUUID, ObjektClient, UploadedGebaeudeBild, VerbrauchsausweisGewerbeClient, VerbrauchsausweisWohnenClient } from "#components/Ausweis/types";
-import { VerbrauchsausweisWohnenClient } from "#components/Ausweis/types";
+import { API_ACCESS_TOKEN_COOKIE_NAME } from "#lib/constants";
 import { pdfVerbrauchsausweisWohnen } from "#lib/pdf/pdfVerbrauchsausweisWohnen";
+import { Enums } from "@ibcornelsen/database/client";
+import { createCaller } from "src/astro-typesafe-api-caller";
 
 const base64 = Astro.url.searchParams.get("base64");
-let ausweis: VerbrauchsausweisWohnenClient | null = null;
+let ausweis: VerbrauchsausweisWohnenClient | VerbrauchsausweisGewerbeClient | null = null;
+let aufnahme: AufnahmeClient = {} as AufnahmeClient;
+let objekt: ObjektClient = {} as ObjektClient;
+let user: BenutzerClient = {} as BenutzerClient;
+let images: UploadedGebaeudeBild[] = []
 if (base64) {
 	const buffer = Buffer.from(base64, "base64");
 	const json = buffer.toString("utf-8");
@@ -16,14 +22,61 @@ if (base64) {
 		return Astro.redirect("/404");
 	}
 
+	const ausweisart = getAusweisartFromUUID(uidAusweis)
+
 	const caller = createCaller(Astro);
 
-	ausweis = await caller.v1.verbrauchsausweisWohnen.get({
+	if (ausweisart === Enums.Ausweisart.VerbrauchsausweisWohnen) {
-		uid: uidAusweis
+		ausweis = await caller["verbrauchsausweis-wohnen"]._uid.GET.fetch(undefined, {
+			params: {
+				uid: uidAusweis
+			},
+			headers: {
+				Authorization: `Bearer ${Astro.cookies.get(API_ACCESS_TOKEN_COOKIE_NAME)?.value}`
+			}
+		});
+	} else if (ausweisart === Enums.Ausweisart.VerbrauchsausweisGewerbe) {
+		ausweis = await caller["verbrauchsausweis-gewerbe"]._uid.GET.fetch(undefined, {
+			params: {
+				uid: uidAusweis
+			},
+			headers: {
+				Authorization: `Bearer ${Astro.cookies.get(API_ACCESS_TOKEN_COOKIE_NAME)?.value}`
+			}
+		});
+	}
+
+
+	if (!ausweis) {
+		return Astro.redirect("/");
+	}
+
+	aufnahme = await caller.aufnahme._uid.GET.fetch(undefined, {
+		params: {
+			uid: ausweis.uid_aufnahme
+		},
+		headers: {
+			Authorization: `Bearer ${Astro.cookies.get(API_ACCESS_TOKEN_COOKIE_NAME)?.value}`
+		}
+	});
+
+	objekt = await caller.objekt._uid.GET.fetch(undefined, {
+		params: {
+			uid: ausweis.uid_objekt
+		},
+		headers: {
+			Authorization: `Bearer ${Astro.cookies.get(API_ACCESS_TOKEN_COOKIE_NAME)?.value}`
+		}
+	});
+
+	user = await caller.user.self.GET.fetch(undefined, {
+		headers: {
+			Authorization: `Bearer ${Astro.cookies.get(API_ACCESS_TOKEN_COOKIE_NAME)?.value}`
+		}
 	});
 }
 
-const pdf = await pdfVerbrauchsausweisWohnen(ausweis);
+const pdf = await pdfVerbrauchsausweisWohnen(ausweis, aufnahme, objekt, images, user);
 
 return new Response(pdf, {
 	headers: {