202 lines
8.5 KiB
TypeScript
202 lines
8.5 KiB
TypeScript
// P4 Files (AK-P4a) §11 — Files browser route. Loader builds the FileBrowserVM
|
|
// once (server-side); the component only renders (DoD A). Module off -> locked
|
|
// empty state (like walking-skeleton). Missing files.read_own -> 404.
|
|
//
|
|
// Interim-UI (AD-28): renders the ~/ui preview screen FilesBrowserPage; the loader
|
|
// owns navigation for filter/view changes (server-side). Final Subframe optics land
|
|
// as a tracked design-nachzug once David's D-P4 delta ships.
|
|
|
|
import { useCallback, useState } from "react";
|
|
import { type LoaderFunctionArgs, useLoaderData, useNavigate, useRevalidator } from "react-router";
|
|
import { buildFileBrowserVM, type FileBrowserRow, type FileBrowserVM, type FileViewMode } from "@hivegrid/view-models";
|
|
import { getTranslations } from "~/locale/i18next.server";
|
|
import { loadFilesContext, notFoundResponse, requireFilesPermission } from "~/utils/integrations/fileAccess.server";
|
|
import { loadFileBrowserData } from "~/utils/integrations/fileService.server";
|
|
import { mediaVariantPath, filesDetailPath } from "~/utils/integrations/fileRoutePaths";
|
|
import { FilesBrowserPage, type FilesBrowserQuery } from "~/components/screens/files/FilesBrowserPage";
|
|
import type { FileUploadDisplayItem } from "~/components/screens/files/FileUploadPage";
|
|
import { uploadFileInChunks, UploadFileClientError } from "~/utils/files/uploadFileClient";
|
|
import ServerError from "~/components/ui/errors/ServerError";
|
|
|
|
type LoaderData = { title: string; vm: FileBrowserVM; tenantSlug: string; bulkZipAction: string };
|
|
|
|
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
|
|
const { t } = await getTranslations(request);
|
|
const ctx = await loadFilesContext({ request, params });
|
|
const tenantSlug = params.tenant ?? "";
|
|
// Absolute (host-aware) URL — a relative "bulk-zip" would resolve against the
|
|
// /<tenant>/files base and drop the "files" segment (→ 404).
|
|
const bulkZipAction = `/${tenantSlug}/files/bulk-zip`;
|
|
|
|
if (!ctx.hasModule) {
|
|
// Locked connector state: render an empty VM (no rows, no write).
|
|
const vm = buildFileBrowserVM({
|
|
rows: [],
|
|
filter: { entityType: null, mimeGroup: null, tags: [], assignedToUserId: null, includeArchived: false, q: "" },
|
|
canWrite: false,
|
|
canDelete: false,
|
|
});
|
|
return Response.json({
|
|
title: `${t("files.browser.title")} | ${process.env.APP_NAME}`,
|
|
vm,
|
|
tenantSlug,
|
|
bulkZipAction,
|
|
} satisfies LoaderData);
|
|
}
|
|
|
|
try {
|
|
requireFilesPermission(ctx, "files.read_own");
|
|
} catch {
|
|
throw notFoundResponse();
|
|
}
|
|
|
|
const url = new URL(request.url);
|
|
const includeArchived = url.searchParams.get("archived") === "1";
|
|
const mimeGroup = url.searchParams.get("mime");
|
|
const entityType = url.searchParams.get("entity");
|
|
const tag = url.searchParams.get("tag");
|
|
const assignedToUserId = url.searchParams.get("assignee");
|
|
const q = url.searchParams.get("q") ?? "";
|
|
const pageParam = Number.parseInt(url.searchParams.get("page") ?? "1", 10);
|
|
const viewMode: FileViewMode = url.searchParams.get("view") === "grid" ? "grid" : "table";
|
|
|
|
const { rows, total, page, pageCount, filterOptions } = await loadFileBrowserData({
|
|
tenantId: ctx.tenantId,
|
|
ctx,
|
|
filter: { includeArchived, mimeGroup, entityType, tags: tag ? [tag] : undefined, assignedToUserId, q },
|
|
page: Number.isFinite(pageParam) ? pageParam : 1,
|
|
});
|
|
|
|
const canWrite = ctx.permissions.includes("files.write");
|
|
const canDelete = ctx.permissions.includes("files.delete");
|
|
const browserRows: FileBrowserRow[] = rows.map((file) => ({
|
|
id: file.id,
|
|
displayName: file.displayName,
|
|
mimeType: file.mimeType,
|
|
sizeBytes: file.sizeBytes,
|
|
createdAtIso: file.createdAt.toISOString(),
|
|
tags: file.tags,
|
|
source: file.source,
|
|
previewStatus: file.previewStatus as FileBrowserRow["previewStatus"],
|
|
scanStatus: file.scanStatus as FileBrowserRow["scanStatus"],
|
|
thumbnailUrl: file.thumbnailStorageKey && file.previewStatus === "ready" ? mediaVariantPath(tenantSlug, file.id, "thumb") : null,
|
|
detailHref: filesDetailPath(tenantSlug, file.id),
|
|
linkedEntityLabelKey: null,
|
|
}));
|
|
|
|
const vm = buildFileBrowserVM({
|
|
viewMode,
|
|
rows: browserRows,
|
|
filter: { entityType, mimeGroup, tags: tag ? [tag] : [], assignedToUserId, includeArchived, q },
|
|
filterOptions,
|
|
canWrite,
|
|
canDelete,
|
|
page,
|
|
pageCount,
|
|
total,
|
|
});
|
|
|
|
return Response.json({ title: `${t("files.browser.title")} | ${process.env.APP_NAME}`, vm, tenantSlug, bulkZipAction } satisfies LoaderData);
|
|
};
|
|
|
|
export default function FilesBrowserRoute() {
|
|
const { vm, tenantSlug, bulkZipAction } = useLoaderData<LoaderData>();
|
|
const navigate = useNavigate();
|
|
const revalidator = useRevalidator();
|
|
const [selectedIds, setSelectedIds] = useState<string[]>([]);
|
|
const [uploadItems, setUploadItems] = useState<FileUploadDisplayItem[]>([]);
|
|
const canWrite = vm.status === "ready" && vm.data.canWrite;
|
|
|
|
function onToggleSelect(id: string) {
|
|
setSelectedIds((prev) => (prev.includes(id) ? prev.filter((value) => value !== id) : [...prev, id]));
|
|
}
|
|
|
|
function onToggleSelectAll(ids: readonly string[], selectAll: boolean) {
|
|
setSelectedIds(selectAll ? [...ids] : []);
|
|
}
|
|
|
|
// --- Upload pipeline of the browser's upload dialog ---------------------
|
|
// Same chunked client as the former upload view (init -> chunk -> complete);
|
|
// it lives here because the screen stays presentational. Every finished file
|
|
// revalidates the loader, so the new file is in the list behind the dialog.
|
|
const updateItem = useCallback((clientId: string, patch: Partial<FileUploadDisplayItem>) => {
|
|
setUploadItems((current) => current.map((item) => (item.clientId === clientId ? { ...item, ...patch } : item)));
|
|
}, []);
|
|
|
|
const uploadOne = useCallback(
|
|
async (file: File, clientId: string) => {
|
|
try {
|
|
updateItem(clientId, { status: "uploading", progressPercent: 0 });
|
|
await uploadFileInChunks({
|
|
tenantSlug,
|
|
file,
|
|
onProgress: (percent) => updateItem(clientId, { progressPercent: percent }),
|
|
onProcessing: () => updateItem(clientId, { status: "processing" }),
|
|
});
|
|
updateItem(clientId, { status: "done", progressPercent: 100 });
|
|
revalidator.revalidate();
|
|
} catch (error) {
|
|
updateItem(clientId, {
|
|
status: "error",
|
|
errorKey: error instanceof UploadFileClientError ? error.errorKey : "files.error.uploadIncomplete",
|
|
});
|
|
}
|
|
},
|
|
[revalidator, tenantSlug, updateItem],
|
|
);
|
|
|
|
const onFiles = useCallback(
|
|
(fileList: FileList | null) => {
|
|
if (!fileList) return;
|
|
const next: FileUploadDisplayItem[] = [];
|
|
for (const file of Array.from(fileList)) {
|
|
const clientId = `${file.name}-${file.size}-${file.lastModified}`;
|
|
next.push({ clientId, filename: file.name, sizeBytes: file.size, status: "queued", progressPercent: 0, errorKey: null });
|
|
void uploadOne(file, clientId);
|
|
}
|
|
setUploadItems((current) => [...current, ...next]);
|
|
},
|
|
[uploadOne],
|
|
);
|
|
|
|
const clearUploadQueue = useCallback(() => setUploadItems([]), []);
|
|
const uploading = uploadItems.some((item) => item.status === "queued" || item.status === "uploading" || item.status === "processing");
|
|
|
|
function buildSearch(query: FilesBrowserQuery, page: number): string {
|
|
const params = new URLSearchParams();
|
|
if (query.mimeGroup) params.set("mime", query.mimeGroup);
|
|
if (query.entityType) params.set("entity", query.entityType);
|
|
if (query.tag) params.set("tag", query.tag);
|
|
if (query.assignedToUserId) params.set("assignee", query.assignedToUserId);
|
|
if (query.q.trim()) params.set("q", query.q.trim());
|
|
if (query.includeArchived) params.set("archived", "1");
|
|
if (query.viewMode === "grid") params.set("view", "grid");
|
|
if (page > 1) params.set("page", String(page));
|
|
return params.toString();
|
|
}
|
|
|
|
function onApply(query: FilesBrowserQuery) {
|
|
// Any filter/search/view change starts over at page 1: page 3 of the old
|
|
// result set says nothing about the new one.
|
|
navigate({ search: buildSearch(query, 1) });
|
|
}
|
|
|
|
function onGoToPage(query: FilesBrowserQuery, page: number) {
|
|
navigate({ search: buildSearch(query, page) });
|
|
}
|
|
|
|
return (
|
|
<FilesBrowserPage
|
|
vm={vm}
|
|
upload={canWrite ? { items: uploadItems, onFiles, uploading, onClose: clearUploadQueue } : undefined}
|
|
bulkZipAction={bulkZipAction}
|
|
selectedIds={selectedIds}
|
|
actions={{ onApply, onGoToPage, onToggleSelect, onToggleSelectAll }}
|
|
/>
|
|
);
|
|
}
|
|
|
|
export function ErrorBoundary() {
|
|
return <ServerError />;
|
|
}
|