@open-mercato/core 0.4.2-canary-10c7a8bf2a → 0.4.2-canary-c84cff7ed5

package/src/modules/dashboards/api/widgets/data/route.ts

@@ -0,0 +1,221 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import type { EntityManager } from '@mikro-orm/postgresql'
+import type { CacheStrategy } from '@open-mercato/cache'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { createRequestContainer } from '@open-mercato/shared/lib/di/container'
+import { resolveOrganizationScopeForRequest } from '@open-mercato/core/modules/directory/utils/organizationScope'
+import {
+  createWidgetDataService,
+  type WidgetDataRequest,
+  WidgetDataValidationError,
+} from '../../../services/widgetDataService'
+import type { AnalyticsRegistry } from '../../../services/analyticsRegistry'
+import type { OpenApiMethodDoc, OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { dashboardsTag, dashboardsErrorSchema } from '../../openapi'
+
+export const metadata = {
+  POST: { requireAuth: true, requireFeatures: ['analytics.view'] },
+}
+
+const aggregateFunctionSchema = z.enum(['count', 'sum', 'avg', 'min', 'max'])
+const dateGranularitySchema = z.enum(['day', 'week', 'month', 'quarter', 'year'])
+const dateRangePresetSchema = z.enum([
+  'today',
+  'yesterday',
+  'this_week',
+  'last_week',
+  'this_month',
+  'last_month',
+  'this_quarter',
+  'last_quarter',
+  'this_year',
+  'last_year',
+  'last_7_days',
+  'last_30_days',
+  'last_90_days',
+])
+
+const filterOperatorSchema = z.enum([
+  'eq',
+  'neq',
+  'gt',
+  'gte',
+  'lt',
+  'lte',
+  'in',
+  'not_in',
+  'is_null',
+  'is_not_null',
+])
+
+const widgetDataRequestSchema = z.object({
+  entityType: z.string().min(1),
+  metric: z.object({
+    field: z.string().min(1),
+    aggregate: aggregateFunctionSchema,
+  }),
+  groupBy: z
+    .object({
+      field: z.string().min(1),
+      granularity: dateGranularitySchema.optional(),
+      limit: z.number().int().min(1).max(100).optional(),
+      resolveLabels: z.boolean().optional(),
+    })
+    .optional(),
+  filters: z
+    .array(
+      z.object({
+        field: z.string().min(1),
+        operator: filterOperatorSchema,
+        value: z.unknown().optional(),
+      }),
+    )
+    .optional(),
+  dateRange: z
+    .object({
+      field: z.string().min(1),
+      preset: dateRangePresetSchema,
+    })
+    .optional(),
+  comparison: z
+    .object({
+      type: z.enum(['previous_period', 'previous_year']),
+    })
+    .optional(),
+})
+
+const widgetDataItemSchema = z.object({
+  groupKey: z.unknown(),
+  groupLabel: z.string().optional(),
+  value: z.number().nullable(),
+})
+
+const widgetDataResponseSchema = z.object({
+  value: z.number().nullable(),
+  data: z.array(widgetDataItemSchema),
+  comparison: z
+    .object({
+      value: z.number().nullable(),
+      change: z.number(),
+      direction: z.enum(['up', 'down', 'unchanged']),
+    })
+    .optional(),
+  metadata: z.object({
+    fetchedAt: z.string(),
+    recordCount: z.number(),
+  }),
+})
+
+export async function POST(req: Request) {
+  const auth = await getAuthFromRequest(req)
+  if (!auth) {
+    return NextResponse.json({ error: 'Unauthorized' }, { status: 401 })
+  }
+
+  let body: unknown
+  try {
+    body = await req.json()
+  } catch {
+    return NextResponse.json({ error: 'Invalid JSON body' }, { status: 400 })
+  }
+
+  const parsed = widgetDataRequestSchema.safeParse(body)
+  if (!parsed.success) {
+    return NextResponse.json(
+      { error: 'Invalid request payload', issues: parsed.error.issues },
+      { status: 400 },
+    )
+  }
+
+  const container = await createRequestContainer()
+  const analyticsRegistry = container.resolve<AnalyticsRegistry>('analyticsRegistry')
+
+  const entityFeatures = analyticsRegistry.getRequiredFeatures(parsed.data.entityType)
+  if (entityFeatures && entityFeatures.length > 0) {
+    const rbacService = container.resolve<{
+      userHasAllFeatures: (
+        userId: string,
+        features: string[],
+        scope: { tenantId: string; organizationId?: string | null },
+      ) => Promise<boolean>
+    }>('rbacService')
+    const hasAccess = await rbacService.userHasAllFeatures(auth.sub, entityFeatures, {
+      tenantId: auth.tenantId!,
+      organizationId: auth.orgId,
+    })
+    if (!hasAccess) {
+      return NextResponse.json({ error: 'Forbidden' }, { status: 403 })
+    }
+  }
+
+  const em = (container.resolve('em') as EntityManager).fork({
+    clear: true,
+    freshEventManager: true,
+    useContext: true,
+  })
+
+  const tenantId = auth.tenantId ?? null
+  if (!tenantId) {
+    return NextResponse.json({ error: 'Tenant context is required' }, { status: 400 })
+  }
+
+  const scope = await resolveOrganizationScopeForRequest({ container, auth, request: req })
+
+  const organizationIds = (() => {
+    if (scope?.selectedId) return [scope.selectedId]
+    if (Array.isArray(scope?.filterIds) && scope.filterIds.length > 0) return scope.filterIds
+    if (scope?.allowedIds === null) return undefined
+    if (auth.orgId) return [auth.orgId]
+    return undefined
+  })()
+
+  try {
+    const cache = container.resolve<CacheStrategy>('cache')
+    const service = createWidgetDataService(em, { tenantId, organizationIds }, analyticsRegistry, cache)
+    const result = await service.fetchWidgetData(parsed.data as WidgetDataRequest)
+    return NextResponse.json(result)
+  } catch (err) {
+    console.error('[widgets/data] Error:', err)
+    if (err instanceof WidgetDataValidationError) {
+      return NextResponse.json({ error: err.message }, { status: 400 })
+    }
+    return NextResponse.json(
+      { error: 'An error occurred while processing your request' },
+      { status: 500 },
+    )
+  }
+}
+
+const widgetDataPostDoc: OpenApiMethodDoc = {
+  summary: 'Fetch aggregated data for dashboard widgets',
+  description:
+    'Executes an aggregation query against the specified entity type and returns the result. Supports date range filtering, grouping, and period-over-period comparison.',
+  tags: [dashboardsTag],
+  requestBody: {
+    contentType: 'application/json',
+    schema: widgetDataRequestSchema,
+    description: 'Widget data request configuration specifying entity type, metric, filters, and grouping.',
+  },
+  responses: [
+    {
+      status: 200,
+      description: 'Aggregated data for the widget.',
+      schema: widgetDataResponseSchema,
+    },
+  ],
+  errors: [
+    { status: 400, description: 'Invalid request payload', schema: dashboardsErrorSchema },
+    { status: 401, description: 'Authentication required', schema: dashboardsErrorSchema },
+    { status: 403, description: 'Missing analytics.view feature', schema: dashboardsErrorSchema },
+    { status: 500, description: 'Internal server error', schema: dashboardsErrorSchema },
+  ],
+}
+
+export const openApi: OpenApiRouteDoc = {
+  tag: dashboardsTag,
+  summary: 'Widget data aggregation endpoint',
+  methods: {
+    POST: widgetDataPostDoc,
+  },
+}

package/src/modules/dashboards/cli.ts

@@ -4,6 +4,8 @@ import type { EntityManager } from '@mikro-orm/postgresql'
 import { DashboardRoleWidgets } from '@open-mercato/core/modules/dashboards/data/entities'
 import { Role } from '@open-mercato/core/modules/auth/data/entities'
 import { loadAllWidgets } from '@open-mercato/core/modules/dashboards/lib/widgets'
+import { appendWidgetsToRoles, resolveAnalyticsWidgetIds } from '@open-mercato/core/modules/dashboards/lib/role-widgets'
+import { seedAnalyticsData } from './seed/analytics'
 
 type Args = Record<string, string>
 
@@ -119,4 +121,205 @@ const seedDefaults: ModuleCli = {
   },
 }
 
