283 lines
9.9 KiB
TypeScript
283 lines
9.9 KiB
TypeScript
import crypto from "node:crypto";
|
|
import { asc, eq } from "drizzle-orm";
|
|
import {
|
|
parseProjectStateSnapshot,
|
|
projectStateSnapshotSchemaVersion,
|
|
serializeProjectStateSnapshot,
|
|
type ProjectStateSnapshot,
|
|
} from "../../domain/models/project-state-snapshot.model.js";
|
|
import type { AppDatabase } from "../database-context.js";
|
|
import { circuitDeviceRows } from "../schema/circuit-device-rows.js";
|
|
import { circuitLists } from "../schema/circuit-lists.js";
|
|
import { circuitProtectionDevices } from "../schema/circuit-protection-devices.js";
|
|
import { circuitSections } from "../schema/circuit-sections.js";
|
|
import { circuits } from "../schema/circuits.js";
|
|
import { distributionBoardComponentProtectionDevices } from "../schema/distribution-board-component-protection-devices.js";
|
|
import { distributionBoardComponents } from "../schema/distribution-board-components.js";
|
|
import { distributionBoards } from "../schema/distribution-boards.js";
|
|
import { floors } from "../schema/floors.js";
|
|
import { projectDevices } from "../schema/project-devices.js";
|
|
import { projects } from "../schema/projects.js";
|
|
import { rooms } from "../schema/rooms.js";
|
|
import { externalCsvConfigurations } from "../schema/external-csv-configurations.js";
|
|
import { ExternalModelStateRepository } from "./external-model-state.repository.js";
|
|
|
|
export interface PersistedProjectStateSnapshot {
|
|
currentRevision: number;
|
|
state: ProjectStateSnapshot;
|
|
payloadJson: string;
|
|
payloadSha256: string;
|
|
}
|
|
|
|
export function readProjectStateSnapshot(
|
|
database: AppDatabase,
|
|
projectId: string
|
|
): PersistedProjectStateSnapshot | null {
|
|
const project = database
|
|
.select({
|
|
id: projects.id,
|
|
name: projects.name,
|
|
internalProjectNumber: projects.internalProjectNumber,
|
|
externalProjectNumber: projects.externalProjectNumber,
|
|
buildingOwner: projects.buildingOwner,
|
|
description: projects.description,
|
|
isPublicBuilding: projects.isPublicBuilding,
|
|
singlePhaseVoltageV: projects.singlePhaseVoltageV,
|
|
threePhaseVoltageV: projects.threePhaseVoltageV,
|
|
enabledDistributionBoardSupplyTypes:
|
|
projects.enabledDistributionBoardSupplyTypes,
|
|
currentRevision: projects.currentRevision,
|
|
})
|
|
.from(projects)
|
|
.where(eq(projects.id, projectId))
|
|
.get();
|
|
if (!project) {
|
|
return null;
|
|
}
|
|
|
|
const boardRows = database
|
|
.select()
|
|
.from(distributionBoards)
|
|
.where(eq(distributionBoards.projectId, projectId))
|
|
.orderBy(asc(distributionBoards.name), asc(distributionBoards.id))
|
|
.all();
|
|
const externalCsvConfiguration = database
|
|
.select()
|
|
.from(externalCsvConfigurations)
|
|
.where(eq(externalCsvConfigurations.projectId, projectId))
|
|
.get() ?? null;
|
|
const externalModel = new ExternalModelStateRepository(database)
|
|
.getByProject(projectId).state;
|
|
const listRows = database
|
|
.select()
|
|
.from(circuitLists)
|
|
.where(eq(circuitLists.projectId, projectId))
|
|
.orderBy(asc(circuitLists.name), asc(circuitLists.id))
|
|
.all();
|
|
const sectionRows = database
|
|
.select({
|
|
id: circuitSections.id,
|
|
circuitListId: circuitSections.circuitListId,
|
|
key: circuitSections.key,
|
|
displayName: circuitSections.displayName,
|
|
prefix: circuitSections.prefix,
|
|
sortOrder: circuitSections.sortOrder,
|
|
category: circuitSections.category,
|
|
groupNumber: circuitSections.groupNumber,
|
|
})
|
|
.from(circuitSections)
|
|
.innerJoin(
|
|
circuitLists,
|
|
eq(circuitLists.id, circuitSections.circuitListId)
|
|
)
|
|
.where(eq(circuitLists.projectId, projectId))
|
|
.orderBy(
|
|
asc(circuitSections.circuitListId),
|
|
asc(circuitSections.sortOrder),
|
|
asc(circuitSections.id)
|
|
)
|
|
.all();
|
|
const componentRows = database
|
|
.select({ component: distributionBoardComponents })
|
|
.from(distributionBoardComponents)
|
|
.innerJoin(
|
|
circuitLists,
|
|
eq(circuitLists.id, distributionBoardComponents.circuitListId)
|
|
)
|
|
.where(eq(circuitLists.projectId, projectId))
|
|
.orderBy(
|
|
asc(distributionBoardComponents.circuitListId),
|
|
asc(distributionBoardComponents.placement),
|
|
asc(distributionBoardComponents.sortOrder),
|
|
asc(distributionBoardComponents.id)
|
|
)
|
|
.all()
|
|
.map((row) => row.component);
|
|
const circuitProtectionRows = database
|
|
.select({ protection: circuitProtectionDevices })
|
|
.from(circuitProtectionDevices)
|
|
.innerJoin(
|
|
circuits,
|
|
eq(circuits.id, circuitProtectionDevices.circuitId)
|
|
)
|
|
.innerJoin(circuitLists, eq(circuitLists.id, circuits.circuitListId))
|
|
.where(eq(circuitLists.projectId, projectId))
|
|
.orderBy(asc(circuitProtectionDevices.circuitId))
|
|
.all()
|
|
.map((row) => row.protection);
|
|
const componentProtectionRows = database
|
|
.select({
|
|
protection: distributionBoardComponentProtectionDevices,
|
|
})
|
|
.from(distributionBoardComponentProtectionDevices)
|
|
.innerJoin(
|
|
distributionBoardComponents,
|
|
eq(
|
|
distributionBoardComponents.id,
|
|
distributionBoardComponentProtectionDevices.componentId
|
|
)
|
|
)
|
|
.innerJoin(
|
|
circuitLists,
|
|
eq(circuitLists.id, distributionBoardComponents.circuitListId)
|
|
)
|
|
.where(eq(circuitLists.projectId, projectId))
|
|
.orderBy(
|
|
asc(distributionBoardComponentProtectionDevices.componentId)
|
|
)
|
|
.all()
|
|
.map((row) => row.protection);
|
|
const circuitRows = database
|
|
.select({
|
|
id: circuits.id,
|
|
circuitListId: circuits.circuitListId,
|
|
sectionId: circuits.sectionId,
|
|
equipmentIdentifier: circuits.equipmentIdentifier,
|
|
displayName: circuits.displayName,
|
|
sortOrder: circuits.sortOrder,
|
|
cableType: circuits.cableType,
|
|
cableCrossSection: circuits.cableCrossSection,
|
|
cableLength: circuits.cableLength,
|
|
rcdAssignment: circuits.rcdAssignment,
|
|
terminalDesignation: circuits.terminalDesignation,
|
|
voltage: circuits.voltage,
|
|
controlRequirement: circuits.controlRequirement,
|
|
status: circuits.status,
|
|
isReserve: circuits.isReserve,
|
|
remark: circuits.remark,
|
|
})
|
|
.from(circuits)
|
|
.innerJoin(circuitLists, eq(circuitLists.id, circuits.circuitListId))
|
|
.where(eq(circuitLists.projectId, projectId))
|
|
.orderBy(
|
|
asc(circuits.circuitListId),
|
|
asc(circuits.sortOrder),
|
|
asc(circuits.id)
|
|
)
|
|
.all();
|
|
const deviceRowRows = database
|
|
.select({
|
|
id: circuitDeviceRows.id,
|
|
circuitId: circuitDeviceRows.circuitId,
|
|
linkedProjectDeviceId: circuitDeviceRows.linkedProjectDeviceId,
|
|
sortOrder: circuitDeviceRows.sortOrder,
|
|
name: circuitDeviceRows.name,
|
|
displayName: circuitDeviceRows.displayName,
|
|
phaseType: circuitDeviceRows.phaseType,
|
|
connectionKind: circuitDeviceRows.connectionKind,
|
|
costGroup: circuitDeviceRows.costGroup,
|
|
category: circuitDeviceRows.category,
|
|
level: circuitDeviceRows.level,
|
|
roomId: circuitDeviceRows.roomId,
|
|
roomNumberSnapshot: circuitDeviceRows.roomNumberSnapshot,
|
|
roomNameSnapshot: circuitDeviceRows.roomNameSnapshot,
|
|
quantity: circuitDeviceRows.quantity,
|
|
manualQuantity: circuitDeviceRows.manualQuantity,
|
|
powerPerUnit: circuitDeviceRows.powerPerUnit,
|
|
simultaneityFactor: circuitDeviceRows.simultaneityFactor,
|
|
cosPhi: circuitDeviceRows.cosPhi,
|
|
remark: circuitDeviceRows.remark,
|
|
overriddenFields: circuitDeviceRows.overriddenFields,
|
|
})
|
|
.from(circuitDeviceRows)
|
|
.innerJoin(circuits, eq(circuits.id, circuitDeviceRows.circuitId))
|
|
.innerJoin(circuitLists, eq(circuitLists.id, circuits.circuitListId))
|
|
.where(eq(circuitLists.projectId, projectId))
|
|
.orderBy(
|
|
asc(circuitDeviceRows.circuitId),
|
|
asc(circuitDeviceRows.sortOrder),
|
|
asc(circuitDeviceRows.id)
|
|
)
|
|
.all();
|
|
const projectDeviceRows = database
|
|
.select()
|
|
.from(projectDevices)
|
|
.where(eq(projectDevices.projectId, projectId))
|
|
.orderBy(asc(projectDevices.displayName), asc(projectDevices.id))
|
|
.all();
|
|
const floorRows = database
|
|
.select()
|
|
.from(floors)
|
|
.where(eq(floors.projectId, projectId))
|
|
.orderBy(asc(floors.sortOrder), asc(floors.id))
|
|
.all();
|
|
const roomRows = database
|
|
.select()
|
|
.from(rooms)
|
|
.where(eq(rooms.projectId, projectId))
|
|
.orderBy(asc(rooms.roomNumber), asc(rooms.id))
|
|
.all();
|
|
|
|
const deviceRowsByCircuit = new Map<string, typeof deviceRowRows>();
|
|
for (const row of deviceRowRows) {
|
|
const entries = deviceRowsByCircuit.get(row.circuitId) ?? [];
|
|
entries.push(row);
|
|
deviceRowsByCircuit.set(row.circuitId, entries);
|
|
}
|
|
|
|
const state = parseProjectStateSnapshot({
|
|
schemaVersion: projectStateSnapshotSchemaVersion,
|
|
project: {
|
|
id: project.id,
|
|
name: project.name,
|
|
internalProjectNumber: project.internalProjectNumber,
|
|
externalProjectNumber: project.externalProjectNumber,
|
|
buildingOwner: project.buildingOwner,
|
|
description: project.description,
|
|
isPublicBuilding: project.isPublicBuilding,
|
|
singlePhaseVoltageV: project.singlePhaseVoltageV,
|
|
threePhaseVoltageV: project.threePhaseVoltageV,
|
|
enabledDistributionBoardSupplyTypes:
|
|
project.enabledDistributionBoardSupplyTypes,
|
|
},
|
|
distributionBoards: boardRows,
|
|
externalCsvConfiguration,
|
|
externalModel,
|
|
circuitLists: listRows,
|
|
circuitSections: sectionRows,
|
|
distributionBoardComponents: componentRows,
|
|
circuitProtectionDevices: circuitProtectionRows,
|
|
distributionBoardComponentProtectionDevices:
|
|
componentProtectionRows,
|
|
circuits: circuitRows.map((circuit) => ({
|
|
...circuit,
|
|
isReserve: Boolean(circuit.isReserve),
|
|
deviceRows: deviceRowsByCircuit.get(circuit.id) ?? [],
|
|
})),
|
|
projectDevices: projectDeviceRows,
|
|
floors: floorRows,
|
|
rooms: roomRows,
|
|
});
|
|
const payloadJson = serializeProjectStateSnapshot(state);
|
|
return {
|
|
currentRevision: project.currentRevision,
|
|
state,
|
|
payloadJson,
|
|
payloadSha256: hashProjectStatePayload(payloadJson),
|
|
};
|
|
}
|
|
|
|
export function hashProjectStatePayload(payloadJson: string) {
|
|
return crypto.createHash("sha256").update(payloadJson).digest("hex");
|
|
}
|