Musterdatei prüfen void inspectSample(event.target.files?.[0])} />{sampleStatus ?
{sampleStatus}
: null}
{(["headerRow", "firstDataRow", "firstDataColumn"] as const).map((key) =>
{key === "headerRow" ? "Kopfzeile" : key === "firstDataRow" ? "Erste Datenzeile" : "Erste Datenspalte"}
)}
diff --git a/src/frontend/types.ts b/src/frontend/types.ts
index 49466f5..a4239b1 100644
--- a/src/frontend/types.ts
+++ b/src/frontend/types.ts
@@ -126,6 +126,29 @@ export interface ExternalProjectObjectsDto {
objects: ExternalProjectObjectDto[];
}
+export type ExternalReturnScopeDto = "all" | "deviating" | "selected";
+
+export interface ExternalReturnWorkbookDto {
+ fileName: string;
+ contentBase64: string;
+ sha256: string;
+ objectCount: number;
+ warnings: string[];
+}
+
+export interface ExternalExportBatchDto {
+ id: string;
+ projectId: string;
+ projectRevision: number;
+ importBatchId: string;
+ exportedAtIso: string;
+ fileName: string;
+ sha256: string;
+ configurationSha256: string;
+ scope: ExternalReturnScopeDto;
+ objectCount: number;
+}
+
export interface ProjectDto {
id: string;
name: string;
@@ -447,6 +470,7 @@ export interface CircuitTreeDeviceRowDto {
remark?: string;
overriddenFields?: string;
rowTotalPower: number;
+ externalObjectCount?: number;
}
export interface CircuitTreeProtectionDeviceDto {
diff --git a/src/frontend/utils/api.ts b/src/frontend/utils/api.ts
index c46f80b..c873ef3 100644
--- a/src/frontend/utils/api.ts
+++ b/src/frontend/utils/api.ts
@@ -44,6 +44,8 @@ import type {
ExternalInitialImportStatusDto,
ApplyExternalInitialImportInput,
ExternalProjectObjectsDto,
+ ExternalReturnScopeDto,
+ ExternalReturnWorkbookDto,
CreateEstimateBalanceInput,
EstimateBalanceCommandResultDto,
EstimateBalanceDto,
@@ -245,6 +247,44 @@ export function updateExternalProjectObjects(projectId: string, expectedRevision
return request
(`/api/projects/${projectId}/external-model/objects`, { method: "PUT", body: JSON.stringify({ expectedRevision, objectIds, patch }) });
}
+export function createExternalReturnWorkbook(
+ projectId: string,
+ expectedRevision: number,
+ scope: ExternalReturnScopeDto,
+ selectedObjectIds: string[]
+) {
+ return request(`/api/projects/${projectId}/external-model/return-workbook`, {
+ method: "POST",
+ body: JSON.stringify({ expectedRevision, scope, selectedObjectIds }),
+ });
+}
+
+export function assignExternalProjectObjectsToRow(projectId: string, expectedRevision: number, objectIds: string[], rowId: string, confirmedConflictObjectIds: string[] = []) {
+ return request(`/api/projects/${projectId}/external-model/objects/assign-row`, {
+ method: "POST",
+ body: JSON.stringify({ expectedRevision, objectIds, rowId, confirmedConflictObjectIds }),
+ });
+}
+
+export function detachExternalProjectObjectsFromRow(projectId: string, expectedRevision: number, objectIds: string[]) {
+ return request(`/api/projects/${projectId}/external-model/objects/detach-row`, {
+ method: "POST",
+ body: JSON.stringify({ expectedRevision, objectIds }),
+ });
+}
+
+export function assignExternalProjectObjectsToNewRow(projectId: string, expectedRevision: number, objectIds: string[], circuitId: string) {
+ return request(`/api/projects/${projectId}/external-model/objects/assign-new-row`, {
+ method: "POST", body: JSON.stringify({ expectedRevision, objectIds, circuitId }),
+ });
+}
+
+export function assignExternalProjectObjectsToNewCircuit(projectId: string, expectedRevision: number, objectIds: string[], sectionId: string) {
+ return request(`/api/projects/${projectId}/external-model/objects/assign-new-circuit`, {
+ method: "POST", body: JSON.stringify({ expectedRevision, objectIds, sectionId }),
+ });
+}
+
export function getProjectHistory(projectId: string) {
return request(
`/api/projects/${projectId}/history`
diff --git a/src/server/composition/application-repositories.ts b/src/server/composition/application-repositories.ts
index a165a30..002a784 100644
--- a/src/server/composition/application-repositories.ts
+++ b/src/server/composition/application-repositories.ts
@@ -15,6 +15,7 @@ import { ProjectRepository } from "../../db/repositories/project.repository.js";
import { RoomRepository } from "../../db/repositories/room.repository.js";
import { ExternalModelConfigurationRepository } from "../../db/repositories/external-model-configuration.repository.js";
import { ExternalModelStateRepository } from "../../db/repositories/external-model-state.repository.js";
+import { ExternalExportBatchRepository } from "../../db/repositories/external-export-batch.repository.js";
import { DocumentBrandingRepository } from "../../db/repositories/document-branding.repository.js";
import { UserRepository } from "../../db/repositories/user.repository.js";
@@ -39,5 +40,6 @@ export const roomRepository = new RoomRepository(db);
export const externalModelConfigurationRepository =
new ExternalModelConfigurationRepository(db);
export const externalModelStateRepository = new ExternalModelStateRepository(db);
+export const externalExportBatchRepository = new ExternalExportBatchRepository(db);
export const documentBrandingRepository = new DocumentBrandingRepository(db);
export const userRepository = new UserRepository(db);
diff --git a/src/server/controllers/circuit-tree.controller.ts b/src/server/controllers/circuit-tree.controller.ts
index 17ac134..d1fb7f6 100644
--- a/src/server/controllers/circuit-tree.controller.ts
+++ b/src/server/controllers/circuit-tree.controller.ts
@@ -14,6 +14,7 @@ import {
circuitSectionRepository,
distributionBoardComponentRepository,
distributionBoardRepository,
+ externalModelStateRepository,
projectRepository,
} from "../composition/application-repositories.js";
@@ -88,6 +89,13 @@ export async function buildProjectCircuitTrees(
circuitListRepository.listByProject(projectId),
distributionBoardRepository.listByProject(projectId),
]);
+ const externalState = externalModelStateRepository.getByProject(projectId).state;
+ const externalCountByRowId = new Map();
+ for (const object of externalState.objects) {
+ if (object.circuitDeviceRowId) {
+ externalCountByRowId.set(object.circuitDeviceRowId, (externalCountByRowId.get(object.circuitDeviceRowId) ?? 0) + 1);
+ }
+ }
const listIds = lists.map((entry) => entry.id);
const [sections, circuits, components] = await Promise.all([
circuitSectionRepository.listByCircuitLists(listIds),
@@ -237,6 +245,7 @@ export async function buildProjectCircuitTrees(
row.powerPerUnit,
row.simultaneityFactor
),
+ externalObjectCount: externalCountByRowId.get(row.id) ?? 0,
}));
const circuitLoad = loads.circuits.get(circuit.id);
if (!circuitLoad) throw new Error("Circuit load is missing.");
diff --git a/src/server/controllers/external-objects.controller.ts b/src/server/controllers/external-objects.controller.ts
index f56f7be..8e90673 100644
--- a/src/server/controllers/external-objects.controller.ts
+++ b/src/server/controllers/external-objects.controller.ts
@@ -1,9 +1,17 @@
import type { Request, Response } from "express";
+import { randomUUID } from "node:crypto";
import { createExternalObjectPlanningUpdateProjectCommand } from "../../domain/models/external-object-planning-project-command.model.js";
+import { createExternalObjectRowAssignmentProjectCommand } from "../../domain/models/external-object-row-assignment-project-command.model.js";
+import type { CircuitDeviceRowSnapshot } from "../../domain/models/circuit-device-row-structure-project-command.model.js";
import type { ExternalModelObjectPlanningValues } from "../../external-model/domain/external-model-contracts.js";
import { distributionBoardRepository, externalModelStateRepository, projectDeviceRepository, projectRepository } from "../composition/application-repositories.js";
import { projectCommandService } from "../composition/project-command-stores.js";
import { respondWithProjectCommandError } from "./project-command.controller.js";
+import { buildProjectCircuitTrees } from "./circuit-tree.controller.js";
+import { createExternalObjectNewRowProjectCommand, externalObjectAssignToNewRowCommandType } from "../../domain/models/external-object-new-row-project-command.model.js";
+import { createExternalObjectNewCircuitProjectCommand, externalObjectAssignToNewCircuitCommandType } from "../../domain/models/external-object-new-circuit-project-command.model.js";
+import { createDefaultCircuitProtection } from "../../domain/services/protection-device-defaults.js";
+import { circuitNumberingService } from "../composition/circuit-numbering-service.js";
export async function listExternalObjects(req: Request, res: Response) {
const projectId = String(req.params.projectId ?? "");
@@ -49,6 +57,221 @@ export function updateExternalObjects(req: Request, res: Response) {
} catch (error) { return respondWithProjectCommandError(error, res); }
}
+export async function assignExternalObjectsToRow(req: Request, res: Response) {
+ const projectId = String(req.params.projectId ?? "");
+ try {
+ const expectedRevision = parseExpectedRevision(req.body?.expectedRevision);
+ const objectIds = parseObjectIds(req.body?.objectIds);
+ const rowId = requiredId(req.body?.rowId, "Ungültige Gerätezeile.");
+ const confirmedConflictObjectIds = Array.isArray(req.body?.confirmedConflictObjectIds)
+ ? req.body.confirmedConflictObjectIds.map((value: unknown) => requiredId(value, "Ungültige Konfliktbestätigung."))
+ : [];
+ const { state, projectExists } = externalModelStateRepository.getByProject(projectId);
+ if (!projectExists) return res.status(404).json({ error: "Projekt nicht gefunden." });
+ const treeResult = await buildProjectCircuitTrees(projectId);
+ const location = findRow(treeResult, rowId);
+ if (!location) throw new Error("Gerätezeile wurde nicht gefunden.");
+ const byId = new Map(state.objects.map((object) => [object.id, object]));
+ const selected = objectIds.map((id) => {
+ const object = byId.get(id);
+ if (!object) throw new Error("Ein Revit-Objekt wurde nicht gefunden.");
+ if (object.circuitDeviceRowId !== null) throw new Error("Ein Revit-Objekt ist bereits einer Gerätezeile zugeordnet.");
+ return object;
+ });
+ const expectedRow = toRowSnapshot(location.row, location.circuitId);
+ const addedQuantity = selected.reduce((sum, object) => sum + object.planningValues.effectiveQuantity, 0);
+ const targetRow = { ...expectedRow, quantity: expectedRow.quantity + addedQuantity };
+ const objects = selected.map((expected) => ({
+ expected,
+ target: { ...expected, distributionBoardId: location.distributionBoardId, circuitDeviceRowId: rowId },
+ }));
+ const result = projectCommandService.executeUser({
+ projectId,
+ expectedRevision,
+ description: `${objects.length} Revit-Objekte zugeordnet`,
+ command: createExternalObjectRowAssignmentProjectCommand({
+ rows: [{ expected: expectedRow, target: targetRow }],
+ objects,
+ confirmedConflictObjectIds,
+ }),
+ });
+ return res.json(result);
+ } catch (error) { return respondWithProjectCommandError(error, res); }
+}
+
+export async function detachExternalObjectsFromRow(req: Request, res: Response) {
+ const projectId = String(req.params.projectId ?? "");
+ try {
+ const expectedRevision = parseExpectedRevision(req.body?.expectedRevision);
+ const objectIds = parseObjectIds(req.body?.objectIds);
+ const { state, projectExists } = externalModelStateRepository.getByProject(projectId);
+ if (!projectExists) return res.status(404).json({ error: "Projekt nicht gefunden." });
+ const treeResult = await buildProjectCircuitTrees(projectId);
+ const byId = new Map(state.objects.map((object) => [object.id, object]));
+ const selected = objectIds.map((id) => {
+ const object = byId.get(id);
+ if (!object?.circuitDeviceRowId) throw new Error("Ein Revit-Objekt ist keiner Gerätezeile zugeordnet.");
+ return object;
+ });
+ const rowIds = new Set(selected.map((object) => object.circuitDeviceRowId!));
+ if (rowIds.size !== 1) throw new Error("Revit-Objekte können nur aus derselben Gerätezeile gemeinsam gelöst werden.");
+ const rowId = [...rowIds][0]!;
+ const location = findRow(treeResult, rowId);
+ if (!location) throw new Error("Gerätezeile wurde nicht gefunden.");
+ const expectedRow = toRowSnapshot(location.row, location.circuitId);
+ const removedQuantity = selected.reduce((sum, object) => sum + object.planningValues.effectiveQuantity, 0);
+ const targetRow = { ...expectedRow, quantity: expectedRow.quantity - removedQuantity };
+ const copiedFields = ["displayName", "category", "connectionKind", "powerPerUnitW", "simultaneityFactor", "cosPhi", "costGroup", "remark"] as const;
+ const objects = selected.map((expected) => ({
+ expected,
+ target: {
+ ...expected,
+ circuitDeviceRowId: null,
+ distributionBoardId: location.distributionBoardId,
+ linkedProjectDeviceId: expectedRow.linkedProjectDeviceId,
+ planningValues: {
+ ...expected.planningValues,
+ displayName: expectedRow.displayName,
+ category: location.category,
+ connectionKind: expectedRow.connectionKind,
+ powerPerUnitW: expectedRow.powerPerUnit * 1000,
+ simultaneityFactor: expectedRow.simultaneityFactor,
+ cosPhi: expectedRow.cosPhi,
+ costGroup: expectedRow.costGroup,
+ remark: expectedRow.remark,
+ },
+ overriddenFields: [...new Set([...expected.overriddenFields, ...copiedFields])],
+ },
+ }));
+ const result = projectCommandService.executeUser({
+ projectId,
+ expectedRevision,
+ description: `${objects.length} Revit-Objekte gelöst`,
+ command: createExternalObjectRowAssignmentProjectCommand({
+ rows: [{ expected: expectedRow, target: targetRow }],
+ objects,
+ confirmedConflictObjectIds: [],
+ }),
+ });
+ return res.json(result);
+ } catch (error) { return respondWithProjectCommandError(error, res); }
+}
+
+export async function assignExternalObjectsToNewRow(req: Request, res: Response) {
+ const projectId = String(req.params.projectId ?? "");
+ try {
+ const expectedRevision = parseExpectedRevision(req.body?.expectedRevision);
+ const objectIds = parseObjectIds(req.body?.objectIds);
+ const circuitId = requiredId(req.body?.circuitId, "Ungültiger Stromkreis.");
+ const context = await loadAssignmentContext(projectId, objectIds);
+ const circuitLocation = context.treeResult?.trees.flatMap((tree) => tree.sections.flatMap((section) => section.circuits.map((circuit) => ({ tree, section, circuit })))).find((entry) => entry.circuit.id === circuitId);
+ if (!circuitLocation || !circuitLocation.section.category) throw new Error("Stromkreis wurde nicht gefunden.");
+ const row = buildExternalRow(context.objects, context.roomId, circuitId, Math.max(0, ...circuitLocation.circuit.deviceRows.map((entry) => entry.sortOrder)) + 10);
+ const transitions = context.objects.map((expected) => ({ expected, target: { ...expected, distributionBoardId: circuitLocation.tree.distributionBoardId, circuitDeviceRowId: row.id } }));
+ const result = projectCommandService.executeUser({ projectId, expectedRevision, description: `${transitions.length} Revit-Objekte als neue Gerätezeile zugeordnet`, command: createExternalObjectNewRowProjectCommand(externalObjectAssignToNewRowCommandType, { row, objects: transitions, confirmedConflictObjectIds: objectIds }) });
+ return res.json(result);
+ } catch (error) { return respondWithProjectCommandError(error, res); }
+}
+
+export async function assignExternalObjectsToNewCircuit(req: Request, res: Response) {
+ const projectId = String(req.params.projectId ?? "");
+ try {
+ const expectedRevision = parseExpectedRevision(req.body?.expectedRevision);
+ const objectIds = parseObjectIds(req.body?.objectIds);
+ const sectionId = requiredId(req.body?.sectionId, "Ungültige Stromkreisgruppe.");
+ const context = await loadAssignmentContext(projectId, objectIds);
+ const sectionLocation = context.treeResult?.trees.flatMap((tree) => tree.sections.map((section) => ({ tree, section }))).find((entry) => entry.section.id === sectionId);
+ if (!sectionLocation?.section.category) throw new Error("Stromkreisgruppe wurde nicht gefunden.");
+ const circuitId = randomUUID();
+ const row = buildExternalRow(context.objects, context.roomId, circuitId, 10);
+ const protection = createDefaultCircuitProtection(sectionLocation.section.category);
+ const circuit = {
+ id: circuitId,
+ circuitListId: sectionLocation.tree.circuitListId,
+ sectionId,
+ equipmentIdentifier: await circuitNumberingService.getNextIdentifier(sectionId),
+ displayName: null,
+ sortOrder: Math.max(0, ...sectionLocation.section.circuits.map((entry) => entry.sortOrder)) + 10,
+ cableType: null, cableCrossSection: null, cableLength: null, rcdAssignment: null,
+ terminalDesignation: null,
+ voltage: sectionLocation.section.category === "three_phase" ? sectionLocation.tree.threePhaseVoltageV : sectionLocation.tree.singlePhaseVoltageV,
+ controlRequirement: null, status: null, isReserve: false, remark: null,
+ deviceRows: [row],
+ protectionDevice: {
+ circuitId,
+ type: protection.type,
+ ratedCurrentA: protection.ratedCurrentA,
+ fuseUtilizationCategory: "fuseUtilizationCategory" in protection ? protection.fuseUtilizationCategory : null,
+ tripCharacteristic: "tripCharacteristic" in protection ? protection.tripCharacteristic : null,
+ rcdType: "rcdType" in protection ? protection.rcdType : null,
+ ratedResidualCurrentMa: "ratedResidualCurrentMa" in protection ? protection.ratedResidualCurrentMa : null,
+ },
+ };
+ const transitions = context.objects.map((expected) => ({ expected, target: { ...expected, distributionBoardId: sectionLocation.tree.distributionBoardId, circuitDeviceRowId: row.id } }));
+ const result = projectCommandService.executeUser({ projectId, expectedRevision, description: `${transitions.length} Revit-Objekte als neuen Stromkreis zugeordnet`, command: createExternalObjectNewCircuitProjectCommand(externalObjectAssignToNewCircuitCommandType, { circuit, objects: transitions, confirmedConflictObjectIds: objectIds }) });
+ return res.json(result);
+ } catch (error) { return respondWithProjectCommandError(error, res); }
+}
+
+async function loadAssignmentContext(projectId: string, objectIds: string[]) {
+ const { state, projectExists } = externalModelStateRepository.getByProject(projectId);
+ if (!projectExists) throw new Error("Projekt nicht gefunden.");
+ const byId = new Map(state.objects.map((object) => [object.id, object]));
+ const objects = objectIds.map((id) => {
+ const object = byId.get(id);
+ if (!object) throw new Error("Ein Revit-Objekt wurde nicht gefunden.");
+ if (object.circuitDeviceRowId !== null) throw new Error("Ein Revit-Objekt ist bereits zugeordnet.");
+ return object;
+ });
+ const roomIds = new Set(objects.map((object) => object.externalRoomMappingId === null ? null : state.roomMappings.find((mapping) => mapping.id === object.externalRoomMappingId)?.roomId ?? null));
+ if (roomIds.size !== 1) throw new Error("Revit-Objekte aus verschiedenen Räumen benötigen getrennte Gerätezeilen.");
+ return { objects, roomId: [...roomIds][0]!, treeResult: await buildProjectCircuitTrees(projectId) };
+}
+
+function buildExternalRow(objects: ReturnType["state"]["objects"], roomId: string | null, circuitId: string, sortOrder: number): CircuitDeviceRowSnapshot {
+ const first = objects[0]!;
+ const planning = first.planningValues;
+ const quantity = objects.reduce((sum, object) => sum + object.planningValues.effectiveQuantity, 0);
+ return {
+ id: randomUUID(), circuitId, linkedProjectDeviceId: first.linkedProjectDeviceId,
+ sortOrder, name: first.acceptedSourceValues.familyAndType,
+ displayName: planning.displayName ?? (scalarText(first.acceptedSourceValues.selectionMarker) || first.acceptedSourceValues.familyAndType),
+ phaseType: planning.category === "three_phase" ? "three_phase" : "single_phase",
+ connectionKind: planning.connectionKind, costGroup: planning.costGroup,
+ category: planning.category, level: null,
+ roomId,
+ roomNumberSnapshot: scalarText(first.acceptedSourceValues.roomNumber) || null,
+ roomNameSnapshot: scalarText(first.acceptedSourceValues.roomName) || null,
+ quantity, manualQuantity: 0,
+ powerPerUnit: (planning.powerPerUnitW ?? 0) / 1000,
+ simultaneityFactor: planning.simultaneityFactor ?? 1,
+ cosPhi: planning.cosPhi, remark: planning.remark, overriddenFields: null,
+ };
+}
+
+function parseExpectedRevision(value: unknown) {
+ if (!Number.isSafeInteger(value) || (value as number) < 0) throw new Error("Ungültige Projektrevision.");
+ return value as number;
+}
+function parseObjectIds(value: unknown): string[] {
+ if (!Array.isArray(value) || value.length === 0) throw new Error("Keine Revit-Objekte ausgewählt.");
+ const ids = value.map((entry) => requiredId(entry, "Ungültige Revit-Objekt-ID."));
+ if (new Set(ids).size !== ids.length) throw new Error("Revit-Objekte sind doppelt ausgewählt.");
+ return ids;
+}
+function requiredId(value: unknown, message: string) { if (typeof value !== "string" || !value) throw new Error(message); return value; }
+function findRow(result: Awaited>, rowId: string) {
+ if (!result) return null;
+ for (const tree of result.trees) for (const section of tree.sections) for (const circuit of section.circuits) {
+ const row = circuit.deviceRows.find((entry) => entry.id === rowId);
+ if (row) return { row, circuitId: circuit.id, distributionBoardId: tree.distributionBoardId, category: section.category ?? null };
+ }
+ return null;
+}
+function toRowSnapshot(row: NonNullable>["row"], circuitId: string): CircuitDeviceRowSnapshot {
+ return { id: row.id, circuitId, linkedProjectDeviceId: row.linkedProjectDeviceId ?? null, sortOrder: row.sortOrder, name: row.name, displayName: row.displayName, phaseType: row.phaseType ?? null, connectionKind: row.connectionKind ?? null, costGroup: row.costGroup ?? null, category: row.category ?? null, level: row.level ?? null, roomId: row.roomId ?? null, roomNumberSnapshot: row.roomNumberSnapshot ?? null, roomNameSnapshot: row.roomNameSnapshot ?? null, quantity: row.quantity, manualQuantity: row.manualQuantity, powerPerUnit: row.powerPerUnit, simultaneityFactor: row.simultaneityFactor, cosPhi: row.cosPhi ?? null, remark: row.remark ?? null, overriddenFields: row.overriddenFields ?? null };
+}
+
const planningFields = ["displayName", "category", "connectionKind", "effectiveQuantity", "powerPerUnitW", "simultaneityFactor", "cosPhi", "costGroup", "remark"] as const satisfies readonly (keyof ExternalModelObjectPlanningValues)[];
function scalarText(value: string | number | boolean | null) { return value === null ? "" : String(value); }
function isRecord(value: unknown): value is Record { return value !== null && typeof value === "object" && !Array.isArray(value); }
diff --git a/src/server/controllers/external-return-workbook.controller.ts b/src/server/controllers/external-return-workbook.controller.ts
new file mode 100644
index 0000000..0db6d81
--- /dev/null
+++ b/src/server/controllers/external-return-workbook.controller.ts
@@ -0,0 +1,180 @@
+import { createHash, randomUUID } from "node:crypto";
+import type { Request, Response } from "express";
+import type { CircuitGroupCategory } from "../../shared/constants/circuit-group.js";
+import type { ExternalExportScope } from "../../db/schema/external-export-batches.js";
+import { projectExternalXlsxReturn, type ExternalReturnRowContext } from "../../external-model/application/external-xlsx-return-projection.js";
+import { createExternalXlsxReturn } from "../../external-model/xlsx/external-xlsx-transport.js";
+import {
+ externalExportBatchRepository,
+ externalModelStateRepository,
+ projectRepository,
+} from "../composition/application-repositories.js";
+import { buildProjectCircuitTrees } from "./circuit-tree.controller.js";
+
+const exportScopes = new Set(["all", "deviating", "selected"]);
+
+export async function createExternalReturnWorkbook(req: Request, res: Response) {
+ const projectId = String(req.params.projectId ?? "");
+ try {
+ const expectedRevision = parseExpectedRevision(req.body?.expectedRevision);
+ const scope = parseScope(req.body?.scope);
+ const selectedObjectIds = scope === "selected" ? parseSelectedIds(req.body?.selectedObjectIds) : [];
+ if (scope === "selected" && selectedObjectIds.length === 0) {
+ return res.status(400).json({ error: "Für die ausgewählte Rückgabe wurden keine Revit-Objekte markiert." });
+ }
+
+ const project = await projectRepository.findById(projectId);
+ if (!project) return res.status(404).json({ error: "Projekt nicht gefunden." });
+ if (project.currentRevision !== expectedRevision) {
+ return res.status(409).json({
+ error: "Die Rückgabe ist wegen einer neueren Projektrevision ungültig.",
+ code: "PROJECT_REVISION_CONFLICT",
+ expectedRevision,
+ currentRevision: project.currentRevision,
+ });
+ }
+
+ const { state } = externalModelStateRepository.getByProject(projectId);
+ const importBatch = state.importBatches.at(-1);
+ if (!importBatch?.originalContentBase64 || !importBatch.configurationSnapshot) {
+ return res.status(409).json({
+ error: "Für die Rückgabe fehlt der letzte vollständige Revit-Import.",
+ code: "EXTERNAL_XLSX_IMPORT_REQUIRED",
+ });
+ }
+ const treeResult = await buildProjectCircuitTrees(projectId);
+ if (!treeResult || treeResult.currentRevision !== expectedRevision) {
+ return res.status(409).json({
+ error: "Die Rückgabe ist wegen einer neueren Projektrevision ungültig.",
+ code: "PROJECT_REVISION_CONFLICT",
+ });
+ }
+
+ const rowById = new Map();
+ for (const tree of treeResult.trees) {
+ for (const section of tree.sections) {
+ for (const circuit of section.circuits) {
+ for (const row of circuit.deviceRows) {
+ rowById.set(row.id, {
+ rowId: row.id,
+ displayName: row.displayName,
+ powerPerUnitKw: row.powerPerUnit,
+ cosPhi: row.cosPhi ?? null,
+ phaseType: row.phaseType ?? null,
+ category: (section.category ?? null) as CircuitGroupCategory | null,
+ circuitIdentifier: circuit.equipmentIdentifier,
+ circuitVoltageV: circuit.voltage ?? null,
+ distributionBoardName: tree.distributionBoardName,
+ });
+ }
+ }
+ }
+ }
+
+ const projections = state.objects
+ .filter((object) => object.presenceStatus === "present" && object.lastSeenImportBatchId === importBatch.id)
+ .map((object) => projectExternalXlsxReturn({
+ object,
+ row: object.circuitDeviceRowId ? rowById.get(object.circuitDeviceRowId) ?? null : null,
+ circuitMode: importBatch.configurationSnapshot!.circuitMode,
+ singlePhaseVoltageV: project.singlePhaseVoltageV,
+ threePhaseVoltageV: project.threePhaseVoltageV,
+ }));
+ const projectionById = new Map(projections.map((projection) => [projection.objectId, projection]));
+ for (const objectId of selectedObjectIds) {
+ if (!projectionById.has(objectId)) {
+ return res.status(400).json({ error: "Ein ausgewähltes Revit-Objekt gehört nicht zum letzten Import." });
+ }
+ }
+ const selected = scope === "all"
+ ? projections
+ : scope === "deviating"
+ ? projections.filter((projection) => projection.differsFromImported)
+ : selectedObjectIds.map((id) => projectionById.get(id)!);
+ if (selected.length === 0) {
+ return res.status(400).json({ error: "Der gewählte Rückgabeumfang enthält keine Revit-Objekte." });
+ }
+
+ const result = await createExternalXlsxReturn({
+ fileName: importBatch.fileName,
+ bytes: Buffer.from(importBatch.originalContentBase64, "base64"),
+ configuration: importBatch.configurationSnapshot,
+ selectedWorksharingIds: selected.map((projection) => projection.worksharingId),
+ updates: selected.map((projection) => ({
+ worksharingId: projection.worksharingId,
+ values: projection.values,
+ })),
+ });
+ const fileName = `${safeFileName(project.name)}_Revit-Rueckgabe_${new Date().toISOString().slice(0, 10)}.xlsx`;
+ const sha256 = hash(result.bytes);
+ const configurationSha256 = hash(Buffer.from(JSON.stringify(importBatch.configurationSnapshot), "utf8"));
+ const currentProject = await projectRepository.findById(projectId);
+ if (!currentProject || currentProject.currentRevision !== expectedRevision) {
+ return res.status(409).json({
+ error: "Die Rückgabe ist wegen einer neueren Projektrevision ungültig.",
+ code: "PROJECT_REVISION_CONFLICT",
+ expectedRevision,
+ currentRevision: currentProject?.currentRevision ?? null,
+ });
+ }
+ externalExportBatchRepository.append({
+ id: randomUUID(),
+ projectId,
+ projectRevision: expectedRevision,
+ importBatchId: importBatch.id,
+ exportedAtIso: new Date().toISOString(),
+ fileName,
+ sha256,
+ configurationSnapshot: importBatch.configurationSnapshot,
+ configurationSha256,
+ scope,
+ objectCount: result.exportedObjectCount,
+ });
+
+ const projectionWarnings = selected.flatMap((projection) =>
+ projection.warnings.map((warning) => `${projection.worksharingId}: ${warning}`)
+ );
+ return res.json({
+ fileName,
+ contentBase64: Buffer.from(result.bytes).toString("base64"),
+ sha256,
+ objectCount: result.exportedObjectCount,
+ warnings: [...new Set([...result.issues.map((issue) => issue.message), ...projectionWarnings])],
+ });
+ } catch (error) {
+ return res.status(400).json({ error: error instanceof Error ? error.message : "Revit-Rückgabe fehlgeschlagen." });
+ }
+}
+
+export async function listExternalExportBatches(req: Request, res: Response) {
+ const projectId = String(req.params.projectId ?? "");
+ const project = await projectRepository.findById(projectId);
+ if (!project) return res.status(404).json({ error: "Projekt nicht gefunden." });
+ return res.json(externalExportBatchRepository.listByProject(projectId).map(({ configurationSnapshot: _configuration, ...batch }) => batch));
+}
+
+function parseExpectedRevision(value: unknown) {
+ if (!Number.isSafeInteger(value) || (value as number) < 0) throw new Error("Ungültige Projektrevision.");
+ return value as number;
+}
+
+function parseScope(value: unknown): ExternalExportScope {
+ if (typeof value !== "string" || !exportScopes.has(value as ExternalExportScope)) throw new Error("Ungültiger Rückgabeumfang.");
+ return value as ExternalExportScope;
+}
+
+function parseSelectedIds(value: unknown) {
+ if (value === undefined) return [];
+ if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string") || new Set(value).size !== value.length) {
+ throw new Error("Ungültige Objektauswahl.");
+ }
+ return value as string[];
+}
+
+function safeFileName(value: string) {
+ return value.trim().replace(/[<>:"/\\|?*\u0000-\u001f]/g, "_") || "Projekt";
+}
+
+function hash(bytes: Uint8Array) {
+ return createHash("sha256").update(bytes).digest("hex");
+}
diff --git a/src/server/routes/project.routes.ts b/src/server/routes/project.routes.ts
index 53c2225..436ff52 100644
--- a/src/server/routes/project.routes.ts
+++ b/src/server/routes/project.routes.ts
@@ -63,7 +63,8 @@ import {
getExternalInitialImportStatus,
planExternalInitialImport,
} from "../controllers/external-initial-import.controller.js";
-import { listExternalObjects, updateExternalObjects } from "../controllers/external-objects.controller.js";
+import { assignExternalObjectsToNewCircuit, assignExternalObjectsToNewRow, assignExternalObjectsToRow, detachExternalObjectsFromRow, listExternalObjects, updateExternalObjects } from "../controllers/external-objects.controller.js";
+import { createExternalReturnWorkbook, listExternalExportBatches } from "../controllers/external-return-workbook.controller.js";
export const projectRouter = Router();
@@ -93,6 +94,12 @@ projectRouter.post("/:projectId/external-model/initial-import/plan", planExterna
projectRouter.post("/:projectId/external-model/initial-import/apply", applyExternalInitialImport);
projectRouter.get("/:projectId/external-model/objects", listExternalObjects);
projectRouter.put("/:projectId/external-model/objects", updateExternalObjects);
+projectRouter.post("/:projectId/external-model/objects/assign-row", assignExternalObjectsToRow);
+projectRouter.post("/:projectId/external-model/objects/assign-new-row", assignExternalObjectsToNewRow);
+projectRouter.post("/:projectId/external-model/objects/assign-new-circuit", assignExternalObjectsToNewCircuit);
+projectRouter.post("/:projectId/external-model/objects/detach-row", detachExternalObjectsFromRow);
+projectRouter.post("/:projectId/external-model/return-workbook", createExternalReturnWorkbook);
+projectRouter.get("/:projectId/external-model/export-batches", listExternalExportBatches);
projectRouter.get("/:projectId/distribution-boards", listDistributionBoardsByProject);
projectRouter.post("/:projectId/distribution-boards", createDistributionBoard);
projectRouter.post(
diff --git a/tests/external-export-batch.repository.test.ts b/tests/external-export-batch.repository.test.ts
new file mode 100644
index 0000000..50278b6
--- /dev/null
+++ b/tests/external-export-batch.repository.test.ts
@@ -0,0 +1,40 @@
+import path from "node:path";
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { migrate } from "drizzle-orm/better-sqlite3/migrator";
+import { createDatabaseContext } from "../src/db/database-context.js";
+import { ExternalExportBatchRepository } from "../src/db/repositories/external-export-batch.repository.js";
+import { projects } from "../src/db/schema/projects.js";
+import { createDefaultExternalModelConfiguration } from "../src/external-model/configuration/external-model-configuration.js";
+
+describe("external export batch repository", () => {
+ it("appends immutable audit metadata without changing the project revision", () => {
+ const context = createDatabaseContext(":memory:");
+ try {
+ migrate(context.db, { migrationsFolder: path.resolve("src", "db", "migrations") });
+ context.db.insert(projects).values({ id: "project-1", name: "Projekt", currentRevision: 7 }).run();
+ const repository = new ExternalExportBatchRepository(context.db);
+ const configuration = createDefaultExternalModelConfiguration();
+ repository.append({
+ id: "export-1", projectId: "project-1", projectRevision: 7,
+ importBatchId: "historical-import-without-foreign-key", exportedAtIso: "2026-09-30T10:00:00.000Z",
+ fileName: "Projekt_Revit-Rueckgabe_2026-09-30.xlsx", sha256: "a".repeat(64),
+ configurationSnapshot: configuration, configurationSha256: "b".repeat(64), scope: "all", objectCount: 4,
+ });
+ configuration.columns.designation = "Nachträglich geändert";
+ repository.append({
+ id: "export-2", projectId: "project-1", projectRevision: 7,
+ importBatchId: "historical-import-without-foreign-key", exportedAtIso: "2026-09-30T11:00:00.000Z",
+ fileName: "Projekt_Revit-Rueckgabe_2026-09-30.xlsx", sha256: "c".repeat(64),
+ configurationSnapshot: configuration, configurationSha256: "d".repeat(64), scope: "selected", objectCount: 1,
+ });
+
+ const batches = repository.listByProject("project-1");
+ assert.deepEqual(batches.map((batch) => batch.id), ["export-2", "export-1"]);
+ assert.notEqual(batches[0]!.configurationSnapshot.columns.designation, batches[1]!.configurationSnapshot.columns.designation);
+ assert.equal(context.db.select({ revision: projects.currentRevision }).from(projects).get()!.revision, 7);
+ } finally {
+ context.close();
+ }
+ });
+});
diff --git a/tests/external-object-row-assignment-project-command.repository.test.ts b/tests/external-object-row-assignment-project-command.repository.test.ts
index 4512e90..547d60f 100644
--- a/tests/external-object-row-assignment-project-command.repository.test.ts
+++ b/tests/external-object-row-assignment-project-command.repository.test.ts
@@ -7,6 +7,9 @@ import { createDatabaseContext, type AppDatabase } from "../src/db/database-cont
import { ExternalObjectRowAssignmentProjectCommandRepository } from "../src/db/repositories/external-object-row-assignment-project-command.repository.js";
import { ExternalObjectNewRowProjectCommandRepository } from "../src/db/repositories/external-object-new-row-project-command.repository.js";
import { ExternalObjectNewCircuitProjectCommandRepository } from "../src/db/repositories/external-object-new-circuit-project-command.repository.js";
+import { CircuitDeviceRowStructureProjectCommandRepository } from "../src/db/repositories/circuit-device-row-structure-project-command.repository.js";
+import { CircuitStructureProjectCommandRepository } from "../src/db/repositories/circuit-structure-project-command.repository.js";
+import { CircuitGroupSubtreeProjectCommandRepository } from "../src/db/repositories/circuit-group-subtree-project-command.repository.js";
import { toCircuitDeviceRowSnapshot } from "../src/db/repositories/circuit-device-row-structure.persistence.js";
import { circuitDeviceRows } from "../src/db/schema/circuit-device-rows.js";
import { circuitLists } from "../src/db/schema/circuit-lists.js";
@@ -31,6 +34,10 @@ import {
externalObjectAssignToNewCircuitCommandType,
} from "../src/domain/models/external-object-new-circuit-project-command.model.js";
import type { ExternalModelObjectSnapshot } from "../src/external-model/domain/external-model-contracts.js";
+import { createCircuitDeviceRowDeleteProjectCommand } from "../src/domain/models/circuit-device-row-structure-project-command.model.js";
+import { createCircuitDeleteProjectCommand } from "../src/domain/models/circuit-structure-project-command.model.js";
+import { createCircuitGroupDeleteSubtreeProjectCommand } from "../src/domain/models/circuit-group-subtree-project-command.model.js";
+import { assertDistributionBoardHasNoExternalObjects, assertRoomHasNoExternalObjects } from "../src/db/repositories/external-object-deletion-guard.persistence.js";
function createFixture(initialObjectRowId: string | null = "row-1") {
const context = createDatabaseContext(":memory:");
@@ -626,4 +633,63 @@ describe("external object new-circuit project command", () => {
context.close();
}
});
+
+ it("detaches linked objects on row deletion and restores the exact link on undo", () => {
+ const context = createFixture();
+ try {
+ const repository = new CircuitDeviceRowStructureProjectCommandRepository(context.db);
+ const deleted = repository.execute({
+ projectId: "project-1",
+ expectedRevision: 0,
+ source: "user",
+ command: createCircuitDeviceRowDeleteProjectCommand("row-1", "circuit-1"),
+ });
+ assert.equal(context.db.select().from(externalModelObjects).get()!.circuitDeviceRowId, null);
+ assert.equal(context.db.select().from(circuitDeviceRows).where(eq(circuitDeviceRows.id, "row-1")).get(), undefined);
+
+ repository.execute({
+ projectId: "project-1",
+ expectedRevision: 1,
+ source: "undo",
+ historyTargetChangeSetId: deleted.revision.changeSetId,
+ command: deleted.inverse,
+ });
+ assert.equal(context.db.select().from(externalModelObjects).get()!.circuitDeviceRowId, "row-1");
+ assert.ok(context.db.select().from(circuitDeviceRows).where(eq(circuitDeviceRows.id, "row-1")).get());
+ } finally {
+ context.close();
+ }
+ });
+
+ it("preserves external links through circuit and populated-group deletion undo", () => {
+ for (const kind of ["circuit", "group"] as const) {
+ const context = createFixture();
+ try {
+ const repository = kind === "circuit"
+ ? new CircuitStructureProjectCommandRepository(context.db)
+ : new CircuitGroupSubtreeProjectCommandRepository(context.db);
+ const command = kind === "circuit"
+ ? createCircuitDeleteProjectCommand("circuit-1", "list-1")
+ : createCircuitGroupDeleteSubtreeProjectCommand(
+ (repository as CircuitGroupSubtreeProjectCommandRepository).capture("project-1", "section-1")
+ );
+ const deleted = repository.execute({ projectId: "project-1", expectedRevision: 0, source: "user", command } as never);
+ assert.equal(context.db.select().from(externalModelObjects).get()!.circuitDeviceRowId, null);
+ repository.execute({ projectId: "project-1", expectedRevision: 1, source: "undo", historyTargetChangeSetId: deleted.revision.changeSetId, command: deleted.inverse } as never);
+ assert.equal(context.db.select().from(externalModelObjects).get()!.circuitDeviceRowId, "row-1");
+ } finally {
+ context.close();
+ }
+ }
+ });
+
+ it("blocks room and distribution-board deletion while external objects reference them", () => {
+ const context = createFixture(null);
+ try {
+ assert.throws(() => assertDistributionBoardHasNoExternalObjects(context.db, "project-1", "board-1"), /Revit-Objekte/);
+ assert.throws(() => assertRoomHasNoExternalObjects(context.db, "project-1", "room-1"), /Revit-Objekte/);
+ } finally {
+ context.close();
+ }
+ });
});
diff --git a/tests/external-xlsx-return-projection.test.ts b/tests/external-xlsx-return-projection.test.ts
new file mode 100644
index 0000000..10c1980
--- /dev/null
+++ b/tests/external-xlsx-return-projection.test.ts
@@ -0,0 +1,43 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { projectExternalXlsxReturn } from "../src/external-model/application/external-xlsx-return-projection.js";
+import type { ExternalModelObjectSnapshot } from "../src/external-model/domain/external-model-contracts.js";
+
+function object(): ExternalModelObjectSnapshot {
+ return {
+ id: "object-1", projectId: "project-1", sourceId: "source-1",
+ worksharingId: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee-ffffffff", ifcGuid: null,
+ deviceTypeId: "type-1", lastSeenImportBatchId: "batch-1", lastAcceptedImportBatchId: "batch-1",
+ acceptedSourceValues: { rowNumber: 2, roomNumber: "101", roomName: "Büro", familyAndType: "Steckdose", selectionMarker: "SD", socketCount: 2, sourceRemark: null, circuitCombined: "UV 1-2F1.1", boardName: "UV 1", circuitIdentifier: "-2F1.1", designation: "Steckdose", electricalPowerW: "240", voltageV: 230, currentA: "1,16" },
+ planningValues: { displayName: "Steckdose", category: "single_phase", connectionKind: "socket", effectiveQuantity: 2, powerPerUnitW: 120, simultaneityFactor: 1, cosPhi: 0.9, costGroup: null, remark: null },
+ overriddenFields: [], externalRoomMappingId: null, distributionBoardId: "board-1", linkedProjectDeviceId: null, circuitDeviceRowId: "row-1", presenceStatus: "present",
+ };
+}
+
+describe("external XLSX return projection", () => {
+ it("projects typed row values and compares normalized imported scalars", () => {
+ const result = projectExternalXlsxReturn({ object: object(), circuitMode: "combined", singlePhaseVoltageV: 230, threePhaseVoltageV: 400, row: { rowId: "row-1", displayName: "Steckdose", powerPerUnitKw: 0.12, cosPhi: 0.9, phaseType: "single_phase", category: "single_phase", circuitIdentifier: "-2F1.1", circuitVoltageV: 230, distributionBoardName: "UV 1" } });
+ assert.deepEqual(result.values, { circuitCombined: "UV 1-2F1.1", designation: "Steckdose", electricalPowerW: 240, voltageV: 230, currentA: 1.16 });
+ assert.equal(result.differsFromImported, false);
+ assert.deepEqual(result.warnings, []);
+ });
+
+ it("uses object planning without a row and leaves an uncomputable current empty", () => {
+ const input = object(); input.circuitDeviceRowId = null; input.planningValues.cosPhi = null;
+ const result = projectExternalXlsxReturn({ object: input, row: null, circuitMode: "separate", singlePhaseVoltageV: 230, threePhaseVoltageV: 400 });
+ assert.equal(result.values.boardName, "");
+ assert.equal(result.values.circuitIdentifier, "");
+ assert.equal(result.values.electricalPowerW, 240);
+ assert.equal(result.values.currentA, null);
+ assert.equal(result.differsFromImported, true);
+ assert.match(result.warnings.join(" "), /Stromstärke/);
+ });
+
+ it("uses three-phase current and object-specific effective quantity", () => {
+ const input = object(); input.planningValues.category = "three_phase"; input.planningValues.effectiveQuantity = 3;
+ const result = projectExternalXlsxReturn({ object: input, row: null, circuitMode: "combined", singlePhaseVoltageV: 230, threePhaseVoltageV: 400 });
+ assert.equal(result.values.electricalPowerW, 360);
+ assert.equal(result.values.voltageV, 400);
+ assert.equal(result.values.currentA, 0.58);
+ });
+});
diff --git a/tests/revit-xlsx-settings-api.test.ts b/tests/revit-xlsx-settings-api.test.ts
index ed91b57..90161b3 100644
--- a/tests/revit-xlsx-settings-api.test.ts
+++ b/tests/revit-xlsx-settings-api.test.ts
@@ -2,7 +2,7 @@ import assert from "node:assert/strict";
import { readFileSync } from "node:fs";
import { describe, it } from "node:test";
import { createDefaultExternalModelConfiguration } from "../src/external-model/configuration/external-model-configuration.js";
-import { applyExternalInitialImport, detectExternalModelWorkbook, getExternalInitialImportStatus, getExternalModelConfiguration, getExternalProjectObjects, planExternalInitialImport, updateExternalModelConfiguration, updateExternalProjectObjects } from "../src/frontend/utils/api.js";
+import { applyExternalInitialImport, createExternalReturnWorkbook, detectExternalModelWorkbook, getExternalInitialImportStatus, getExternalModelConfiguration, getExternalProjectObjects, planExternalInitialImport, updateExternalModelConfiguration, updateExternalProjectObjects } from "../src/frontend/utils/api.js";
describe("Revit XLSX settings", () => {
it("uses the project-scoped configuration endpoint with expectedRevision", async () => {
@@ -59,11 +59,15 @@ describe("Revit XLSX settings", () => {
assert.match(revitPage, /Importstatus/);
assert.match(settings, /Musterdatei prüfen/);
assert.match(settings, /Kombinierte Stromkreisspalte/);
+ assert.match(settings, /isNewConfiguration/);
+ assert.match(revitPage, /isNewConfiguration={snapshot === null}/);
assert.match(wizard, /Schritt.*von/);
assert.match(wizard, /keine Gerätezeilen, Stromkreise oder BMKs/);
assert.match(wizard, /GZF 1/);
assert.match(objectTable, /viewportHeight/);
assert.match(objectTable, /Sammeländerung anwenden/);
+ assert.match(objectTable, /Rückgabe-Excel herunterladen/);
+ assert.match(objectTable, /Nur geänderte Objekte/);
});
it("loads one project object list and sends revision-safe bulk updates", async () => {
@@ -74,4 +78,16 @@ describe("Revit XLSX settings", () => {
finally { globalThis.fetch = originalFetch; }
assert.deepEqual(requests, [{ url: "/api/projects/project-1/external-model/objects", method: "GET", body: undefined }, { url: "/api/projects/project-1/external-model/objects", method: "PUT", body: { expectedRevision: 4, objectIds: ["object-1"], patch: { simultaneityFactor: 0.7 } } }]);
});
+
+ it("creates a revision-safe return workbook for the requested scope", async () => {
+ const requests: Array<{ url: string; method: string; body: unknown }> = [];
+ const originalFetch = globalThis.fetch;
+ globalThis.fetch = async (input, init) => {
+ requests.push({ url: String(input), method: init?.method ?? "GET", body: init?.body ? JSON.parse(String(init.body)) : undefined });
+ return new Response(JSON.stringify({ fileName: "return.xlsx", contentBase64: "", sha256: "a".repeat(64), objectCount: 1, warnings: [] }), { status: 200, headers: { "Content-Type": "application/json" } });
+ };
+ try { await createExternalReturnWorkbook("project-1", 7, "selected", ["object-1"]); }
+ finally { globalThis.fetch = originalFetch; }
+ assert.deepEqual(requests, [{ url: "/api/projects/project-1/external-model/return-workbook", method: "POST", body: { expectedRevision: 7, scope: "selected", selectedObjectIds: ["object-1"] } }]);
+ });
});