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

206 lines
9.5 KiB
TypeScript

import { Link, LoaderFunctionArgs, useLoaderData, useNavigate } from "react-router";
import { useSearchParams } from "react-router";
import { ready, toFirstStepsChecklistVM, type FirstStepsChecklistVM } from "@hivegrid/view-models";
import { useAppData } from "~/utils/data/useAppData";
import { DashboardLoaderData, loadDashboardData } from "~/utils/data/useDashboardData";
import { getTranslations } from "~/locale/i18next.server";
import { getAppDashboardStats } from "~/utils/services/appDashboardService";
import { DashboardStats } from "~/components/ui/stats/DashboardStats";
import { getTenantIdFromUrl } from "~/utils/services/.server/urlService";
import { Stat } from "~/application/dtos/stats/Stat";
import InputSelect from "~/components/ui/input/InputSelect";
import PeriodHelper, { defaultPeriodFilter, PeriodFilters } from "~/utils/helpers/PeriodHelper";
import { useTranslation } from "react-i18next";
import ServerError from "~/components/ui/errors/ServerError";
import { serverTimingHeaders } from "~/modules/metrics/utils/defaultHeaders";
import { createMetrics } from "~/modules/metrics/services/.server/MetricTracker";
import { promiseHash } from "~/utils/promises/promiseHash";
import { getTenant } from "~/utils/db/tenants.db.server";
import { Fragment } from "react";
import { loadAppData } from "~/utils/data/.server/appData";
import { getUserHasPermission } from "~/utils/helpers/PermissionsHelper";
import { requireAuth } from "~/utils/loaders.middleware";
import { v2MetaFunction } from "~/utils/compat/v2MetaFunction";
import { appTenantPlanRequiredPath } from "~/utils/app/AppTenantStatusPaths";
import {
evaluateDashboardModuleGates,
getDashboardModuleDiagnostics,
getVisibleDashboardModules,
type DashboardModuleGateDiagnostic,
} from "~/services/dashboard-registry/gating.server";
import type { DashboardModuleDefinition, DashboardModuleId } from "~/services/dashboard-registry/registry.server";
import { loadDashboardVM, type DashboardVM } from "~/services/dashboard/dashboard.server";
import { getFirstStepsChecklist } from "~/utils/services/.server/akP20OnboardingService";
import { DashboardPage } from "~/components/screens/dashboard/DashboardPage";
import { useDashboardStream } from "~/components/screens/dashboard/useDashboardStream";
import { FirstStepsChecklistWidget } from "~/components/screens/onboarding/FirstStepsChecklistWidget";
import UrlUtils from "~/utils/app/UrlUtils";
export { serverTimingHeaders as headers };
const DASHBOARD_READ_PERMISSION = "dashboard.read";
const LEGACY_DASHBOARD_PERMISSION = "app.dashboard.view";
const FIRST_STEPS_CHECKLIST_PERMISSION = "app.onboarding.checklist.update";
export const meta: v2MetaFunction<LoaderData> = ({ data }) => [{ title: data?.title }];
type LoaderData = DashboardLoaderData & {
title: string;
stats: Stat[];
modules: DashboardModuleDefinition[];
moduleDiagnostics: DashboardModuleGateDiagnostic[];
dashboard: DashboardVM;
firstStepsChecklist: FirstStepsChecklistVM;
};
function isDashboardModuleVisible(modules: readonly DashboardModuleDefinition[], moduleId: DashboardModuleId) {
return modules.some((module) => module.id === moduleId);
}
function getSafeModuleNoticePath(diagnostic: DashboardModuleGateDiagnostic) {
if (diagnostic.source === "plan") {
return diagnostic.redirectPath?.startsWith("/") ? diagnostic.redirectPath : "/plan-required";
}
return diagnostic.redirectPath?.startsWith("/") ? diagnostic.redirectPath : "/feature-disabled";
}
export const loader = async ({ request, params }: LoaderFunctionArgs) => {
const userInfo = await requireAuth({ request, params });
const { time, getServerTimingHeader } = await createMetrics({ request, params }, "app.$tenant.dashboard");
let { t } = await getTranslations(request);
const { tenantId, appData } = await time(
promiseHash({
tenantId: getTenantIdFromUrl(params),
appData: loadAppData({ request, params, t, time }),
}),
"app.$tenant.dashboard.context"
);
const tenant = await time(getTenant(tenantId), "getTenant");
if (!tenant) {
throw Response.json({ error: t("app.dashboard.errors.tenantNotFound") }, { status: 404 });
}
const canViewFirstStepsChecklist = getUserHasPermission(appData, FIRST_STEPS_CHECKLIST_PERMISSION);
const firstStepsChecklistRequest = canViewFirstStepsChecklist
? getFirstStepsChecklist({ tenantId, userId: userInfo.userId }).then((checklist) =>
toFirstStepsChecklistVM({
...checklist,
items: checklist.items.map((item) => ({ ...item, href: UrlUtils.currentTenantUrl(params, item.href) })),
})
)
: Promise.resolve<FirstStepsChecklistVM>({ status: "empty" });
const { stats, dashboardData, dashboard, firstStepsChecklist, moduleDecisions } = await time(
promiseHash({
stats: getAppDashboardStats({ t, tenant, gte: PeriodHelper.getGreaterThanOrEqualsFromRequest({ request }) }),
dashboardData: loadDashboardData({ request, params }),
dashboard: loadDashboardVM({ request, params }),
firstStepsChecklist: firstStepsChecklistRequest,
moduleDecisions: evaluateDashboardModuleGates({
request,
params,
subscription: appData.mySubscription,
redirectPaths: {
"feature-flag": `/feature-disabled?tenant=${encodeURIComponent(tenant.slug)}`,
plan: appTenantPlanRequiredPath({ tenant: tenant.slug }),
},
}),
}),
"app.$tenant.dashboard.details"
);
const data: LoaderData = {
title: `${t("app.sidebar.dashboard")} | ${process.env.APP_NAME}`,
...dashboardData,
stats,
modules: getVisibleDashboardModules(moduleDecisions),
moduleDiagnostics: getDashboardModuleDiagnostics(moduleDecisions),
dashboard,
firstStepsChecklist,
};
return Response.json(data, { headers: getServerTimingHeader() });
};
export default function DashboardRoute() {
const { t } = useTranslation();
const appData = useAppData();
const data = useLoaderData<LoaderData>();
const navigate = useNavigate();
const [searchParams, setSearchParams] = useSearchParams();
const { snapshot } = useDashboardStream({
streamUrl: data.dashboard.streamUrl,
initialGeneratedAt: data.dashboard.generatedAt,
});
const canViewSummary = isDashboardModuleVisible(data.modules, "summary-stats");
const canViewDashboard =
getUserHasPermission(appData, DASHBOARD_READ_PERMISSION) || getUserHasPermission(appData, LEGACY_DASHBOARD_PERMISSION);
const dashboard = snapshot ?? data.dashboard;
const planRequiredDiagnostics = data.moduleDiagnostics.filter((diagnostic) => diagnostic.reason === "plan-required");
return (
<main className="relative z-0 flex-1 pb-8" data-ui-id="ui.dashboard.page">
{/* The screen renders its own full-bleed page header; only the sibling blocks stay in the centered column. */}
{canViewDashboard ? (
<DashboardPage vm={ready(dashboard)} />
) : null}
<div className="grid w-full gap-5 px-4 py-5 sm:px-6">
{canViewDashboard ? (
<Fragment>
{canViewSummary && data.stats.length > 0 && (
<div className="space-y-3 p-1">
<div className="flex items-center justify-between space-x-2">
<h3 className="text-foreground grow leading-4 font-medium">{t("app.dashboard.summary")}</h3>
<div>
<InputSelect
className="w-48 shrink-0"
name="period"
value={searchParams.get("period")?.toString() ?? defaultPeriodFilter}
options={PeriodFilters.map((f) => {
return {
value: f.value,
name: t(f.name),
};
})}
setValue={(value) => {
if (value) {
searchParams.set("period", value?.toString() ?? "");
} else {
searchParams.delete("period");
}
setSearchParams(searchParams);
}}
/>
</div>
</div>
<DashboardStats items={data.stats} />
</div>
)}
{/* Feature-disabled diagnostics still gate the module content but render no notice —
only actionable plan-required diagnostics surface to the user. */}
{planRequiredDiagnostics.length > 0 && (
<div className="space-y-2">
{planRequiredDiagnostics.map((diagnostic) => (
<div key={diagnostic.moduleId} className="border-border bg-secondary rounded-md border border-dashed px-4 py-3 text-sm">
<div className="text-foreground font-medium">{t("app.dashboard.moduleDiagnostics.planRequiredTitle")}</div>
<div className="text-muted-foreground mt-1">{t("app.dashboard.moduleDiagnostics.planRequiredDescription")}</div>
<Link className="text-theme-600 mt-2 inline-flex underline" to={getSafeModuleNoticePath(diagnostic)}>
{t("app.dashboard.moduleDiagnostics.viewPlanOptions")}
</Link>
</div>
))}
</div>
)}
<FirstStepsChecklistWidget vm={data.firstStepsChecklist} href="../onboarding/checklist" onOpen={(href) => navigate(href)} />
</Fragment>
) : (
<div className="font-medium">{t("app.dashboard.noPermission")}</div>
)}
</div>
</main>
);
}
export function ErrorBoundary() {
return <ServerError />;
}