-export default [seedDefaults]
+const enableAnalyticsWidgets: ModuleCli = {
+  command: 'enable-analytics-widgets',
+  async run(rest) {
+    const args = parseArgs(rest)
+    const tenantId = args.tenant || args.tenantId || null
+    const organizationId = args.organization || args.organizationId || args.org || null
+    const roleCsv = args.roles || 'admin,employee'
+    if (!tenantId) {
+      console.error('Usage: mercato dashboards enable-analytics-widgets --tenant <tenantId> [--org <orgId>] [--roles admin,employee]')
+      return
+    }
+
+    const roleNames = roleCsv
+      .split(',')
+      .map((name) => name.trim())
+      .filter(Boolean)
+
+    if (!roleNames.length) {
+      console.log('No roles provided, nothing to update.')
+      return
+    }
+
+    const { resolve } = await createRequestContainer()
+    const em = resolve('em') as EntityManager
+    const widgetIds = await resolveAnalyticsWidgetIds()
+
+    const updated = await appendWidgetsToRoles(em, {
+      tenantId,
+      organizationId,
+      roleNames,
+      widgetIds,
+    })
+
+    if (!updated) {
+      console.log('No dashboard role widgets updated.')
+    }
+  },
+}
+
+const seedAnalytics: ModuleCli = {
+  command: 'seed-analytics',
+  async run(rest) {
+    const args = parseArgs(rest)
+    const tenantId = args.tenant || args.tenantId || null
+    const organizationId = args.organization || args.organizationId || args.org || null
+    const months = args.months ? parseInt(args.months, 10) : 6
+    const ordersPerMonth = args.ordersPerMonth ? parseInt(args.ordersPerMonth, 10) : 50
+
+    if (!tenantId || !organizationId) {
+      console.error('Usage: mercato dashboards seed-analytics --tenant <tenantId> --organization <organizationId> [--months 6] [--ordersPerMonth 50]')
+      return
+    }
+
+    const { resolve } = await createRequestContainer()
+    const em = resolve('em') as EntityManager
+
+    console.log(`Seeding analytics data for ${months} months with ~${ordersPerMonth} orders/month...`)
+
+    try {
+      const result = await em.transactional(async (tem) =>
+        seedAnalyticsData(tem, { tenantId, organizationId }, { months, ordersPerMonth })
+      )
+
+      if (result.orders === 0) {
+        console.log('Analytics data already exists. Skipping seed.')
+      } else {
+        console.log(`Seeded analytics data:`)
+        console.log(`  - Orders: ${result.orders}`)
+        console.log(`  - Customers: ${result.customers}`)
+        console.log(`  - Products: ${result.products}`)
+        console.log(`  - Deals: ${result.deals}`)
+      }
+    } catch (error) {
+      console.error('Failed to seed analytics data:', error)
+    }
+  },
+}
+
+const debugAnalytics: ModuleCli = {
+  command: 'debug-analytics',
+  async run(rest) {
+    const args = parseArgs(rest)
+    const tenantId = args.tenant || args.tenantId || null
+    const organizationId = args.organization || args.organizationId || args.org || null
+
+    if (!tenantId) {
+      console.error('Usage: mercato dashboards debug-analytics --tenant <tenantId> [--organization <organizationId>]')
+      return
+    }
+
+    const { resolve } = await createRequestContainer()
+    const em = resolve('em') as EntityManager
+    const conn = em.getConnection()
+
+    console.log('Checking analytics data...\n')
+
+    const ordersResult = await conn.execute(
+      `SELECT COUNT(*) as total, MIN(placed_at) as earliest, MAX(placed_at) as latest
+       FROM sales_orders
+       WHERE tenant_id = ? AND order_number LIKE 'SO-ANALYTICS-%'`,
+      [tenantId]
+    )
+    console.log('Orders summary:', ordersResult[0])
+
+    const recentOrders = await conn.execute(
+      `SELECT order_number, placed_at, status, grand_total_gross_amount::numeric as total
+       FROM sales_orders
+       WHERE tenant_id = ? AND order_number LIKE 'SO-ANALYTICS-%'
+       ORDER BY placed_at DESC LIMIT 5`,
+      [tenantId]
+    )
+    console.log('\nRecent orders:', recentOrders)
+
+    const januaryOrders = await conn.execute(
+      `SELECT COUNT(*) as count, SUM(grand_total_gross_amount::numeric) as total
+       FROM sales_orders
+       WHERE tenant_id = ?
+         AND order_number LIKE 'SO-ANALYTICS-%'
+         AND placed_at >= '2026-01-01'
+         AND placed_at <= '2026-01-31 23:59:59'`,
+      [tenantId]
+    )
+    console.log('\nJanuary 2026 orders:', januaryOrders[0])
+
+    const allOrders = await conn.execute(
+      `SELECT COUNT(*) as count
+       FROM sales_orders
+       WHERE tenant_id = ?`,
+      [tenantId]
+    )
+    console.log('\nTotal orders in tenant:', allOrders[0])
+
+    const orgCheck = await conn.execute(
+      `SELECT organization_id, COUNT(*) as count
+       FROM sales_orders
+       WHERE tenant_id = ? AND order_number LIKE 'SO-ANALYTICS-%'
+       GROUP BY organization_id`,
+      [tenantId]
+    )
+    console.log('\nOrders by organization:', orgCheck)
+
+    if (organizationId) {
+      const orgOrders = await conn.execute(
+        `SELECT COUNT(*) as count, SUM(grand_total_gross_amount::numeric) as total
+         FROM sales_orders
+         WHERE tenant_id = ?
+           AND organization_id = ?
+           AND placed_at >= '2026-01-01'
+           AND placed_at <= '2026-01-31 23:59:59'`,
+        [tenantId, organizationId]
+      )
+      console.log(`\nJanuary orders for org ${organizationId}:`, orgOrders[0])
+    }
+
+    // Check for NULL placed_at
+    const nullPlacedAt = await conn.execute(
+      `SELECT COUNT(*) as count
+       FROM sales_orders
+       WHERE tenant_id = ? AND placed_at IS NULL`,
+      [tenantId]
+    )
+    console.log('\nOrders with NULL placed_at:', nullPlacedAt[0])
+
+    // Check non-analytics orders
+    const nonAnalytics = await conn.execute(
+      `SELECT order_number, placed_at, status, organization_id, grand_total_gross_amount::numeric as total
+       FROM sales_orders
+       WHERE tenant_id = ? AND order_number NOT LIKE 'SO-ANALYTICS-%'
+       ORDER BY placed_at DESC NULLS LAST LIMIT 10`,
+      [tenantId]
+    )
+    console.log('\nNon-analytics orders:', nonAnalytics)
+
+    // Simulate widget query
+    console.log('\n--- Simulating widget query for this_month ---')
+    const widgetQuery = await conn.execute(
+      `SELECT COALESCE(SUM(grand_total_gross_amount::numeric), 0) AS value
+       FROM sales_orders
+       WHERE tenant_id = ?
+         AND organization_id = ANY(?::uuid[])
+         AND deleted_at IS NULL
+         AND placed_at >= '2026-01-01'
+         AND placed_at <= '2026-01-31 23:59:59'`,
+      [tenantId, `{${organizationId}}`]
+    )
+    console.log('Widget query result (revenue sum):', widgetQuery[0])
+
+    const widgetCountQuery = await conn.execute(
+      `SELECT COUNT(*) AS value
+       FROM sales_orders
+       WHERE tenant_id = ?
+         AND organization_id = ANY(?::uuid[])
+         AND deleted_at IS NULL
+         AND placed_at >= '2026-01-01'
+         AND placed_at <= '2026-01-31 23:59:59'`,
+      [tenantId, `{${organizationId}}`]
+    )
+    console.log('Widget query result (order count):', widgetCountQuery[0])
+  },
+}
+
+export default [seedDefaults, enableAnalyticsWidgets, seedAnalytics, debugAnalytics]

