Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/routes/app.$tenant/projects.plantafel.tsx
T

343 lines
14 KiB
TypeScript

import {
useActionData,
useFetcher,
useLoaderData,
useLocation,
useNavigate,
useNavigation,
useSubmit,
type ActionFunctionArgs,
type LoaderFunctionArgs,
} from "react-router";
import { fromZonedTime } from "date-fns-tz";
import { addDaysIso, buildPlantafelVM, parsePlantafelSort, startOfWeekIso, type PlantafelSort } from "@hivegrid/view-models";
import { APP_TIME_ZONE } from "~/locale/format";
import {
applyOfflineMutation,
bulkReassignScheduleEntries,
listEditablePlantafelProjectOptions,
loadPlantafel,
updateScheduleEntryStatus,
upsertScheduleEntry,
type PlantafelVM,
type ScheduleEntryStatus,
} from "~/utils/integrations/projects/plantafelAcceptanceService.server";
import {
loadProjectContext,
projectActionErrorResponse,
projectNotFoundResponse,
requireProjectPermission,
requireProjectView,
} from "~/utils/integrations/projects/projectAccess.server";
import { listAssignableUsers, resolveUserLabels } from "~/utils/integrations/crm/crmService.server";
import { PlantafelPage, type PlantafelOption, type PlantafelViewMode } from "~/components/screens/projects/PlantafelPage";
import { useSaveToast } from "~/hooks/use-save-toast";
type LoaderData = {
plantafel: PlantafelVM;
projectLabels: PlantafelOption[];
editableProjectIds: string[];
projectOptions: PlantafelOption[];
projectOptionsHasMore: boolean;
assigneeOptions: PlantafelOption[];
canWrite: boolean;
canBulkReassign: boolean;
filter: { assignedUserId: string | null; includePast: boolean; sort: PlantafelSort };
view: PlantafelViewMode;
anchorIso: string;
todayIso: string;
};
type ProjectPickerLoaderData = {
resource: "projectPicker";
projectOptions: PlantafelOption[];
projectOptionsHasMore: boolean;
projectQuery: string;
};
type PlantafelActionData = {
intent: string | null;
ok?: boolean;
error?: string;
};
function formString(formData: FormData, name: string): string | null {
const value = formData.get(name);
return typeof value === "string" ? value : null;
}
function parseJsonObject(value: string | null): Record<string, unknown> {
if (!value) return {};
const parsed = JSON.parse(value) as unknown;
return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? (parsed as Record<string, unknown>) : {};
}
function parseEntryIds(formData: FormData): string[] {
const raw = formString(formData, "entryIds");
if (!raw) return [];
const parsed = JSON.parse(raw) as unknown;
return Array.isArray(parsed) ? parsed.filter((item): item is string => typeof item === "string") : [];
}
function dateParam(url: URL, name: string, fallback: Date): Date {
const value = url.searchParams.get(name);
const parsed = value ? new Date(value) : fallback;
return Number.isNaN(parsed.getTime()) ? fallback : parsed;
}
const DATE_ISO_RE = /^\d{4}-\d{2}-\d{2}$/u;
/** How far back the table reaches once past appointments are switched on. */
const PLANTAFEL_PAST_WINDOW_DAYS = 21;
/** Today as `YYYY-MM-DD` in the fixed app time zone, so server and client agree on the cells. */
function todayIsoInAppTz(now: Date): string {
return new Intl.DateTimeFormat("en-CA", { timeZone: APP_TIME_ZONE, year: "numeric", month: "2-digit", day: "2-digit" }).format(now);
}
/** Local midnight of a calendar date in the app time zone, as an absolute instant. */
function startOfDayInAppTz(dateIso: string): Date {
return fromZonedTime(`${dateIso}T00:00:00`, APP_TIME_ZONE);
}
export async function loader({ request, params }: LoaderFunctionArgs) {
const ctx = await requireProjectView({ request, params }, ["plantafel.read_all", "plantafel.read_own"]);
const url = new URL(request.url);
const now = new Date();
// `range=today` narrows the table window to the current day; without it the
// table shows the next 7 days. The quick-range buttons are gone from the
// toolbar (search + monteur picker took their place), but the parameter stays
// part of the URL contract - the mobile Monteur "today" view is a tracked
// design-nachzug and links pointing at it must keep working.
const startOfToday = new Date(now.getFullYear(), now.getMonth(), now.getDate());
// Past appointments are hidden by default - the plantafel is a planning
// board, not an archive. The toggle widens the window backwards; the service
// caps a range at 31 days, so three weeks back plus the seven ahead stays
// safely inside it even across a DST change.
const includePast = url.searchParams.get("past") === "1";
const pastWindowStart = new Date(startOfToday.getTime() - PLANTAFEL_PAST_WINDOW_DAYS * 24 * 60 * 60 * 1000);
// Calendar view renders a fixed Monday-Sunday week, so it resolves its own
// window from the anchor instead of the quick ranges above.
const view: PlantafelViewMode = url.searchParams.get("view") === "calendar" ? "calendar" : "table";
const todayIso = todayIsoInAppTz(now);
const anchorParam = url.searchParams.get("anchor");
const anchorIso = anchorParam && DATE_ISO_RE.test(anchorParam) ? anchorParam : todayIso;
const weekStartIso = startOfWeekIso(anchorIso);
const from =
view === "calendar"
? startOfDayInAppTz(weekStartIso)
: url.searchParams.get("range") === "today"
? startOfToday
: dateParam(url, "from", includePast ? pastWindowStart : startOfToday);
const to =
view === "calendar"
? startOfDayInAppTz(addDaysIso(weekStartIso, 7))
: url.searchParams.get("range") === "today"
? new Date(startOfToday.getTime() + 24 * 60 * 60 * 1000)
: // The window always reaches the same seven days ahead - switching the
// past on extends it backwards, it must not drag the end back too.
dateParam(url, "to", new Date(startOfToday.getTime() + 7 * 24 * 60 * 60 * 1000));
// Whose appointments to show. A user without plantafel.read_all is pinned to
// their own rows by the service, no matter what this parameter says.
const assignedUserId = url.searchParams.get("assignedUserId");
// Row order for the table. Narrowed here so an unknown value falls back to
// the chronological default instead of reaching the component.
const sort = parsePlantafelSort(url.searchParams.get("sort"));
const canWrite = ctx.permissions.includes("plantafel.write");
const canReadAll = ctx.permissions.includes("plantafel.read_all");
const canBulkReassign = ctx.permissions.includes("plantafel.bulk_reassign");
if (url.searchParams.get("_resource") === "projectPicker") {
if (!canWrite) throw projectNotFoundResponse();
const picker = await listEditablePlantafelProjectOptions({
tenantId: ctx.tenantId,
ctx,
query: url.searchParams.get("projectQuery"),
});
return Response.json({
resource: "projectPicker",
projectOptions: picker.options,
projectOptionsHasMore: picker.hasMore,
projectQuery: picker.query,
} satisfies ProjectPickerLoaderData);
}
const assigneeOptionsPromise =
canWrite || canReadAll
? listAssignableUsers(ctx.tenantId)
: resolveUserLabels([ctx.userId]).then((labels) => {
const label = labels.get(ctx.userId);
return label ? [{ id: ctx.userId, label }] : [];
});
const projectOptionsPromise = canWrite
? listEditablePlantafelProjectOptions({ tenantId: ctx.tenantId, ctx })
: Promise.resolve({ options: [], hasMore: false, query: "" });
const [plantafel, projectPicker, assigneeOptions] = await Promise.all([
loadPlantafel({
tenantId: ctx.tenantId,
ctx,
from,
to,
assignedUserId,
}),
projectOptionsPromise,
assigneeOptionsPromise,
]);
return Response.json({
plantafel,
projectLabels: plantafel.projectLabels,
editableProjectIds: plantafel.editableProjectIds,
projectOptions: projectPicker.options,
projectOptionsHasMore: projectPicker.hasMore,
assigneeOptions,
canWrite,
canBulkReassign,
filter: { assignedUserId, includePast, sort },
view,
anchorIso,
todayIso,
} satisfies LoaderData);
}
export async function action({ request, params }: ActionFunctionArgs) {
const ctx = await loadProjectContext({ request, params, requireModule: true });
const formData = await request.formData();
const intent = formString(formData, "_action");
try {
if (intent === "upsertSchedule") {
requireProjectPermission(ctx, "plantafel.write");
const result = await upsertScheduleEntry({
tenantId: ctx.tenantId,
ctx,
entryId: formString(formData, "entryId"),
projektId: formString(formData, "projektId") ?? "",
assignedUserId: formString(formData, "assignedUserId") ?? "",
title: formString(formData, "title") ?? "",
startAt: formString(formData, "startAt") ?? "",
endAt: formString(formData, "endAt") ?? "",
status: (formString(formData, "status") as ScheduleEntryStatus | null) ?? "planned",
calendarEventId: formString(formData, "calendarEventId"),
conflictOverrideReason: formString(formData, "conflictOverrideReason"),
clientMutationId: formString(formData, "clientMutationId"),
});
return Response.json({ ok: true, intent, ...result });
}
if (intent === "updateStatus") {
requireProjectPermission(ctx, "plantafel.write");
const entry = await updateScheduleEntryStatus({
tenantId: ctx.tenantId,
ctx,
entryId: formString(formData, "entryId") ?? "",
status: (formString(formData, "status") as ScheduleEntryStatus | null) ?? "planned",
clientMutationId: formString(formData, "clientMutationId"),
});
return Response.json({ ok: true, intent, entry });
}
if (intent === "bulkReassign") {
requireProjectPermission(ctx, "plantafel.bulk_reassign");
const result = await bulkReassignScheduleEntries({
tenantId: ctx.tenantId,
ctx,
entryIds: parseEntryIds(formData),
assignedUserId: formString(formData, "assignedUserId") ?? "",
conflictOverrideReason: formString(formData, "conflictOverrideReason"),
});
return Response.json({ ok: true, intent, ...result });
}
if (intent === "offlineSync") {
const result = await applyOfflineMutation({
tenantId: ctx.tenantId,
ctx,
clientMutationId: formString(formData, "clientMutationId") ?? "",
operation: formString(formData, "operation"),
payload: parseJsonObject(formString(formData, "payload")),
});
return Response.json({ ok: true, intent, ...result });
}
return Response.json({ intent, error: "projects.error.unsupportedAction" }, { status: 400 });
} catch (error) {
const response = projectActionErrorResponse(error);
const payload = (await response.json()) as Record<string, unknown>;
return Response.json({ ...payload, intent }, { status: response.status });
}
}
export default function PlantafelRoute() {
const data = useLoaderData<LoaderData>();
const actionData = useActionData<PlantafelActionData>();
const projectPicker = useFetcher<ProjectPickerLoaderData>();
const location = useLocation();
const navigate = useNavigate();
const navigation = useNavigation();
const submit = useSubmit();
const vm = buildPlantafelVM(data.plantafel);
// Every write here answers with `{ ok }` or an error key, so the confirmation
// follows the server's verdict rather than the click. `offlineSync` stays out:
// it reports its outcome in the card it runs from, and a toast would say the
// same thing twice.
useSaveToast(actionData, { intents: ["upsertSchedule", "updateStatus", "bulkReassign"] });
return (
<PlantafelPage
vm={vm}
projectLabels={data.projectLabels}
editableProjectIds={data.editableProjectIds}
projectOptions={projectPicker.data?.resource === "projectPicker" ? projectPicker.data.projectOptions : data.projectOptions}
projectOptionsHasMore={projectPicker.data?.resource === "projectPicker" ? projectPicker.data.projectOptionsHasMore : data.projectOptionsHasMore}
projectPickerLoading={projectPicker.state !== "idle"}
assigneeOptions={data.assigneeOptions}
canWrite={data.canWrite}
canBulkReassign={data.canBulkReassign}
filter={data.filter}
view={data.view}
anchorIso={data.anchorIso}
todayIso={data.todayIso}
submitting={navigation.state !== "idle"}
actionResult={actionData ?? null}
actions={{
onSubmit: (intent, fields) => {
const fd = new FormData();
fd.set("_action", intent);
for (const [key, value] of Object.entries(fields ?? {})) fd.set(key, value);
submit(fd, { method: "post" });
},
onProjectSearch: (query) => {
const search = new URLSearchParams(location.search);
search.set("_resource", "projectPicker");
search.set("projectQuery", query);
projectPicker.load(`${location.pathname}?${search.toString()}`);
},
onFilterChange: (next) => {
const search = new URLSearchParams(location.search);
if (next.assignedUserId) search.set("assignedUserId", next.assignedUserId);
else search.delete("assignedUserId");
if (next.includePast) search.set("past", "1");
else search.delete("past");
if (next.sort !== "start_asc") search.set("sort", next.sort);
else search.delete("sort");
const query = search.toString();
void navigate(`${location.pathname}${query ? `?${query}` : ""}`);
},
onViewChange: (next) => {
const search = new URLSearchParams(location.search);
// The table's quick ranges and the week's anchor describe different
// windows - drop the other view's window parameters on the switch.
search.delete("from");
search.delete("to");
if (next === "calendar") {
search.set("view", "calendar");
search.delete("range");
} else {
search.delete("view");
search.delete("anchor");
}
void navigate(`${location.pathname}?${search.toString()}`);
},
onAnchorChange: (anchorIso) => {
const search = new URLSearchParams(location.search);
search.set("view", "calendar");
search.set("anchor", anchorIso);
void navigate(`${location.pathname}?${search.toString()}`);
},
}}
/>
);
}