// P17 HR-Hub core (AK-P17a) — employee "my documents" route. The employee sees // their own employee-visible documents; office-uploaded ones are read-only. Build // the HrDocumentListVM in the loader; archive own non-office docs in the action. // // Self-upload is INDEPENDENT of the Files module's files.write permission: the // screen posts the file as multipart to intent=upload-doc, gated on hr.read_own. // The action stores it via the single-shot createFileFromBytes primitive (scan + // File row + scan/preview fan-out) and links it as an HrEmployeeDocument through // createDocument. No chunked client, no files.write. import { useCallback, useEffect, useRef, useState } from "react"; import { type ActionFunctionArgs, type LoaderFunctionArgs, useFetcher, useLoaderData } from "react-router"; import { buildHrDocumentListVM, hrDocumentKindKey, type HrDocumentKind, type HrDocumentRow as HrDocumentVMRow, type HrDocumentListVM } from "@hivegrid/view-models"; import { getTranslations } from "~/locale/i18next.server"; import { badRequestResponse, hrActionErrorResponse, loadHrContext, notFoundResponse, requireHrPermission } from "~/utils/integrations/hrAccess.server"; import { archiveDocument, createDocumentWithLink, listEmployeeDocuments } from "~/utils/integrations/hrService.server"; import { createFileFromBytes, hardDeleteFile } from "~/utils/integrations/fileService.server"; import { StorageScanRejectedError } from "~/utils/integrations/storageService"; import { hrMyDocumentsPath } from "~/utils/integrations/hrRoutePaths"; import ServerError from "~/components/ui/errors/ServerError"; import { HrMyDocumentsPage, type HrDocumentUploadState, type HrMyDocumentsUploadInput } from "~/components/screens/hr/HrMyDocumentsPage"; import { useSaveToast } from "~/hooks/use-save-toast"; type LoaderData = { title: string; vm: HrDocumentListVM; tenantSlug: string }; type UploadActionData = { intent?: string; ok?: boolean; messageKey?: string; error?: string }; // Single-request self-upload cap. HR personnel documents are small; larger files // belong in the dedicated Files module (chunked). Rejected with a Klartext error. const HR_DOC_MAX_BYTES = 25 * 1024 * 1024; const DOCUMENT_KINDS: readonly HrDocumentKind[] = ["contract", "certificate", "identification", "qualification", "other"]; // The underlying file bytes are delivered by the Files auth-proxy route (AK-P4a). function fileHref(tenantSlug: string, fileId: string): string { return `/${tenantSlug}/files/${fileId}`; } export const loader = async ({ request, params }: LoaderFunctionArgs) => { const { t } = await getTranslations(request); const ctx = await loadHrContext({ request, params }); const tenantSlug = params.tenant ?? ""; if (!ctx.hasModule) { return Response.json({ title: `${t("hr.documents.title")} | ${process.env.APP_NAME}`, vm: buildHrDocumentListVM({ rows: [], canUpload: false, uploadHref: hrMyDocumentsPath(tenantSlug) }), tenantSlug } satisfies LoaderData); } try { requireHrPermission(ctx, "hr.read_own"); } catch { throw notFoundResponse(); } const docs = await listEmployeeDocuments({ tenantId: ctx.tenantId, employeeUserId: ctx.userId, viewerIsEmployee: true }); const now = Date.now(); const rows: HrDocumentVMRow[] = docs.map((doc) => ({ id: doc.id, title: doc.title, documentKind: doc.documentKind, kindKey: hrDocumentKindKey(doc.documentKind), createdAtIso: doc.createdAt.toISOString(), validUntilIso: doc.validUntil ? doc.validUntil.toISOString() : null, isExpired: Boolean(doc.validUntil && doc.validUntil.getTime() < now), readOnly: doc.uploadedByOffice, fileHref: fileHref(tenantSlug, doc.fileId), })); const vm = buildHrDocumentListVM({ rows, canUpload: true, uploadHref: hrMyDocumentsPath(tenantSlug) }); return Response.json({ title: `${t("hr.documents.title")} | ${process.env.APP_NAME}`, vm, tenantSlug } satisfies LoaderData); }; export const action = async ({ request, params }: ActionFunctionArgs) => { const ctx = await loadHrContext({ request, params, requireModule: true }); requireHrPermission(ctx, "hr.read_own"); const form = await request.formData(); const intent = form.get("intent")?.toString(); try { if (intent === "archive") { await archiveDocument({ tenantId: ctx.tenantId, documentId: form.get("documentId")?.toString() ?? "", actorUserId: ctx.userId, viewerIsEmployee: true }); return Response.json({ intent, ok: true, messageKey: "hr.documents.toast.archived" }); } if (intent === "upload-doc") { const fileEntry = form.get("file"); const title = (form.get("title")?.toString() ?? "").trim(); const kindRaw = form.get("documentKind")?.toString() ?? "other"; const documentKind = (DOCUMENT_KINDS as readonly string[]).includes(kindRaw) ? (kindRaw as HrDocumentKind) : "other"; const validUntilRaw = form.get("validUntil")?.toString() ?? ""; const validUntil = validUntilRaw ? new Date(validUntilRaw) : null; if (!(fileEntry instanceof File) || fileEntry.size === 0 || !title) { return Response.json({ intent, error: "hr.documents.upload.error.generic" } satisfies UploadActionData, { status: 400 }); } if (fileEntry.size > HR_DOC_MAX_BYTES) { return Response.json({ intent, error: "hr.documents.upload.error.tooLarge" } satisfies UploadActionData, { status: 400 }); } const bytes = new Uint8Array(await fileEntry.arrayBuffer()); // Self-service: create the File gated on hr.read_own (NOT files.write) and // link it as the employee's own, editable (non-office) personnel document. const created = await createFileFromBytes({ tenantId: ctx.tenantId, userId: ctx.userId, filename: fileEntry.name || title, mimeType: fileEntry.type || "application/octet-stream", bytes, }); try { await createDocumentWithLink({ tenantId: ctx.tenantId, employeeUserId: ctx.userId, uploadedByUserId: ctx.userId, title, documentKind, fileId: created.id, visibility: "employee", uploadedByOffice: false, validUntil: validUntil && !Number.isNaN(validUntil.getTime()) ? validUntil : null, }); } catch (error) { await hardDeleteFile({ tenantId: ctx.tenantId, fileId: created.id }).catch(() => {}); throw error; } return Response.json({ intent, ok: true, messageKey: "hr.documents.toast.uploaded" } satisfies UploadActionData); } throw badRequestResponse(); } catch (error) { if (error instanceof Response) { throw error; } if (error instanceof StorageScanRejectedError) { return Response.json({ intent, error: "hr.documents.upload.error.rejected" } satisfies UploadActionData, { status: 422 }); } return hrActionErrorResponse(error); } }; const IDLE: HrDocumentUploadState = { status: "idle", errorKey: null }; export default function HrMyDocumentsRoute() { const { vm } = useLoaderData(); const archiveFetcher = useFetcher(); const uploadFetcher = useFetcher(); useSaveToast(archiveFetcher.data); useSaveToast(uploadFetcher.data); const [upload, setUpload] = useState(IDLE); // True only while a submit initiated in THIS dialog session awaits its result. // Prevents a prior upload's stale fetcher.data from re-closing a reopened dialog. const awaitingRef = useRef(false); const onUpload = useCallback( (input: HrMyDocumentsUploadInput) => { awaitingRef.current = true; setUpload({ status: "uploading", errorKey: null }); const body = new FormData(); body.set("intent", "upload-doc"); body.set("file", input.file); body.set("title", input.title); body.set("documentKind", input.documentKind); body.set("validUntil", input.validUntilIso ?? ""); uploadFetcher.submit(body, { method: "post", encType: "multipart/form-data" }); }, [uploadFetcher], ); // Reflect the upload fetcher's outcome exactly once per submission. useEffect(() => { if (!awaitingRef.current || uploadFetcher.state !== "idle" || !uploadFetcher.data) return; awaitingRef.current = false; setUpload(uploadFetcher.data.ok ? { status: "done", errorKey: null } : { status: "error", errorKey: uploadFetcher.data.error ?? "hr.documents.upload.error.generic" }); }, [uploadFetcher.state, uploadFetcher.data]); return ( archiveFetcher.submit({ intent: "archive", documentId }, { method: "post" }), onUpload, onResetUpload: () => setUpload(IDLE), }} /> ); } export function ErrorBoundary() { return ; }