import { CatalogError, foundationErrors } from "@hivegrid/foundation"; import { featureKeys } from "@hivegrid/entitlements"; import type { Params } from "react-router"; import { appPath } from "~/utils/app/CanonicalUrlUtils"; import { tenantHasModule } from "~/utils/connector/tenantConnector.server"; import { withTenantRLS } from "~/utils/db/.server/tenantRls.server"; import { getPermissionsByUser } from "~/utils/db/permissions/userRoles.db.server"; import { requireAuth } from "~/utils/loaders.middleware"; import { getTenantIdFromUrl } from "~/utils/services/.server/urlService"; import { getUserInfo } from "~/utils/session.server"; export const DASHBOARD_MODULE_KEY = featureKeys.dashboard; export const DASHBOARD_READ_PERMISSION = "dashboard.read"; export const DASHBOARD_CUSTOMIZE_PERMISSION = "dashboard.customize"; export const LEGACY_DASHBOARD_PERMISSION = "app.dashboard.view"; export type DashboardRoleKey = "gf" | "office" | "monteur"; export type DashboardWidgetDomain = "general" | "sales" | "projects" | "tasks" | "hr" | "activity" | "comms" | "schedule"; export type DashboardWidgetKind = "hero" | "kpi" | "list" | "trend"; export interface DashboardWidgetDefinition { readonly key: string; readonly domain: DashboardWidgetDomain; readonly kind: DashboardWidgetKind; readonly titleKey: string; readonly descriptionKey: string; readonly requiredAnyPermission: readonly string[]; readonly defaultPeriod: "today" | "7d" | "30d" | "quarter"; } export interface DashboardRoleLayoutDefinition { readonly role: DashboardRoleKey; readonly nameKey: string; readonly descriptionKey: string; readonly mobileFirst: boolean; readonly widgets: readonly { readonly key: string; readonly position: { readonly x: number; readonly y: number }; readonly size: { readonly w: number; readonly h: number }; readonly config?: Record; }[]; } export interface DashboardContext { readonly tenantId: string; readonly tenantSlug: string; readonly userId: string; readonly permissions: readonly string[]; readonly canCustomize: boolean; } export interface DashboardMetric { readonly labelKey: string; readonly value: string; } export interface DashboardWidgetVM { readonly key: string; readonly titleKey: string; readonly descriptionKey: string; readonly domain: DashboardWidgetDomain; readonly kind: DashboardWidgetKind; readonly period: DashboardWidgetDefinition["defaultPeriod"]; readonly visible: boolean; readonly loadingMode: "lazy"; readonly metrics: readonly DashboardMetric[]; readonly items: readonly { readonly id: string; readonly label?: string; readonly labelKey?: string; readonly href?: string; readonly meta?: string }[]; readonly position: { readonly x: number; readonly y: number }; readonly size: { readonly w: number; readonly h: number }; } export interface DashboardRoleVM { readonly role: DashboardRoleKey; readonly nameKey: string; readonly descriptionKey: string; readonly mobileFirst: boolean; readonly isDefault: boolean; readonly widgets: readonly DashboardWidgetVM[]; } export interface DashboardVM { readonly activeRole: DashboardRoleKey; readonly roles: readonly DashboardRoleVM[]; readonly generatedAt: string; readonly streamUrl: string; readonly liveUpdatesEnabled: boolean; readonly canCustomize: boolean; } type DashboardSourceSnapshot = { readonly generatedAt: string; readonly sales: { readonly openProjects: number; readonly wonProjects: number; readonly forecastValue: number; }; readonly projects: { readonly activeProjects: number; readonly dueSoon: number; readonly openDefects: number; readonly myProjects: readonly { id: string; label?: string; labelKey?: string; href: string; meta?: string }[]; }; readonly tasks: { readonly myOpen: number; readonly dueToday: number; readonly items: readonly { id: string; label?: string; labelKey?: string; href: string; meta?: string }[]; }; readonly hr: { readonly pendingRequests: number; }; readonly activity: { readonly items: readonly { id: string; label?: string; labelKey?: string; href?: string; meta?: string }[]; }; readonly comms: { readonly callsToday: number; }; readonly schedule: { readonly today: readonly { id: string; label?: string; labelKey?: string; href?: string; meta?: string }[]; }; }; const widgetCatalog = Object.freeze([ { key: "general.welcome", domain: "general", kind: "hero", titleKey: "app.dashboard.widgets.welcome.title", descriptionKey: "app.dashboard.widgets.welcome.description", requiredAnyPermission: [DASHBOARD_READ_PERMISSION, LEGACY_DASHBOARD_PERMISSION], defaultPeriod: "today", }, { key: "sales.kpis", domain: "sales", kind: "kpi", titleKey: "app.dashboard.widgets.salesKpis.title", descriptionKey: "app.dashboard.widgets.salesKpis.description", requiredAnyPermission: ["projects.read_all", "deals.read_aggregates"], defaultPeriod: "30d", }, { key: "sales.forecast", domain: "sales", kind: "trend", titleKey: "app.dashboard.widgets.salesForecast.title", descriptionKey: "app.dashboard.widgets.salesForecast.description", requiredAnyPermission: ["deals.read_aggregates", "deals.read_volume_all"], defaultPeriod: "quarter", }, { key: "projects.kpis", domain: "projects", kind: "kpi", titleKey: "app.dashboard.widgets.projectKpis.title", descriptionKey: "app.dashboard.widgets.projectKpis.description", requiredAnyPermission: ["projects.read_all", "projects.read_own", "projects.read_own_member", "projects.read_own_pl"], defaultPeriod: "30d", }, { key: "projects.open_defects", domain: "projects", kind: "kpi", titleKey: "app.dashboard.widgets.openDefects.title", descriptionKey: "app.dashboard.widgets.openDefects.description", requiredAnyPermission: ["acceptance.read", "acceptance.admin"], defaultPeriod: "30d", }, { key: "projects.my_active", domain: "projects", kind: "list", titleKey: "app.dashboard.widgets.myProjects.title", descriptionKey: "app.dashboard.widgets.myProjects.description", requiredAnyPermission: ["projects.read_all", "projects.read_own", "projects.read_own_member", "projects.read_own_pl"], defaultPeriod: "today", }, { key: "tasks.my_open", domain: "tasks", kind: "list", titleKey: "app.dashboard.widgets.myTasks.title", descriptionKey: "app.dashboard.widgets.myTasks.description", requiredAnyPermission: ["tasks.read_all", "tasks.read_own"], defaultPeriod: "today", }, { key: "hr.requests_pending", domain: "hr", kind: "kpi", titleKey: "app.dashboard.widgets.hrRequests.title", descriptionKey: "app.dashboard.widgets.hrRequests.description", requiredAnyPermission: ["hr.read_all", "hr.write", "hr.admin", "hr.leave.approve"], defaultPeriod: "30d", }, { key: "activity.recent", domain: "activity", kind: "list", titleKey: "app.dashboard.widgets.activity.title", descriptionKey: "app.dashboard.widgets.activity.description", requiredAnyPermission: [DASHBOARD_READ_PERMISSION, LEGACY_DASHBOARD_PERMISSION], defaultPeriod: "7d", }, { key: "comms.calls_today", domain: "comms", kind: "kpi", titleKey: "app.dashboard.widgets.callsToday.title", descriptionKey: "app.dashboard.widgets.callsToday.description", requiredAnyPermission: [DASHBOARD_READ_PERMISSION, LEGACY_DASHBOARD_PERMISSION], defaultPeriod: "today", }, { key: "schedule.my_today", domain: "schedule", kind: "list", titleKey: "app.dashboard.widgets.scheduleToday.title", descriptionKey: "app.dashboard.widgets.scheduleToday.description", requiredAnyPermission: ["calendar.connect_own", "bookings.read_own", "plantafel.read_own", "plantafel.read_all"], defaultPeriod: "today", }, ] as const satisfies readonly DashboardWidgetDefinition[]); const roleLayouts = Object.freeze([ { role: "gf", nameKey: "app.dashboard.roles.gf.name", descriptionKey: "app.dashboard.roles.gf.description", mobileFirst: false, widgets: [ { key: "general.welcome", position: { x: 0, y: 0 }, size: { w: 12, h: 1 } }, { key: "sales.kpis", position: { x: 0, y: 1 }, size: { w: 4, h: 2 } }, { key: "sales.forecast", position: { x: 4, y: 1 }, size: { w: 4, h: 2 } }, { key: "projects.kpis", position: { x: 8, y: 1 }, size: { w: 4, h: 2 } }, { key: "hr.requests_pending", position: { x: 0, y: 3 }, size: { w: 4, h: 2 } }, { key: "projects.open_defects", position: { x: 4, y: 3 }, size: { w: 4, h: 2 } }, { key: "activity.recent", position: { x: 8, y: 3 }, size: { w: 4, h: 2 } }, ], }, { role: "office", nameKey: "app.dashboard.roles.office.name", descriptionKey: "app.dashboard.roles.office.description", mobileFirst: false, widgets: [ { key: "general.welcome", position: { x: 0, y: 0 }, size: { w: 12, h: 1 } }, { key: "projects.kpis", position: { x: 0, y: 1 }, size: { w: 4, h: 2 } }, { key: "tasks.my_open", position: { x: 4, y: 1 }, size: { w: 4, h: 2 } }, { key: "comms.calls_today", position: { x: 8, y: 1 }, size: { w: 4, h: 2 } }, { key: "hr.requests_pending", position: { x: 0, y: 3 }, size: { w: 6, h: 2 } }, { key: "activity.recent", position: { x: 6, y: 3 }, size: { w: 6, h: 2 } }, ], }, { role: "monteur", nameKey: "app.dashboard.roles.monteur.name", descriptionKey: "app.dashboard.roles.monteur.description", mobileFirst: true, widgets: [ { key: "schedule.my_today", position: { x: 0, y: 0 }, size: { w: 12, h: 2 } }, { key: "projects.my_active", position: { x: 0, y: 2 }, size: { w: 12, h: 2 } }, { key: "tasks.my_open", position: { x: 0, y: 4 }, size: { w: 12, h: 2 } }, ], }, ] as const satisfies readonly DashboardRoleLayoutDefinition[]); const widgetByKey = new Map(widgetCatalog.map((widget) => [widget.key, widget])); export function getDashboardWidgetCatalog(): readonly DashboardWidgetDefinition[] { return widgetCatalog; } export function getDefaultDashboardRoleLayouts(): readonly DashboardRoleLayoutDefinition[] { return roleLayouts; } function hasAnyPermission(permissions: readonly string[], requiredAnyPermission: readonly string[]): boolean { return requiredAnyPermission.some((permission) => permissions.includes(permission)); } function widgetConfig(widget: DashboardRoleLayoutDefinition["widgets"][number]): Record { return "config" in widget && widget.config ? widget.config : {}; } function assertDashboardRead(permissions: readonly string[]): void { if (!hasAnyPermission(permissions, [DASHBOARD_READ_PERMISSION, LEGACY_DASHBOARD_PERMISSION])) { throw new CatalogError(foundationErrors.notFound, { permission: DASHBOARD_READ_PERMISSION }); } } export async function loadDashboardContext({ request, params }: { request: Request; params: Params }): Promise { await requireAuth({ request, params }); const [tenantId, userInfo] = await Promise.all([getTenantIdFromUrl(params), getUserInfo(request)]); if (!tenantId || !userInfo.userId) { throw new CatalogError(foundationErrors.notFound); } const [hasModule, permissions] = await Promise.all([ tenantHasModule({ tenantId, userId: userInfo.userId, moduleKey: DASHBOARD_MODULE_KEY }), getPermissionsByUser(userInfo.userId, tenantId), ]); if (!hasModule) { throw new CatalogError(foundationErrors.notFound, { module: DASHBOARD_MODULE_KEY }); } assertDashboardRead(permissions); return { tenantId, tenantSlug: params.tenant ?? tenantId, userId: userInfo.userId, permissions, canCustomize: permissions.includes(DASHBOARD_CUSTOMIZE_PERMISSION), }; } export async function ensureDefaultDashboards(ctx: Pick): Promise { await withTenantRLS(ctx.tenantId, async (tx) => { for (const layout of roleLayouts) { const dashboard = await tx.dashboard.upsert({ where: { tenantId_role_name: { tenantId: ctx.tenantId, role: layout.role, name: layout.nameKey } }, update: { description: layout.descriptionKey, isDefaultForRole: true, isShared: true, archivedAt: null, }, create: { tenantId: ctx.tenantId, role: layout.role, name: layout.nameKey, description: layout.descriptionKey, isDefaultForRole: true, isShared: true, }, }); const layoutRow = await tx.dashboardLayout.findFirst({ where: { tenantId: ctx.tenantId, dashboardId: dashboard.id, userId: null, archivedAt: null }, select: { id: true }, }); const layoutData = { role: layout.role, columns: 12, mobileFirst: layout.mobileFirst }; const widgets = layout.widgets.map((widget) => ({ key: widget.key, position: widget.position, size: widget.size, config: widgetConfig(widget) })); if (layoutRow) { await tx.dashboardLayout.update({ where: { id: layoutRow.id }, data: { widgets, layoutData, archivedAt: null }, }); } else { await tx.dashboardLayout.create({ data: { tenantId: ctx.tenantId, dashboardId: dashboard.id, userId: null, widgets, layoutData }, }); } const existingInstances = await tx.widgetInstance.findMany({ where: { tenantId: ctx.tenantId, dashboardId: dashboard.id, archivedAt: null }, select: { id: true, widgetCatalogKey: true }, }); const instanceByKey = new Map(existingInstances.map((instance) => [instance.widgetCatalogKey, instance.id])); for (const widget of layout.widgets) { const existingId = instanceByKey.get(widget.key); const data = { config: widgetConfig(widget), position: widget.position, size: widget.size, archivedAt: null, }; if (existingId) { await tx.widgetInstance.update({ where: { id: existingId }, data }); } else { await tx.widgetInstance.create({ data: { tenantId: ctx.tenantId, dashboardId: dashboard.id, widgetCatalogKey: widget.key, ...data, }, }); } } } }); } export async function loadDashboardVM({ request, params }: { request: Request; params: Params }): Promise { const ctx = await loadDashboardContext({ request, params }); await ensureDefaultDashboards(ctx); const snapshot = await loadDashboardSourceSnapshot(ctx); const requestedRole = new URL(request.url).searchParams.get("role"); const activeRole = isDashboardRole(requestedRole) ? requestedRole : defaultRoleForPermissions(ctx.permissions); return buildDashboardVM({ ctx, snapshot, activeRole }); } export async function loadDashboardStreamSnapshot({ request, params }: { request: Request; params: Params }): Promise { const ctx = await loadDashboardContext({ request, params }); const requestedRole = new URL(request.url).searchParams.get("role"); const activeRole = isDashboardRole(requestedRole) ? requestedRole : defaultRoleForPermissions(ctx.permissions); const snapshot = await loadDashboardSourceSnapshot(ctx); return buildDashboardVM({ ctx, snapshot, activeRole }); } function buildDashboardVM({ ctx, snapshot, activeRole }: { ctx: DashboardContext; snapshot: DashboardSourceSnapshot; activeRole: DashboardRoleKey }): DashboardVM { return { activeRole, generatedAt: snapshot.generatedAt, streamUrl: appPath({ tenantSlug: ctx.tenantSlug, path: `dashboard/stream?role=${activeRole}`, mode: "host-aware" }), liveUpdatesEnabled: true, canCustomize: ctx.canCustomize, roles: roleLayouts.map((layout) => ({ role: layout.role, nameKey: layout.nameKey, descriptionKey: layout.descriptionKey, mobileFirst: layout.mobileFirst, isDefault: layout.role === activeRole, widgets: layout.widgets.map((widgetLayout) => { const widget = widgetByKey.get(widgetLayout.key); if (!widget) { throw new Error(`Unknown dashboard widget key: ${widgetLayout.key}`); } const visible = hasAnyPermission(ctx.permissions, widget.requiredAnyPermission); return { key: widget.key, titleKey: widget.titleKey, descriptionKey: widget.descriptionKey, domain: widget.domain, kind: widget.kind, period: widget.defaultPeriod, visible, loadingMode: "lazy", position: widgetLayout.position, size: widgetLayout.size, ...(visible ? widgetData(widget.key, snapshot) : { metrics: [], items: [] }), }; }), })), }; } async function loadDashboardSourceSnapshot(ctx: DashboardContext): Promise { const now = new Date(); const todayStart = new Date(now); todayStart.setHours(0, 0, 0, 0); const todayEnd = new Date(todayStart); todayEnd.setDate(todayEnd.getDate() + 1); const dueSoon = new Date(now); dueSoon.setDate(dueSoon.getDate() + 14); const generatedAt = now.toISOString(); return withTenantRLS(ctx.tenantId, async (tx) => { const canReadAllProjects = ctx.permissions.includes("projects.read_all"); const canReadProjects = hasAnyPermission(ctx.permissions, ["projects.read_all", "projects.read_own", "projects.read_own_member", "projects.read_own_pl"]); const canReadTasks = hasAnyPermission(ctx.permissions, ["tasks.read_all", "tasks.read_own"]); const canReadHr = hasAnyPermission(ctx.permissions, ["hr.read_all", "hr.write", "hr.admin", "hr.leave.approve"]); const canReadSchedule = hasAnyPermission(ctx.permissions, ["calendar.connect_own", "bookings.read_own", "plantafel.read_own", "plantafel.read_all"]); const canReadDefects = hasAnyPermission(ctx.permissions, ["acceptance.read", "acceptance.admin"]); const projectOwnerWhere = canReadAllProjects ? {} : { OR: [{ zustaendigePersonId: ctx.userId }, { projektleiterId: ctx.userId }, { createdByUserId: ctx.userId }] }; const projectWhere = { tenantId: ctx.tenantId, archivedAt: null, ...projectOwnerWhere }; const [ openProjects, wonProjects, forecastSnapshots, activeProjects, dueSoonProjects, myProjects, myOpenTasks, dueTodayTasks, taskItems, pendingHrRequests, openDefects, recentActivity, callsToday, calendarEvents, appointments, ] = await Promise.all([ canReadProjects ? tx.projekt.count({ where: projectWhere }) : Promise.resolve(0), canReadProjects ? tx.projekt.count({ where: { ...projectWhere, wonAt: { not: null } } }) : Promise.resolve(0), hasAnyPermission(ctx.permissions, ["deals.read_aggregates", "deals.read_volume_all"]) ? tx.pipelineAggregateSnapshot.findMany({ where: { tenantId: ctx.tenantId, scopeKey: "pipeline" }, orderBy: { calculatedAt: "desc" }, take: 12, select: { weightedForecast: true }, }) : Promise.resolve([]), canReadProjects ? tx.projekt.count({ where: projectWhere }) : Promise.resolve(0), canReadProjects ? tx.projekt.count({ where: { ...projectWhere, deadline: { gte: todayStart, lt: dueSoon } } }) : Promise.resolve(0), canReadProjects ? tx.projekt.findMany({ where: projectWhere, orderBy: { updatedAt: "desc" }, take: 4, select: { id: true, projektname: true, projektNummer: true, deadline: true }, }) : Promise.resolve([]), canReadTasks ? tx.task.count({ where: { tenantId: ctx.tenantId, archivedAt: null, status: { notIn: ["done", "cancelled"] }, OR: [{ assignedToUserId: ctx.userId }, { createdByUserId: ctx.userId }] }, }) : Promise.resolve(0), canReadTasks ? tx.task.count({ where: { tenantId: ctx.tenantId, archivedAt: null, status: { notIn: ["done", "cancelled"] }, deadline: { gte: todayStart, lt: todayEnd }, OR: [{ assignedToUserId: ctx.userId }, { createdByUserId: ctx.userId }], }, }) : Promise.resolve(0), canReadTasks ? tx.task.findMany({ where: { tenantId: ctx.tenantId, archivedAt: null, status: { notIn: ["done", "cancelled"] }, OR: [{ assignedToUserId: ctx.userId }, { createdByUserId: ctx.userId }] }, orderBy: [{ deadline: "asc" }, { updatedAt: "desc" }], take: 4, select: { id: true, title: true, deadline: true, status: true }, }) : Promise.resolve([]), canReadHr ? tx.hrRequest.count({ where: { tenantId: ctx.tenantId, archivedAt: null, status: { in: ["submitted", "clarification"] } } }) : Promise.resolve(0), canReadDefects ? tx.projektChecklistItem.count({ where: { tenantId: ctx.tenantId, status: "offen", checklist: { tenantId: ctx.tenantId, typ: "maengel", archivedAt: null, }, }, }) : Promise.resolve(0), tx.activity.findMany({ where: { tenantId: ctx.tenantId }, orderBy: { createdAt: "desc" }, take: 5, select: { id: true, summaryText: true, subjectType: true, subjectId: true, createdAt: true }, }), tx.activity.count({ where: { tenantId: ctx.tenantId, activityType: { in: ["call", "phone_call", "comms.call"] }, createdAt: { gte: todayStart, lt: todayEnd } }, }), canReadSchedule ? tx.calendarEvent.findMany({ where: { tenantId: ctx.tenantId, userId: ctx.userId, archivedAt: null, startsAt: { gte: todayStart, lt: todayEnd } }, orderBy: { startsAt: "asc" }, take: 5, select: { id: true, title: true, startsAt: true, endsAt: true }, }) : Promise.resolve([]), canReadSchedule ? tx.appointment.findMany({ where: { tenantId: ctx.tenantId, providerUserId: ctx.userId, status: "scheduled", startAt: { gte: todayStart, lt: todayEnd } }, orderBy: { startAt: "asc" }, take: 5, select: { id: true, startAt: true, endAt: true, notesInternal: true }, }) : Promise.resolve([]), ]); const forecastValue = forecastSnapshots.reduce((sum, snapshot) => sum + numeric(snapshot.weightedForecast), 0); return { generatedAt, sales: { openProjects, wonProjects, forecastValue }, projects: { activeProjects, dueSoon: dueSoonProjects, openDefects, myProjects: myProjects.map((project) => ({ id: project.id, label: project.projektname, href: appPath({ tenantSlug: ctx.tenantSlug, path: `projects/${project.id}`, mode: "host-aware" }), meta: project.projektNummer || formatDate(project.deadline), })), }, tasks: { myOpen: myOpenTasks, dueToday: dueTodayTasks, items: taskItems.map((task) => ({ id: task.id, label: task.title, href: appPath({ tenantSlug: ctx.tenantSlug, path: `tasks`, mode: "host-aware" }), meta: task.deadline ? formatDate(task.deadline) : task.status, })), }, hr: { pendingRequests: pendingHrRequests }, activity: { items: recentActivity.map((activity) => ({ id: activity.id, label: activity.summaryText, meta: `${activity.subjectType}:${activity.subjectId}`, })), }, comms: { callsToday }, schedule: { today: [ ...calendarEvents.map((event) => ({ id: event.id, ...(event.title ? { label: event.title } : { labelKey: "app.dashboard.schedule.untitled" }), meta: formatTimeRange(event.startsAt, event.endsAt), })), ...appointments.map((appointment) => ({ id: appointment.id, ...(appointment.notesInternal ? { label: appointment.notesInternal } : { labelKey: "app.dashboard.schedule.appointment" }), meta: formatTimeRange(appointment.startAt, appointment.endAt), })), ], }, }; }); } function widgetData(key: string, snapshot: DashboardSourceSnapshot): Pick { switch (key) { case "general.welcome": return { metrics: [{ labelKey: "app.dashboard.metrics.lastUpdated", value: snapshot.generatedAt }], items: [] }; case "sales.kpis": return { metrics: [ { labelKey: "app.dashboard.metrics.openProjects", value: String(snapshot.sales.openProjects) }, { labelKey: "app.dashboard.metrics.wonProjects", value: String(snapshot.sales.wonProjects) }, ], items: [], }; case "sales.forecast": return { metrics: [{ labelKey: "app.dashboard.metrics.forecast", value: currency(snapshot.sales.forecastValue) }], items: [] }; case "projects.kpis": return { metrics: [ { labelKey: "app.dashboard.metrics.activeProjects", value: String(snapshot.projects.activeProjects) }, { labelKey: "app.dashboard.metrics.dueSoon", value: String(snapshot.projects.dueSoon) }, ], items: [], }; case "projects.open_defects": return { metrics: [{ labelKey: "app.dashboard.metrics.openDefects", value: String(snapshot.projects.openDefects) }], items: [] }; case "projects.my_active": return { metrics: [], items: snapshot.projects.myProjects }; case "tasks.my_open": return { metrics: [ { labelKey: "app.dashboard.metrics.myOpenTasks", value: String(snapshot.tasks.myOpen) }, { labelKey: "app.dashboard.metrics.dueToday", value: String(snapshot.tasks.dueToday) }, ], items: snapshot.tasks.items, }; case "hr.requests_pending": return { metrics: [{ labelKey: "app.dashboard.metrics.pendingHrRequests", value: String(snapshot.hr.pendingRequests) }], items: [] }; case "activity.recent": return { metrics: [], items: snapshot.activity.items }; case "comms.calls_today": return { metrics: [{ labelKey: "app.dashboard.metrics.callsToday", value: String(snapshot.comms.callsToday) }], items: [] }; case "schedule.my_today": return { metrics: [], items: snapshot.schedule.today }; default: return { metrics: [], items: [] }; } } function isDashboardRole(value: string | null): value is DashboardRoleKey { return value === "gf" || value === "office" || value === "monteur"; } function defaultRoleForPermissions(permissions: readonly string[]): DashboardRoleKey { if (permissions.includes("projects.read_all") || permissions.includes("deals.read_aggregates")) return "gf"; if (permissions.includes("plantafel.read_own") || permissions.includes("calendar.connect_own")) return "monteur"; return "office"; } function numeric(value: unknown): number { if (typeof value === "number") return value; if (typeof value === "string") return Number(value) || 0; if (value && typeof value === "object" && "toString" in value) return Number(value.toString()) || 0; return 0; } function currency(value: number): string { return new Intl.NumberFormat("de-DE", { style: "currency", currency: "EUR", maximumFractionDigits: 0 }).format(value); } function formatDate(value: Date | null | undefined): string | undefined { return value ? value.toISOString().slice(0, 10) : undefined; } function formatTimeRange(start: Date, end: Date): string { return `${start.toISOString().slice(11, 16)}-${end.toISOString().slice(11, 16)}`; }