505 lines
18 KiB
TypeScript
505 lines
18 KiB
TypeScript
import type { AxiosProgressEvent } from "axios";
|
|
import type { TIssueAttachment } from "@plane/types";
|
|
import {
|
|
DEFAULT_BEAM_VIEWER_BASE_URL,
|
|
getBeamDirectModelTypeFromFileName,
|
|
getBeamFileExtension,
|
|
getBeamModelTypeFromFileName,
|
|
} from "./beam-viewer-config";
|
|
|
|
export type TBeamViewerConversion = {
|
|
artifactSrc?: string;
|
|
artifactType?: string;
|
|
componentTreeRequired: boolean;
|
|
message?: string;
|
|
metadataSrc?: string;
|
|
size?: number;
|
|
sourceFormat: string;
|
|
sourceSrc?: string;
|
|
status: "conversion_required" | "processing" | "ready" | "failed";
|
|
targetFormat: "glb" | "xkt";
|
|
updatedAt?: string;
|
|
};
|
|
|
|
export type TBeamModelVersionRecord = {
|
|
assetId?: string;
|
|
conversion?: TBeamViewerConversion;
|
|
downloadUrl: string;
|
|
originalFilename: string;
|
|
previewAvailable: boolean;
|
|
projectId?: string;
|
|
sha256?: string;
|
|
size: number;
|
|
sourceSrc?: string;
|
|
src: string;
|
|
status?: string;
|
|
type: string;
|
|
uploadedBy?: string;
|
|
uploadedAt: string;
|
|
version: number;
|
|
versionId?: string;
|
|
viewerUrl?: string | null;
|
|
};
|
|
|
|
export type TBeamViewerAttachment = {
|
|
assetId?: string;
|
|
backend: "beam-viewer-local" | "beam-viewer";
|
|
conversion?: TBeamViewerConversion;
|
|
downloadUrl: string;
|
|
originalFilename: string;
|
|
previewAvailable: boolean;
|
|
projectId?: string;
|
|
sha256?: string;
|
|
src: string;
|
|
type: string;
|
|
uploadedBy?: string;
|
|
uploadedAt: string;
|
|
version?: number;
|
|
versionId?: string;
|
|
versions?: TBeamModelVersionRecord[];
|
|
viewerUrl?: string | null;
|
|
};
|
|
|
|
export type TBeamConversionStatus = {
|
|
assetId?: string;
|
|
artifactSrc?: string;
|
|
artifactType?: string;
|
|
artifactUrl?: string;
|
|
componentCount?: number;
|
|
componentTreeRequired?: boolean;
|
|
error?: string;
|
|
message?: string;
|
|
metadataSrc?: string;
|
|
metadataUrl?: string;
|
|
sha256?: string;
|
|
sourceFormat?: string;
|
|
sourceSrc?: string;
|
|
size?: number;
|
|
status: "conversion_required" | "processing" | "ready" | "failed";
|
|
targetFormat?: "glb" | "xkt";
|
|
updatedAt?: string;
|
|
version?: number;
|
|
versionId?: string;
|
|
};
|
|
|
|
export type TBeamVersionHistoryResponse = {
|
|
assetId?: string;
|
|
currentVersion?: number;
|
|
currentVersionId?: string;
|
|
ok: boolean;
|
|
projectId?: string;
|
|
updatedAt?: string;
|
|
versions: TBeamModelVersionRecord[];
|
|
};
|
|
|
|
export const BEAM_VIEWER_OPEN_EVENT = "nodedc:beam-viewer-open";
|
|
|
|
export type TBeamViewerOpenEventDetail = {
|
|
downloadUrl?: string;
|
|
fileExtension?: string;
|
|
fileName: string;
|
|
fileSize: number;
|
|
issueId: string;
|
|
viewerUrl: string;
|
|
};
|
|
|
|
export const dispatchBeamViewerOpenEvent = (detail: TBeamViewerOpenEventDetail) => {
|
|
window.dispatchEvent(new CustomEvent<TBeamViewerOpenEventDetail>(BEAM_VIEWER_OPEN_EVENT, { detail }));
|
|
};
|
|
|
|
const MIME_TYPE_BY_EXTENSION: Record<string, string> = {
|
|
glb: "model/gltf-binary",
|
|
gltf: "model/gltf+json",
|
|
};
|
|
|
|
const normalizeBaseUrl = (url: string | undefined): string =>
|
|
(url && url.trim() ? url.trim() : DEFAULT_BEAM_VIEWER_BASE_URL).replace(/\/+$/, "");
|
|
|
|
const getUploadGroupId = (parts: Array<string | undefined>): string => {
|
|
const value = parts
|
|
.filter(Boolean)
|
|
.join("_")
|
|
.replace(/[^a-zA-Z0-9_-]/g, "_");
|
|
return value || "tasker";
|
|
};
|
|
|
|
const toBeamRelativeUploadSrc = (src: string): string => {
|
|
try {
|
|
const url = new URL(src);
|
|
return url.pathname.replace(/^\/+/, "");
|
|
} catch (_error) {
|
|
return src.replace(/^\/+/, "");
|
|
}
|
|
};
|
|
|
|
const toBeamAbsoluteUrl = (src: string | undefined, cacheKey?: string): string | undefined => {
|
|
if (!src) return undefined;
|
|
let url: URL;
|
|
try {
|
|
url = new URL(src);
|
|
} catch (_error) {
|
|
url = new URL(src.startsWith("/") ? src : `/${src}`, `${getBeamApiBaseUrl()}/`);
|
|
}
|
|
if (cacheKey) url.searchParams.set("v", cacheKey);
|
|
return url.toString();
|
|
};
|
|
|
|
export const getBeamViewerBaseUrl = (): string => normalizeBaseUrl(process.env.VITE_BEAM_VIEWER_BASE_URL);
|
|
|
|
export const getBeamApiBaseUrl = (): string =>
|
|
normalizeBaseUrl(process.env.VITE_BEAM_API_BASE_URL || process.env.VITE_BEAM_VIEWER_BASE_URL);
|
|
|
|
export const getBeamModelTypeFromName = (name: string | undefined): string | null => {
|
|
return getBeamModelTypeFromFileName(name);
|
|
};
|
|
|
|
export const getBeamDirectModelTypeFromName = (name: string | undefined): string | null => {
|
|
return getBeamDirectModelTypeFromFileName(name);
|
|
};
|
|
|
|
export const getBeamModelMimeType = (file: File): string =>
|
|
MIME_TYPE_BY_EXTENSION[getBeamFileExtension(file.name)] || "application/octet-stream";
|
|
|
|
export const isBeamModelFile = (name: string | undefined): boolean => !!getBeamModelTypeFromName(name);
|
|
|
|
export const isBeamDirectViewerFile = (name: string | undefined): boolean => !!getBeamDirectModelTypeFromName(name);
|
|
|
|
export const buildBeamViewerUrl = (params: {
|
|
name?: string;
|
|
settingsSrc?: string;
|
|
src: string;
|
|
type?: string | null;
|
|
}): string => {
|
|
const viewerUrl = new URL(getBeamViewerBaseUrl());
|
|
viewerUrl.searchParams.set("url", params.src);
|
|
if (params.type) viewerUrl.searchParams.set("type", params.type);
|
|
if (params.type === "gltf" || params.type === "glb") viewerUrl.searchParams.set("edges", "false");
|
|
if (params.name) viewerUrl.searchParams.set("name", params.name);
|
|
if (params.settingsSrc) viewerUrl.searchParams.set("settingsSrc", params.settingsSrc);
|
|
return viewerUrl.toString();
|
|
};
|
|
|
|
export const getBeamViewerAttachment = (attachment: TIssueAttachment | undefined): TBeamViewerAttachment | null => {
|
|
const beamViewer = (attachment?.attributes as { beamViewer?: TBeamViewerAttachment } | undefined)?.beamViewer;
|
|
if (!beamViewer || typeof beamViewer !== "object") return null;
|
|
return beamViewer;
|
|
};
|
|
|
|
const getAttachmentVersionNumber = (attachment: TIssueAttachment | undefined): number => {
|
|
const rawVersion = (attachment?.attributes as { version?: number | string } | undefined)?.version;
|
|
if (typeof rawVersion === "number" && Number.isFinite(rawVersion)) return rawVersion;
|
|
if (typeof rawVersion === "string") {
|
|
const parsed = Number.parseInt(rawVersion.replace(/^v/i, ""), 10);
|
|
if (Number.isFinite(parsed)) return parsed;
|
|
}
|
|
return 1;
|
|
};
|
|
|
|
export const getBeamViewerVersionNumber = (
|
|
beamViewer: TBeamViewerAttachment | null | undefined,
|
|
attachment?: TIssueAttachment
|
|
): number => {
|
|
if (typeof beamViewer?.version === "number" && Number.isFinite(beamViewer.version)) return beamViewer.version;
|
|
return getAttachmentVersionNumber(attachment);
|
|
};
|
|
|
|
export const createBeamModelVersionRecord = (
|
|
beamViewer: TBeamViewerAttachment,
|
|
options: {
|
|
attachment?: TIssueAttachment;
|
|
size?: number;
|
|
uploadedBy?: string;
|
|
} = {}
|
|
): TBeamModelVersionRecord => ({
|
|
assetId: beamViewer.assetId,
|
|
conversion: beamViewer.conversion,
|
|
downloadUrl: beamViewer.downloadUrl,
|
|
originalFilename: beamViewer.originalFilename,
|
|
previewAvailable: beamViewer.previewAvailable,
|
|
projectId: beamViewer.projectId,
|
|
sha256: beamViewer.sha256,
|
|
size: options.size ?? beamViewer.conversion?.size ?? Number(options.attachment?.attributes.size ?? 0),
|
|
sourceSrc: beamViewer.conversion?.sourceSrc || beamViewer.src,
|
|
src: beamViewer.src,
|
|
status: beamViewer.conversion?.status || "ready",
|
|
type: beamViewer.type,
|
|
uploadedBy: beamViewer.uploadedBy || options.uploadedBy || options.attachment?.created_by,
|
|
uploadedAt: beamViewer.uploadedAt,
|
|
version: getBeamViewerVersionNumber(beamViewer, options.attachment),
|
|
versionId: beamViewer.versionId,
|
|
viewerUrl: beamViewer.viewerUrl,
|
|
});
|
|
|
|
const isSameBeamVersionRecord = (first: TBeamModelVersionRecord, second: TBeamModelVersionRecord): boolean => {
|
|
if (first.versionId && second.versionId) return first.versionId === second.versionId;
|
|
return first.version === second.version;
|
|
};
|
|
|
|
export const getBeamModelVersionRecords = (
|
|
beamViewer: TBeamViewerAttachment | null | undefined,
|
|
attachment?: TIssueAttachment
|
|
): TBeamModelVersionRecord[] => {
|
|
if (!beamViewer) return [];
|
|
const currentRecord = createBeamModelVersionRecord(beamViewer, { attachment });
|
|
const storedVersions = Array.isArray(beamViewer.versions) ? beamViewer.versions : [];
|
|
const versions = storedVersions.some((version) => isSameBeamVersionRecord(version, currentRecord))
|
|
? storedVersions
|
|
: [...storedVersions, currentRecord];
|
|
|
|
return versions
|
|
.filter((version) => typeof version?.version === "number" && Number.isFinite(version.version))
|
|
.sort((first, second) => first.version - second.version);
|
|
};
|
|
|
|
export const mergeBeamModelVersionRecords = (
|
|
previousBeamViewer: TBeamViewerAttachment,
|
|
nextBeamViewer: TBeamViewerAttachment,
|
|
attachment?: TIssueAttachment
|
|
): TBeamModelVersionRecord[] => {
|
|
const previousVersions = getBeamModelVersionRecords(previousBeamViewer, attachment);
|
|
const nextRecord =
|
|
nextBeamViewer.versions?.find((version) =>
|
|
nextBeamViewer.versionId
|
|
? version.versionId === nextBeamViewer.versionId
|
|
: version.version === nextBeamViewer.version
|
|
) ||
|
|
nextBeamViewer.versions?.[0] ||
|
|
createBeamModelVersionRecord(nextBeamViewer);
|
|
return [...previousVersions.filter((version) => !isSameBeamVersionRecord(version, nextRecord)), nextRecord].sort(
|
|
(first, second) => first.version - second.version
|
|
);
|
|
};
|
|
|
|
export const mergeBeamModelVersionRecordLists = (
|
|
firstVersions: TBeamModelVersionRecord[] = [],
|
|
secondVersions: TBeamModelVersionRecord[] = []
|
|
): TBeamModelVersionRecord[] => {
|
|
const byKey = new Map<string, TBeamModelVersionRecord>();
|
|
[...firstVersions, ...secondVersions].forEach((version) => {
|
|
const key = version.versionId || `version-${version.version}`;
|
|
const previous = byKey.get(key);
|
|
byKey.set(key, { ...(previous || {}), ...version });
|
|
});
|
|
return [...byKey.values()]
|
|
.filter((version) => typeof version?.version === "number" && Number.isFinite(version.version))
|
|
.sort((first, second) => first.version - second.version);
|
|
};
|
|
|
|
export const syncCurrentBeamVersionRecord = (
|
|
beamViewer: TBeamViewerAttachment,
|
|
attachment?: TIssueAttachment
|
|
): TBeamViewerAttachment => {
|
|
const currentRecord = createBeamModelVersionRecord(beamViewer, { attachment });
|
|
const versions = getBeamModelVersionRecords(beamViewer, attachment).map((version) => {
|
|
if (!isSameBeamVersionRecord(version, currentRecord)) return version;
|
|
return Object.assign({}, version, currentRecord);
|
|
});
|
|
return { ...beamViewer, versions };
|
|
};
|
|
|
|
export const getBeamVersionViewerUrl = (version: TBeamModelVersionRecord): string | undefined => {
|
|
if (version.viewerUrl) return version.viewerUrl;
|
|
if (!version.conversion && version.previewAvailable && version.src) {
|
|
return buildBeamViewerUrl({
|
|
name: version.originalFilename,
|
|
settingsSrc: version.sourceSrc || version.src,
|
|
src: version.src,
|
|
type: version.type,
|
|
});
|
|
}
|
|
if (version.conversion?.status !== "ready" || !version.conversion.artifactSrc) return undefined;
|
|
const artifactType = version.conversion.artifactType || version.conversion.targetFormat || "gltf";
|
|
return buildBeamViewerUrl({
|
|
name: version.originalFilename,
|
|
settingsSrc: version.conversion.sourceSrc || version.src,
|
|
src:
|
|
toBeamAbsoluteUrl(version.conversion.artifactSrc, version.conversion.updatedAt) || version.conversion.artifactSrc,
|
|
type: artifactType,
|
|
});
|
|
};
|
|
|
|
export const fetchBeamConversionStatus = async (beamViewer: TBeamViewerAttachment): Promise<TBeamConversionStatus> => {
|
|
const statusUrl = new URL("/api/conversions/status", `${getBeamApiBaseUrl()}/`);
|
|
statusUrl.searchParams.set("src", toBeamRelativeUploadSrc(beamViewer.src));
|
|
|
|
const response = await fetch(statusUrl.toString(), { credentials: "include" });
|
|
if (!response.ok) {
|
|
throw new Error(`BIM conversion status failed: HTTP ${response.status}`);
|
|
}
|
|
|
|
const payload = (await response.json()) as TBeamConversionStatus;
|
|
return {
|
|
...payload,
|
|
artifactUrl: toBeamAbsoluteUrl(payload.artifactSrc, payload.updatedAt),
|
|
metadataUrl: toBeamAbsoluteUrl(payload.metadataSrc),
|
|
};
|
|
};
|
|
|
|
export const fetchBeamModelVersions = async (
|
|
beamViewer: TBeamViewerAttachment
|
|
): Promise<TBeamVersionHistoryResponse> => {
|
|
const versionsUrl = new URL("/api/uploads/versions", `${getBeamApiBaseUrl()}/`);
|
|
if (beamViewer.projectId && beamViewer.assetId) {
|
|
versionsUrl.searchParams.set("projectId", beamViewer.projectId);
|
|
versionsUrl.searchParams.set("assetId", beamViewer.assetId);
|
|
} else {
|
|
versionsUrl.searchParams.set("src", toBeamRelativeUploadSrc(beamViewer.src));
|
|
}
|
|
|
|
const response = await fetch(versionsUrl.toString(), { credentials: "include" });
|
|
if (!response.ok) {
|
|
throw new Error(`BIM version history failed: HTTP ${response.status}`);
|
|
}
|
|
|
|
return (await response.json()) as TBeamVersionHistoryResponse;
|
|
};
|
|
|
|
export const uploadBeamModelFile = (
|
|
file: File,
|
|
options: {
|
|
assetId?: string;
|
|
issueId?: string;
|
|
onUploadProgress?: (progressEvent: AxiosProgressEvent) => void;
|
|
projectId?: string;
|
|
uploadedBy?: string;
|
|
version?: number;
|
|
workspaceSlug?: string;
|
|
} = {}
|
|
): Promise<TBeamViewerAttachment> =>
|
|
new Promise((resolve, reject) => {
|
|
const type = getBeamModelTypeFromName(file.name);
|
|
if (!type) {
|
|
reject(new Error("Формат модели не поддерживается BIM Viewer"));
|
|
return;
|
|
}
|
|
const directViewerType = getBeamDirectModelTypeFromName(file.name);
|
|
|
|
const apiBaseUrl = getBeamApiBaseUrl();
|
|
const uploadUrl = new URL("/api/uploads", `${apiBaseUrl}/`);
|
|
uploadUrl.searchParams.set("filename", file.name);
|
|
uploadUrl.searchParams.set(
|
|
"projectId",
|
|
getUploadGroupId([options.workspaceSlug, options.projectId, options.issueId])
|
|
);
|
|
if (options.assetId) uploadUrl.searchParams.set("assetId", options.assetId);
|
|
if (options.version) uploadUrl.searchParams.set("version", String(options.version));
|
|
|
|
const xhr = new XMLHttpRequest();
|
|
xhr.open("POST", uploadUrl.toString());
|
|
xhr.withCredentials = true;
|
|
xhr.setRequestHeader("Content-Type", "application/octet-stream");
|
|
xhr.upload.addEventListener("progress", (event) => {
|
|
if (!event.lengthComputable || !options.onUploadProgress) return;
|
|
options.onUploadProgress({
|
|
loaded: event.loaded,
|
|
progress: event.loaded / event.total,
|
|
total: event.total,
|
|
} as AxiosProgressEvent);
|
|
});
|
|
xhr.addEventListener("error", () => reject(new Error("Не удалось загрузить модель в BIM Viewer")));
|
|
xhr.addEventListener("load", () => {
|
|
if (xhr.status < 200 || xhr.status >= 300) {
|
|
reject(new Error(xhr.responseText || `BIM Viewer upload failed: HTTP ${xhr.status}`));
|
|
return;
|
|
}
|
|
|
|
try {
|
|
const response = JSON.parse(xhr.responseText) as {
|
|
assetId?: string;
|
|
conversion?: TBeamViewerAttachment["conversion"];
|
|
originalFilename?: string;
|
|
projectId?: string;
|
|
sha256?: string;
|
|
src?: string;
|
|
uploadedAt?: string;
|
|
version?: number;
|
|
versionId?: string;
|
|
};
|
|
if (!response.src) {
|
|
reject(new Error("BIM Viewer не вернул путь к загруженной модели"));
|
|
return;
|
|
}
|
|
|
|
const downloadUrl = new URL(response.src.startsWith("/") ? response.src : `/${response.src}`, `${apiBaseUrl}/`);
|
|
const baseAttachment: TBeamViewerAttachment = {
|
|
assetId: response.assetId ?? options.assetId,
|
|
backend: "beam-viewer-local",
|
|
downloadUrl: downloadUrl.toString(),
|
|
originalFilename: response.originalFilename || file.name,
|
|
previewAvailable: !!directViewerType,
|
|
projectId: response.projectId,
|
|
sha256: response.sha256,
|
|
src: downloadUrl.toString(),
|
|
type,
|
|
uploadedBy: options.uploadedBy,
|
|
uploadedAt: response.uploadedAt || new Date().toISOString(),
|
|
version: response.version ?? options.version ?? 1,
|
|
versionId: response.versionId,
|
|
};
|
|
|
|
if (!directViewerType) {
|
|
const nextAttachment: TBeamViewerAttachment = {
|
|
...baseAttachment,
|
|
conversion: {
|
|
...response.conversion,
|
|
componentTreeRequired: true,
|
|
message:
|
|
response.conversion?.message ??
|
|
"Оригинальный STEP загружен. Просмотр появится после подготовки модели и дерева компонентов.",
|
|
sourceFormat: type,
|
|
status: response.conversion?.status ?? "conversion_required",
|
|
targetFormat: response.conversion?.targetFormat ?? "xkt",
|
|
},
|
|
};
|
|
resolve({
|
|
...nextAttachment,
|
|
versions: [createBeamModelVersionRecord(nextAttachment, { size: file.size })],
|
|
});
|
|
return;
|
|
}
|
|
|
|
const nextAttachment: TBeamViewerAttachment = {
|
|
...baseAttachment,
|
|
viewerUrl: buildBeamViewerUrl({
|
|
name: file.name,
|
|
settingsSrc: downloadUrl.toString(),
|
|
src: downloadUrl.toString(),
|
|
type: directViewerType,
|
|
}),
|
|
};
|
|
|
|
resolve({
|
|
...nextAttachment,
|
|
versions: [createBeamModelVersionRecord(nextAttachment, { size: file.size })],
|
|
});
|
|
} catch (_error) {
|
|
reject(new Error("BIM Viewer вернул некорректный ответ"));
|
|
}
|
|
});
|
|
xhr.send(file);
|
|
});
|
|
|
|
const deleteBeamStorageResource = async (
|
|
endpoint: "/api/uploads/asset" | "/api/uploads/version",
|
|
payload: unknown
|
|
): Promise<void> => {
|
|
const response = await fetch(new URL(endpoint, `${getBeamApiBaseUrl()}/`).toString(), {
|
|
method: "DELETE",
|
|
credentials: "include",
|
|
headers: {
|
|
"Content-Type": "application/json",
|
|
},
|
|
body: JSON.stringify(payload),
|
|
});
|
|
|
|
if (!response.ok) {
|
|
throw new Error((await response.text()) || `BIM storage delete failed: HTTP ${response.status}`);
|
|
}
|
|
};
|
|
|
|
export const deleteBeamModelAsset = async (beamViewer: TBeamViewerAttachment): Promise<void> =>
|
|
deleteBeamStorageResource("/api/uploads/asset", beamViewer);
|
|
|
|
export const deleteBeamModelVersion = async (version: TBeamModelVersionRecord): Promise<void> =>
|
|
deleteBeamStorageResource("/api/uploads/version", version);
|