Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/apps/web/app/routes/app.$tenant/tasks._index.tsx
T
2026-07-08 16:15:37 +02:00

165 lines
6.8 KiB
TypeScript

// P4 Tasks (AK-P4b) §6 — Tasks browser route. Loader builds the TaskListVM once
// (server-side); the component only renders (DoD A). Module off -> locked empty
// state. Missing tasks.read_own -> 404. Presets (mine/created/all) + server-side
// filters. The list shape is the reusable component (DoD 8); this route is its
// standalone host.
//
// Interim-UI (AD-28): renders the ~/ui preview screen TasksListPage; the loader
// owns navigation for preset/filter changes (server-side). Final Subframe optics
// land as a tracked design-nachzug once David's D-P4 delta ships.
import { type LoaderFunctionArgs, useLoaderData, useNavigate } from "react-router";
import {
buildTaskListVM,
taskEntityLabelKey,
taskPriorityKey,
taskSourceKey,
taskStatusKey,
type TaskListPreset,
type TaskListRow,
type TaskListVM,
} from "@hivegrid/view-models";
import { getTranslations } from "~/locale/i18next.server";
import { loadTasksContext, notFoundResponse, requireTasksPermission } from "~/utils/integrations/taskAccess.server";
import {
listTasksForBrowser,
resolveGroupLabels,
resolveUserLabels,
type TaskPriority,
type TaskRow,
type TaskStatus,
} from "~/utils/integrations/taskService.server";
import { tasksDetailPath, tasksNewPath } from "~/utils/integrations/taskRoutePaths";
import { TasksListPage, type TaskListQuery } from "~/components/screens/tasks/TasksListPage";
import ServerError from "~/components/ui/errors/ServerError";
type LoaderData = { title: string; vm: TaskListVM; includeDemoData: boolean; nextHref: string | null };
const PRESETS: readonly TaskListPreset[] = ["mine", "created", "all"];
const TERMINAL: ReadonlySet<TaskStatus> = new Set<TaskStatus>(["done", "cancelled"]);
function parsePreset(value: string | null): TaskListPreset {
return PRESETS.includes(value as TaskListPreset) ? (value as TaskListPreset) : "all";
}
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const { t } = await getTranslations(request);
const ctx = await loadTasksContext({ request, params });
const tenantSlug = params.tenant ?? "";
const url = new URL(request.url);
const includeDemoData = url.searchParams.get("demo") === "show";
const emptyFilter = { preset: "all" as TaskListPreset, status: null, priority: null, assignedToUserId: null, includeArchived: false };
if (!ctx.hasModule) {
const vm = buildTaskListVM({ rows: [], filter: emptyFilter, canWrite: false, canDelete: false, createHref: tasksNewPath(tenantSlug) });
return Response.json({ title: `${t("tasks.list.title")} | ${process.env.APP_NAME}`, vm, includeDemoData, nextHref: null } satisfies LoaderData);
}
try {
requireTasksPermission(ctx, "tasks.read_own");
} catch {
throw notFoundResponse();
}
const preset = parsePreset(url.searchParams.get("preset"));
const status = (url.searchParams.get("status") as TaskStatus | null) || null;
const priority = (url.searchParams.get("priority") as TaskPriority | null) || null;
const includeArchived = url.searchParams.get("archived") === "1";
const cursor = url.searchParams.get("cursor");
const { rows, nextCursor } = await listTasksForBrowser({
tenantId: ctx.tenantId,
ctx,
filter: { preset, status, priority, includeArchived, includeDemoData },
cursor,
});
// Batch-resolve assignee display names for the page.
const [userLabels, groupLabels] = await Promise.all([
resolveUserLabels(rows.map((row) => row.assignedToUserId).filter((id): id is string => Boolean(id))),
resolveGroupLabels(
ctx.tenantId,
rows.map((row) => row.assignedToGroupId).filter((id): id is string => Boolean(id))
),
]);
const now = Date.now();
const listRows: TaskListRow[] = rows.map((task) => toTaskListRow(task, { tenantSlug, userLabels, groupLabels, now }));
const canWrite = ctx.permissions.includes("tasks.write");
const canDelete = ctx.permissions.includes("tasks.delete");
const vm = buildTaskListVM({
rows: listRows,
filter: { preset, status, priority, assignedToUserId: null, includeArchived },
canWrite,
canDelete,
createHref: tasksNewPath(tenantSlug),
nextCursor,
});
// Preserve the active preset/filter when paging via cursor.
const nextParams = new URLSearchParams();
if (preset !== "all") nextParams.set("preset", preset);
if (status) nextParams.set("status", status);
if (priority) nextParams.set("priority", priority);
if (includeArchived) nextParams.set("archived", "1");
if (includeDemoData) nextParams.set("demo", "show");
if (nextCursor) nextParams.set("cursor", nextCursor);
const nextHref = nextCursor ? `?${nextParams.toString()}` : null;
return Response.json({ title: `${t("tasks.list.title")} | ${process.env.APP_NAME}`, vm, includeDemoData, nextHref } satisfies LoaderData);
};
/** Map a domain TaskRow to the routing-resolved TaskListRow (shared by embeds). */
export function toTaskListRow(
task: TaskRow,
deps: { tenantSlug: string; userLabels: Map<string, string>; groupLabels: Map<string, string>; now: number }
): TaskListRow {
const assignee = task.assignedToUserId
? { kind: "user" as const, label: deps.userLabels.get(task.assignedToUserId) ?? task.assignedToUserId }
: task.assignedToGroupId
? { kind: "group" as const, label: deps.groupLabels.get(task.assignedToGroupId) ?? task.assignedToGroupId }
: null;
return {
id: task.id,
title: task.title,
status: task.status,
statusKey: taskStatusKey(task.status),
priority: task.priority,
priorityKey: taskPriorityKey(task.priority),
deadlineIso: task.deadline ? task.deadline.toISOString() : null,
isOverdue: Boolean(task.deadline && task.deadline.getTime() < deps.now && !TERMINAL.has(task.status)),
assignee,
linkedEntity:
task.linkedEntityType && task.linkedEntityId
? { entityType: task.linkedEntityType, entityId: task.linkedEntityId, labelKey: taskEntityLabelKey(task.linkedEntityType) }
: null,
source: task.source,
sourceKey: taskSourceKey(task.source),
sourceHref: null,
detailHref: tasksDetailPath(deps.tenantSlug, task.id),
};
}
export default function TasksBrowserRoute() {
const { vm, includeDemoData, nextHref } = useLoaderData<LoaderData>();
const navigate = useNavigate();
function onApply(query: TaskListQuery) {
const params = new URLSearchParams();
if (query.preset !== "all") params.set("preset", query.preset);
if (query.status) params.set("status", query.status);
if (query.priority) params.set("priority", query.priority);
if (query.includeArchived) params.set("archived", "1");
if (query.includeDemoData) params.set("demo", "show");
// Reset cursor pagination whenever the preset/filter changes.
navigate({ search: params.toString() });
}
return <TasksListPage vm={vm} includeDemoData={includeDemoData} nextHref={nextHref} actions={{ onApply }} />;
}
export function ErrorBoundary() {
return <ServerError />;
}