package/src/modules/dashboards/di.ts

@@ -0,0 +1,9 @@
+import { asFunction } from 'awilix'
+import type { AppContainer } from '@open-mercato/shared/lib/di/container'
+import { createAnalyticsRegistry } from './services/analyticsRegistry'
+
+export function register(container: AppContainer): void {
+  container.register({
+    analyticsRegistry: asFunction(() => createAnalyticsRegistry()).singleton(),
+  })
+}

package/src/modules/dashboards/i18n/de.json

@@ -5,5 +5,119 @@
   "dashboards.widgets.flash.saved": "Dashboard-Widgets aktualisiert",
   "dashboards.widgets.mode.inherit": "Von Rollen übernehmen",
   "dashboards.widgets.mode.override": "Für diesen Benutzer überschreiben",
-  "dashboards.widgets.mode.hint": "Dieser Benutzer erbt derzeit Widgets von seinen Rollen. Wechseln Sie zu \"Überschreiben\", um anzupassen."
+  "dashboards.widgets.mode.hint": "Dieser Benutzer erbt derzeit Widgets von seinen Rollen. Wechseln Sie zu \"Überschreiben\", um anzupassen.",
+
+  "dashboards.analytics.dateRange.today": "Heute",
+  "dashboards.analytics.dateRange.yesterday": "Gestern",
+  "dashboards.analytics.dateRange.thisWeek": "Diese Woche",
+  "dashboards.analytics.dateRange.lastWeek": "Letzte Woche",
+  "dashboards.analytics.dateRange.thisMonth": "Dieser Monat",
+  "dashboards.analytics.dateRange.lastMonth": "Letzter Monat",
+  "dashboards.analytics.dateRange.thisQuarter": "Dieses Quartal",
+  "dashboards.analytics.dateRange.lastQuarter": "Letztes Quartal",
+  "dashboards.analytics.dateRange.thisYear": "Dieses Jahr",
+  "dashboards.analytics.dateRange.lastYear": "Letztes Jahr",
+  "dashboards.analytics.dateRange.last7Days": "Letzte 7 Tage",
+  "dashboards.analytics.dateRange.last30Days": "Letzte 30 Tage",
+  "dashboards.analytics.dateRange.last90Days": "Letzte 90 Tage",
+
+  "dashboards.analytics.granularity.day": "Tag",
+  "dashboards.analytics.granularity.week": "Woche",
+  "dashboards.analytics.granularity.month": "Monat",
+  "dashboards.analytics.granularity.quarter": "Quartal",
+  "dashboards.analytics.granularity.year": "Jahr",
+  "dashboards.analytics.granularity.short.day": "T",
+  "dashboards.analytics.granularity.short.week": "W",
+  "dashboards.analytics.granularity.short.month": "M",
+  "dashboards.analytics.granularity.short.quarter": "Q",
+  "dashboards.analytics.granularity.short.year": "J",
+
+  "dashboards.analytics.chartVariant.pie": "Kreis",
+  "dashboards.analytics.chartVariant.donut": "Ring",
+
+  "dashboards.analytics.comparison.vsYesterday": "vs gestern",
+  "dashboards.analytics.comparison.vsDayBefore": "vs vorgestern",
+  "dashboards.analytics.comparison.vsLastWeek": "vs letzte Woche",
+  "dashboards.analytics.comparison.vsWeekBefore": "vs Woche davor",
+  "dashboards.analytics.comparison.vsLastMonth": "vs letzter Monat",
+  "dashboards.analytics.comparison.vsMonthBefore": "vs Monat davor",
+  "dashboards.analytics.comparison.vsLastQuarter": "vs letztes Quartal",
+  "dashboards.analytics.comparison.vsQuarterBefore": "vs Quartal davor",
+  "dashboards.analytics.comparison.vsLastYear": "vs letztes Jahr",
+  "dashboards.analytics.comparison.vsYearBefore": "vs Jahr davor",
+  "dashboards.analytics.comparison.vsPrevious7Days": "vs vorherige 7 Tage",
+  "dashboards.analytics.comparison.vsPrevious30Days": "vs vorherige 30 Tage",
+  "dashboards.analytics.comparison.vsPrevious90Days": "vs vorherige 90 Tage",
+  "dashboards.analytics.comparison.vsPreviousPeriod": "vs vorheriger Zeitraum",
+
+  "dashboards.analytics.settings.dateRange": "Zeitraum",
+  "dashboards.analytics.settings.showComparison": "Vergleich anzeigen",
+  "dashboards.analytics.settings.granularity": "Granularität",
+  "dashboards.analytics.settings.showArea": "Flächenfüllung anzeigen",
+  "dashboards.analytics.settings.limit": "Anzahl der Elemente",
+  "dashboards.analytics.settings.chartVariant": "Diagrammstil",
+  "dashboards.analytics.settings.chartLayout": "Diagramm-Layout",
+  "dashboards.analytics.settings.horizontal": "Horizontal",
+  "dashboards.analytics.settings.vertical": "Vertikal",
+
+  "dashboards.analytics.widgets.revenueKpi.title": "Umsatz",
+  "dashboards.analytics.widgets.revenueKpi.description": "Gesamtumsatz mit Periodenvergleich",
+  "dashboards.analytics.widgets.revenueKpi.error": "Umsatzdaten konnten nicht geladen werden",
+
+  "dashboards.analytics.widgets.ordersKpi.title": "Bestellungen",
+  "dashboards.analytics.widgets.ordersKpi.description": "Gesamtbestellungen mit Periodenvergleich",
+  "dashboards.analytics.widgets.ordersKpi.error": "Bestelldaten konnten nicht geladen werden",
+
+  "dashboards.analytics.widgets.aovKpi.title": "Durchschnittlicher Bestellwert",
+  "dashboards.analytics.widgets.aovKpi.description": "Durchschnittlicher Bestellwert mit Periodenvergleich",
+  "dashboards.analytics.widgets.aovKpi.error": "AOV-Daten konnten nicht geladen werden",
+
+  "dashboards.analytics.widgets.newCustomersKpi.title": "Kundenwachstum",
+  "dashboards.analytics.widgets.newCustomersKpi.description": "Anzahl neuer Kunden mit Periodenvergleich",
+  "dashboards.analytics.widgets.newCustomersKpi.error": "Daten zu neuen Kunden konnten nicht geladen werden",
+
+  "dashboards.analytics.widgets.revenueTrend.title": "Umsatztrend",
+  "dashboards.analytics.widgets.revenueTrend.description": "Umsatz im Zeitverlauf mit anpassbarer Granularität",
+  "dashboards.analytics.widgets.revenueTrend.error": "Umsatztrenddaten konnten nicht geladen werden",
+  "dashboards.analytics.widgets.revenueTrend.empty": "Keine Umsatzdaten für diesen Zeitraum",
+
+  "dashboards.analytics.widgets.topProducts.title": "Top-Produkte nach Umsatz",
+  "dashboards.analytics.widgets.topProducts.description": "Meistverkaufte Produkte nach Umsatz",
+  "dashboards.analytics.widgets.topProducts.error": "Produktdaten konnten nicht geladen werden",
+  "dashboards.analytics.widgets.topProducts.empty": "Keine Produktverkaufsdaten für diesen Zeitraum",
+
+  "dashboards.analytics.widgets.ordersByStatus.title": "Bestellungen nach Status",
+  "dashboards.analytics.widgets.ordersByStatus.description": "Verteilung der Bestellungen nach Status",
+  "dashboards.analytics.widgets.ordersByStatus.error": "Daten zu Bestellungen nach Status konnten nicht geladen werden",
+  "dashboards.analytics.widgets.ordersByStatus.empty": "Keine Bestellungen für diesen Zeitraum",
+
+  "dashboards.analytics.widgets.topCustomers.title": "Top-Kunden nach Umsatz",
+  "dashboards.analytics.widgets.topCustomers.description": "Top-Kunden nach Gesamtumsatz",
+  "dashboards.analytics.widgets.topCustomers.error": "Kundendaten konnten nicht geladen werden",
+  "dashboards.analytics.widgets.topCustomers.empty": "Keine Kundendaten für diesen Zeitraum",
+  "dashboards.analytics.widgets.topCustomers.column.customer": "Kunde",
+  "dashboards.analytics.widgets.topCustomers.column.revenue": "Umsatz",
+
+  "dashboards.analytics.widgets.pipelineSummary.title": "Pipeline-Übersicht",
+  "dashboards.analytics.widgets.pipelineSummary.description": "Deal-Wert nach Pipeline-Phase",
+  "dashboards.analytics.widgets.pipelineSummary.error": "Pipeline-Daten konnten nicht geladen werden",
+  "dashboards.analytics.widgets.pipelineSummary.empty": "Keine Deal-Daten für diesen Zeitraum",
+
+  "dashboards.analytics.widgets.salesByRegion.title": "Verkäufe nach Region",
+  "dashboards.analytics.widgets.salesByRegion.description": "Umsatzverteilung nach Versandregion",
+  "dashboards.analytics.widgets.salesByRegion.error": "Daten zu Verkäufen nach Region konnten nicht geladen werden",
+  "dashboards.analytics.widgets.salesByRegion.empty": "Keine regionalen Verkaufsdaten für diesen Zeitraum",
+
+  "dashboards.analytics.labels.unknown": "Unbekannt",
+  "dashboards.analytics.labels.unknownProduct": "Unbekanntes Produkt",
+  "dashboards.analytics.labels.unnamedProduct": "Unbenanntes Produkt",
+  "dashboards.analytics.labels.value": "Wert",
+
+  "dashboards.analytics.orderStatus.draft": "Entwurf",
+  "dashboards.analytics.orderStatus.pending": "Ausstehend",
+  "dashboards.analytics.orderStatus.confirmed": "Bestätigt",
+  "dashboards.analytics.orderStatus.processing": "In Bearbeitung",
+  "dashboards.analytics.orderStatus.shipped": "Versendet",
+  "dashboards.analytics.orderStatus.delivered": "Geliefert",
+  "dashboards.analytics.orderStatus.cancelled": "Storniert"
 }