@open-mercato/core 0.4.2-canary-ccd610ad18 → 0.4.2-canary-92bc12ea91

package/src/modules/sales/api/dashboard/widgets/new-orders/route.ts

@@ -0,0 +1,192 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import type { FilterQuery } from '@mikro-orm/core'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { findAndCountWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { SalesOrder } from '../../../../data/entities'
+import { resolveWidgetScope, type WidgetScopeContext } from '../utils'
+import { extractCustomerName } from '../../../../lib/customerSnapshot'
+import { parseDateInput, resolveDateRange, type DatePeriodOption } from '../../../../lib/dateRange'
+
+const querySchema = z.object({
+  limit: z.coerce.number().min(1).max(20).default(5),
+  datePeriod: z.enum(['last24h', 'last7d', 'last30d', 'custom']).default('last24h'),
+  customFrom: z.string().optional(),
+  customTo: z.string().optional(),
+  tenantId: z.string().uuid().optional(),
+  organizationId: z.string().uuid().optional(),
+})
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['dashboards.view', 'sales.widgets.new-orders'] },
+}
+
+type WidgetContext = WidgetScopeContext & {
+  limit: number
+  datePeriod: DatePeriodOption
+  customFrom?: string
+  customTo?: string
+}
+
+async function resolveContext(
+  req: Request,
+  translate: (key: string, fallback?: string) => string,
+): Promise<WidgetContext> {
+  const url = new URL(req.url)
+  const rawQuery: Record<string, string> = {}
+  for (const [key, value] of url.searchParams.entries()) {
+    rawQuery[key] = value
+  }
+  const parsed = querySchema.safeParse(rawQuery)
+  if (!parsed.success) {
+    throw new CrudHttpError(400, { error: translate('sales.errors.invalid_query', 'Invalid query parameters') })
+  }
+
+  const { container, em, tenantId, organizationIds } = await resolveWidgetScope(req, translate, {
+    tenantId: parsed.data.tenantId ?? null,
+    organizationId: parsed.data.organizationId ?? null,
+  })
+
+  return {
+    container,
+    em,
+    tenantId,
+    organizationIds,
+    limit: parsed.data.limit,
+    datePeriod: parsed.data.datePeriod,
+    customFrom: parsed.data.customFrom,
+    customTo: parsed.data.customTo,
+  }
+}
+
+function resolveDateRangeOrThrow(
+  period: DatePeriodOption,
+  customFrom: string | undefined,
+  customTo: string | undefined,
+  translate: (key: string, fallback?: string) => string,
+): { from: Date; to: Date } {
+  const parsedFrom = parseDateInput(customFrom)
+  const parsedTo = parseDateInput(customTo)
+  if (customFrom && !parsedFrom) {
+    throw new CrudHttpError(400, { error: translate('sales.errors.invalid_date', 'Invalid date range') })
+  }
+  if (customTo && !parsedTo) {
+    throw new CrudHttpError(400, { error: translate('sales.errors.invalid_date', 'Invalid date range') })
+  }
+  return resolveDateRange(period, parsedFrom, parsedTo)
+}
+
+export async function GET(req: Request) {
+  const { translate } = await resolveTranslations()
+  try {
+    const { em, tenantId, organizationIds, limit, datePeriod, customFrom, customTo } = await resolveContext(
+      req,
+      translate,
+    )
+
+    const { from, to } = resolveDateRangeOrThrow(datePeriod, customFrom, customTo, translate)
+
+    const where: FilterQuery<SalesOrder> = {
+      tenantId,
+      deletedAt: null,
+      createdAt: { $gte: from, $lte: to },
+    }
+
+    if (Array.isArray(organizationIds)) {
+      where.organizationId =
+        organizationIds.length === 1 ? organizationIds[0] : { $in: Array.from(new Set(organizationIds)) }
+    }
+
+    const [items, total] = await findAndCountWithDecryption(
+      em,
+      SalesOrder,
+      where,
+      {
+        limit,
+        orderBy: { createdAt: 'desc' as const },
+      },
+      { tenantId },
+    )
+
+    const responseItems = items.map((order) => ({
+      id: order.id,
+      orderNumber: order.orderNumber,
+      status: order.status ?? null,
+      fulfillmentStatus: order.fulfillmentStatus ?? null,
+      paymentStatus: order.paymentStatus ?? null,
+      customerName: extractCustomerName(order.customerSnapshot) ?? null,
+      customerEntityId: order.customerEntityId ?? null,
+      netAmount: order.grandTotalNetAmount,
+      grossAmount: order.grandTotalGrossAmount,
+      currency: order.currencyCode ?? null,
+      createdAt: order.createdAt.toISOString(),
+    }))
+
+    return NextResponse.json({
+      items: responseItems,
+      total,
+      dateRange: {
+        from: from.toISOString(),
+        to: to.toISOString(),
+      },
+    })
+  } catch (err) {
+    if (err instanceof CrudHttpError) {
+      return NextResponse.json(err.body, { status: err.status })
+    }
+    console.error('sales.widgets.newOrders failed', err)
+    return NextResponse.json(
+      { error: translate('sales.widgets.newOrders.error', 'Failed to load recent orders') },
+      { status: 500 },
+    )
+  }
+}
+
+const orderItemSchema = z.object({
+  id: z.string().uuid(),
+  orderNumber: z.string(),
+  status: z.string().nullable(),
+  fulfillmentStatus: z.string().nullable(),
+  paymentStatus: z.string().nullable(),
+  customerName: z.string().nullable(),
+  customerEntityId: z.string().uuid().nullable(),
+  netAmount: z.string(),
+  grossAmount: z.string(),
+  currency: z.string().nullable(),
+  createdAt: z.string(),
+})
+
+const responseSchema = z.object({
+  items: z.array(orderItemSchema),
+  total: z.number(),
+  dateRange: z.object({
+    from: z.string(),
+    to: z.string(),
+  }),
+})
+
+const widgetErrorSchema = z.object({
+  error: z.string(),
+})
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'Sales',
+  summary: 'New orders widget',
+  methods: {
+    GET: {
+      summary: 'Fetch recently created sales orders',
+      description: 'Returns the most recent sales orders within the scoped tenant/organization.',
+      query: querySchema,
+      responses: [
+        { status: 200, description: 'Widget payload', schema: responseSchema },
+      ],
+      errors: [
+        { status: 400, description: 'Invalid query parameters', schema: widgetErrorSchema },
+        { status: 401, description: 'Unauthorized', schema: widgetErrorSchema },
+        { status: 500, description: 'Widget failed to load', schema: widgetErrorSchema },
+      ],
+    },
+  },
+}

package/src/modules/sales/api/dashboard/widgets/new-quotes/__tests__/route.test.ts

@@ -0,0 +1,61 @@
+import { GET } from '../route'
+
+jest.mock('../../utils', () => ({
+  resolveWidgetScope: jest.fn(async () => ({
+    container: {},
+    em: {},
+    tenantId: '33333333-3333-3333-3333-333333333333',
+    organizationIds: ['22222222-2222-2222-2222-222222222222'],
+  })),
+}))
+
+jest.mock('@open-mercato/shared/lib/i18n/server', () => ({
+  resolveTranslations: async () => ({
+    translate: (k: string, fb?: string) => fb ?? k,
+  }),
+}))
+
+jest.mock('@open-mercato/shared/lib/encryption/find', () => ({
+  findAndCountWithDecryption: jest.fn(async () => [
+    [
+      {
+        id: '11111111-1111-1111-1111-111111111111',
+        quoteNumber: 'QT-2001',
+        status: 'draft',
+        customerSnapshot: { displayName: 'Acme Corp' },
+        customerEntityId: '44444444-4444-4444-4444-444444444444',
+        validFrom: new Date('2026-01-20T00:00:00.000Z'),
+        validUntil: new Date('2026-02-01T00:00:00.000Z'),
+        grandTotalNetAmount: '80.00',
+        grandTotalGrossAmount: '96.00',
+        currencyCode: 'USD',
+        createdAt: new Date('2026-01-27T10:00:00.000Z'),
+        convertedOrderId: null,
+      },
+    ],
+    1,
+  ]),
+}))
+
+describe('sales new-quotes widget route', () => {
+  it('returns 200 with items on happy path', async () => {
+    const req = new Request('http://localhost/api?limit=5')
+    const res = await GET(req)
+    expect(res.status).toBe(200)
+    const body = await res.json()
+    expect(Array.isArray(body.items)).toBe(true)
+    expect(body.items[0]).toMatchObject({
+      id: '11111111-1111-1111-1111-111111111111',
+      quoteNumber: 'QT-2001',
+      customerName: 'Acme Corp',
+    })
+  })
+
+  it('returns 400 on invalid limit', async () => {
+    const req = new Request('http://localhost/api?limit=0')
+    const res = await GET(req)
+    expect(res.status).toBe(400)
+    const body = await res.json()
+    expect(body).toHaveProperty('error')
+  })
+})

package/src/modules/sales/api/dashboard/widgets/new-quotes/route.ts

@@ -0,0 +1,194 @@
+import { NextResponse } from 'next/server'
+import { z } from 'zod'
+import type { FilterQuery } from '@mikro-orm/core'
+import { resolveTranslations } from '@open-mercato/shared/lib/i18n/server'
+import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import type { OpenApiRouteDoc } from '@open-mercato/shared/lib/openapi'
+import { findAndCountWithDecryption } from '@open-mercato/shared/lib/encryption/find'
+import { SalesQuote } from '../../../../data/entities'
+import { resolveWidgetScope, type WidgetScopeContext } from '../utils'
+import { extractCustomerName } from '../../../../lib/customerSnapshot'
+import { parseDateInput, resolveDateRange, type DatePeriodOption } from '../../../../lib/dateRange'
+
+const querySchema = z.object({
+  limit: z.coerce.number().min(1).max(20).default(5),
+  datePeriod: z.enum(['last24h', 'last7d', 'last30d', 'custom']).default('last24h'),
+  customFrom: z.string().optional(),
+  customTo: z.string().optional(),
+  tenantId: z.string().uuid().optional(),
+  organizationId: z.string().uuid().optional(),
+})
+
+export const metadata = {
+  GET: { requireAuth: true, requireFeatures: ['dashboards.view', 'sales.widgets.new-quotes'] },
+}
+
+type WidgetContext = WidgetScopeContext & {
+  limit: number
+  datePeriod: DatePeriodOption
+  customFrom?: string
+  customTo?: string
+}
+
+async function resolveContext(
+  req: Request,
+  translate: (key: string, fallback?: string) => string,
+): Promise<WidgetContext> {
+  const url = new URL(req.url)
+  const rawQuery: Record<string, string> = {}
+  for (const [key, value] of url.searchParams.entries()) {
+    rawQuery[key] = value
+  }
+  const parsed = querySchema.safeParse(rawQuery)
+  if (!parsed.success) {
+    throw new CrudHttpError(400, { error: translate('sales.errors.invalid_query', 'Invalid query parameters') })
+  }
+
+  const { container, em, tenantId, organizationIds } = await resolveWidgetScope(req, translate, {
+    tenantId: parsed.data.tenantId ?? null,
+    organizationId: parsed.data.organizationId ?? null,
+  })
+
+  return {
+    container,
+    em,
+    tenantId,
+    organizationIds,
+    limit: parsed.data.limit,
+    datePeriod: parsed.data.datePeriod,
+    customFrom: parsed.data.customFrom,
+    customTo: parsed.data.customTo,
+  }
+}
+
+function resolveDateRangeOrThrow(
+  period: DatePeriodOption,
+  customFrom: string | undefined,
+  customTo: string | undefined,
+  translate: (key: string, fallback?: string) => string,
+): { from: Date; to: Date } {
+  const parsedFrom = parseDateInput(customFrom)
+  const parsedTo = parseDateInput(customTo)
+  if (customFrom && !parsedFrom) {
+    throw new CrudHttpError(400, { error: translate('sales.errors.invalid_date', 'Invalid date range') })
+  }
+  if (customTo && !parsedTo) {
+    throw new CrudHttpError(400, { error: translate('sales.errors.invalid_date', 'Invalid date range') })
+  }
+  return resolveDateRange(period, parsedFrom, parsedTo)
+}
+
+export async function GET(req: Request) {
+  const { translate } = await resolveTranslations()
+  try {
+    const { em, tenantId, organizationIds, limit, datePeriod, customFrom, customTo } = await resolveContext(
+      req,
+      translate,
+    )
+
+    const { from, to } = resolveDateRangeOrThrow(datePeriod, customFrom, customTo, translate)
+
+    const where: FilterQuery<SalesQuote> = {
+      tenantId,
+      deletedAt: null,
+      createdAt: { $gte: from, $lte: to },
+    }
+
+    if (Array.isArray(organizationIds)) {
+      where.organizationId =
+        organizationIds.length === 1 ? organizationIds[0] : { $in: Array.from(new Set(organizationIds)) }
+    }
+
+    const [items, total] = await findAndCountWithDecryption(
+      em,
+      SalesQuote,
+      where,
+      {
+        limit,
+        orderBy: { createdAt: 'desc' as const },
+      },
+      { tenantId },
+    )
+
+    const responseItems = items.map((quote) => ({
+      id: quote.id,
+      quoteNumber: quote.quoteNumber,
+      status: quote.status ?? null,
+      customerName: extractCustomerName(quote.customerSnapshot) ?? null,
+      customerEntityId: quote.customerEntityId ?? null,
+      validFrom: quote.validFrom ? quote.validFrom.toISOString() : null,
+      validUntil: quote.validUntil ? quote.validUntil.toISOString() : null,
+      netAmount: quote.grandTotalNetAmount,
+      grossAmount: quote.grandTotalGrossAmount,
+      currency: quote.currencyCode ?? null,
+      createdAt: quote.createdAt.toISOString(),
+      convertedOrderId: quote.convertedOrderId ?? null,
+    }))
+
+    return NextResponse.json({
+      items: responseItems,
+      total,
+      dateRange: {
+        from: from.toISOString(),
+        to: to.toISOString(),
+      },
+    })
+  } catch (err) {
+    if (err instanceof CrudHttpError) {
+      return NextResponse.json(err.body, { status: err.status })
+    }
+    console.error('sales.widgets.newQuotes failed', err)
+    return NextResponse.json(
+      { error: translate('sales.widgets.newQuotes.error', 'Failed to load recent quotes') },
+      { status: 500 },
+    )
+  }
+}
+
+const quoteItemSchema = z.object({
+  id: z.string().uuid(),
+  quoteNumber: z.string(),
+  status: z.string().nullable(),
+  customerName: z.string().nullable(),
+  customerEntityId: z.string().uuid().nullable(),
+  validFrom: z.string().nullable(),
+  validUntil: z.string().nullable(),
+  netAmount: z.string(),
+  grossAmount: z.string(),
+  currency: z.string().nullable(),
+  createdAt: z.string(),
+  convertedOrderId: z.string().uuid().nullable(),
+})
+
+const responseSchema = z.object({
+  items: z.array(quoteItemSchema),
+  total: z.number(),
+  dateRange: z.object({
+    from: z.string(),
+    to: z.string(),
+  }),
+})
+
+const widgetErrorSchema = z.object({
+  error: z.string(),
+})
+
+export const openApi: OpenApiRouteDoc = {
+  tag: 'Sales',
+  summary: 'New quotes widget',
+  methods: {
+    GET: {
+      summary: 'Fetch recently created sales quotes',
+      description: 'Returns the most recent sales quotes within the scoped tenant/organization.',
+      query: querySchema,
+      responses: [
+        { status: 200, description: 'Widget payload', schema: responseSchema },
+      ],
+      errors: [
+        { status: 400, description: 'Invalid query parameters', schema: widgetErrorSchema },
+        { status: 401, description: 'Unauthorized', schema: widgetErrorSchema },
+        { status: 500, description: 'Widget failed to load', schema: widgetErrorSchema },
+      ],
+    },
+  },
+}

package/src/modules/sales/api/dashboard/widgets/utils.ts

@@ -0,0 +1,53 @@
+import type { EntityManager } from '@mikro-orm/postgresql'
+import { createRequestContainer, type AppContainer } from '@open-mercato/shared/lib/di/container'
+import { getAuthFromRequest } from '@open-mercato/shared/lib/auth/server'
+import { CrudHttpError } from '@open-mercato/shared/lib/crud/errors'
+import { resolveOrganizationScopeForRequest } from '@open-mercato/core/modules/directory/utils/organizationScope'
+
+export type WidgetScopeContext = {
+  container: AppContainer
+  em: EntityManager
+  tenantId: string
+  organizationIds: string[] | null
+}
+
+export async function resolveWidgetScope(
+  req: Request,
+  translate: (key: string, fallback?: string) => string,
+  overrides?: { tenantId?: string | null; organizationId?: string | null },
+): Promise<WidgetScopeContext> {
+  const auth = await getAuthFromRequest(req)
+  if (!auth) {
+    throw new CrudHttpError(401, { error: translate('sales.errors.unauthorized', 'Unauthorized') })
+  }
+
+  const container = await createRequestContainer()
+  const scope = await resolveOrganizationScopeForRequest({ container, auth, request: req })
+
+  const tenantId = overrides?.tenantId ?? auth.tenantId ?? null
+  if (!tenantId) {
+    throw new CrudHttpError(400, { error: translate('sales.errors.tenant_required', 'Tenant context is required') })
+  }
+
+  const organizationIds = (() => {
+    if (overrides?.organizationId) return [overrides.organizationId]
+    if (scope?.selectedId) return [scope.selectedId]
+    if (Array.isArray(scope?.filterIds) && scope.filterIds.length > 0) return scope.filterIds
+    if (scope?.allowedIds === null) return null
+    if (auth.orgId) return [auth.orgId]
+    return []
+  })()
+
+  if (organizationIds !== null && organizationIds.length === 0) {
+    throw new CrudHttpError(400, { error: translate('sales.errors.organization_required', 'Organization context is required') })
+  }
+
+  const em = container.resolve('em') as EntityManager
+
+  return {
+    container,
+    em,
+    tenantId,
+    organizationIds,
+  }
+}

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

@@ -1534,5 +1534,36 @@
   "sales.search.badge.deliveryWindow": "Lieferfenster",
   "sales.search.badge.paymentMethod": "Zahlungsart",
   "sales.search.badge.taxRate": "Steuersatz",
-  "sales.search.badge.documentTag": "Dokumenten-Tag"
+  "sales.search.badge.documentTag": "Dokumenten-Tag",
+  "sales.errors.invalid_query": "Ungültige Abfrageparameter",
+  "sales.errors.tenant_required": "Mandantenkontext ist erforderlich",
+  "sales.errors.organization_required": "Organisationskontext ist erforderlich",
+  "sales.errors.unauthorized": "Nicht autorisiert",
+  "sales.errors.invalid_date": "Ungültiger Datumsbereich",
+  "sales.widgets.newOrders.error": "Bestellungen konnten nicht geladen werden",
+  "sales.widgets.newOrders.empty": "Keine Bestellungen in diesem Zeitraum gefunden",
+  "sales.widgets.newOrders.noCustomer": "Kein Kunde",
+  "sales.widgets.newOrders.unknownDate": "Unbekanntes Datum",
+  "sales.widgets.newOrders.settings.pageSize": "Anzahl der Bestellungen",
+  "sales.widgets.newOrders.settings.datePeriod": "Zeitraum",
+  "sales.widgets.newOrders.settings.last24h": "Letzte 24 Stunden",
+  "sales.widgets.newOrders.settings.last7d": "Letzte 7 Tage",
+  "sales.widgets.newOrders.settings.last30d": "Letzte 30 Tage",
+  "sales.widgets.newOrders.settings.custom": "Benutzerdefinierter Zeitraum",
+  "sales.widgets.newOrders.settings.customFrom": "Von",
+  "sales.widgets.newOrders.settings.customTo": "Bis",
+  "sales.widgets.newQuotes.error": "Angebote konnten nicht geladen werden",
+  "sales.widgets.newQuotes.empty": "Keine Angebote in diesem Zeitraum gefunden",
+  "sales.widgets.newQuotes.noCustomer": "Kein Kunde",
+  "sales.widgets.newQuotes.validUntil": "Gültig bis {{date}}",
+  "sales.widgets.newQuotes.converted": "Konvertiert",
+  "sales.widgets.newQuotes.unknownDate": "Unbekanntes Datum",
+  "sales.widgets.newQuotes.settings.pageSize": "Anzahl der Angebote",
+  "sales.widgets.newQuotes.settings.datePeriod": "Zeitraum",
+  "sales.widgets.newQuotes.settings.last24h": "Letzte 24 Stunden",
+  "sales.widgets.newQuotes.settings.last7d": "Letzte 7 Tage",
+  "sales.widgets.newQuotes.settings.last30d": "Letzte 30 Tage",
+  "sales.widgets.newQuotes.settings.custom": "Benutzerdefinierter Zeitraum",
+  "sales.widgets.newQuotes.settings.customFrom": "Von",
+  "sales.widgets.newQuotes.settings.customTo": "Bis"
 }

package/src/modules/sales/i18n/en.json

@@ -1516,5 +1516,36 @@
   "sales.search.badge.deliveryWindow": "Delivery window",
   "sales.search.badge.paymentMethod": "Payment method",
   "sales.search.badge.taxRate": "Tax rate",
-  "sales.search.badge.documentTag": "Document tag"
+  "sales.search.badge.documentTag": "Document tag",
+  "sales.errors.invalid_query": "Invalid query parameters",
+  "sales.errors.tenant_required": "Tenant context is required",
+  "sales.errors.organization_required": "Organization context is required",
+  "sales.errors.unauthorized": "Unauthorized",
+  "sales.errors.invalid_date": "Invalid date range",
+  "sales.widgets.newOrders.error": "Failed to load orders",
+  "sales.widgets.newOrders.empty": "No orders found in this period",
+  "sales.widgets.newOrders.noCustomer": "No customer",
+  "sales.widgets.newOrders.unknownDate": "Unknown date",
+  "sales.widgets.newOrders.settings.pageSize": "Number of Orders",
+  "sales.widgets.newOrders.settings.datePeriod": "Date Period",
+  "sales.widgets.newOrders.settings.last24h": "Last 24 hours",
+  "sales.widgets.newOrders.settings.last7d": "Last 7 days",
+  "sales.widgets.newOrders.settings.last30d": "Last 30 days",
+  "sales.widgets.newOrders.settings.custom": "Custom range",
+  "sales.widgets.newOrders.settings.customFrom": "From",
+  "sales.widgets.newOrders.settings.customTo": "To",
+  "sales.widgets.newQuotes.error": "Failed to load quotes",
+  "sales.widgets.newQuotes.empty": "No quotes found in this period",
+  "sales.widgets.newQuotes.noCustomer": "No customer",
+  "sales.widgets.newQuotes.validUntil": "Valid until {{date}}",
+  "sales.widgets.newQuotes.converted": "Converted",
+  "sales.widgets.newQuotes.unknownDate": "Unknown date",
+  "sales.widgets.newQuotes.settings.pageSize": "Number of Quotes",
+  "sales.widgets.newQuotes.settings.datePeriod": "Date Period",
+  "sales.widgets.newQuotes.settings.last24h": "Last 24 hours",
+  "sales.widgets.newQuotes.settings.last7d": "Last 7 days",
+  "sales.widgets.newQuotes.settings.last30d": "Last 30 days",
+  "sales.widgets.newQuotes.settings.custom": "Custom range",
+  "sales.widgets.newQuotes.settings.customFrom": "From",
+  "sales.widgets.newQuotes.settings.customTo": "To"
 }

package/src/modules/sales/i18n/es.json

@@ -1517,5 +1517,36 @@
   "sales.search.badge.deliveryWindow": "Ventana de entrega",
   "sales.search.badge.paymentMethod": "Método de pago",
   "sales.search.badge.taxRate": "Tasa de impuesto",
-  "sales.search.badge.documentTag": "Etiqueta de documento"
+  "sales.search.badge.documentTag": "Etiqueta de documento",
+  "sales.errors.invalid_query": "Parámetros de consulta inválidos",
+  "sales.errors.tenant_required": "Se requiere el contexto del inquilino",
+  "sales.errors.organization_required": "Se requiere el contexto de la organización",
+  "sales.errors.unauthorized": "No autorizado",
+  "sales.errors.invalid_date": "Rango de fechas inválido",
+  "sales.widgets.newOrders.error": "No se pudieron cargar los pedidos",
+  "sales.widgets.newOrders.empty": "No se encontraron pedidos en este período",
+  "sales.widgets.newOrders.noCustomer": "Sin cliente",
+  "sales.widgets.newOrders.unknownDate": "Fecha desconocida",
+  "sales.widgets.newOrders.settings.pageSize": "Número de pedidos",
+  "sales.widgets.newOrders.settings.datePeriod": "Período",
+  "sales.widgets.newOrders.settings.last24h": "Últimas 24 horas",
+  "sales.widgets.newOrders.settings.last7d": "Últimos 7 días",
+  "sales.widgets.newOrders.settings.last30d": "Últimos 30 días",
+  "sales.widgets.newOrders.settings.custom": "Rango personalizado",
+  "sales.widgets.newOrders.settings.customFrom": "Desde",
+  "sales.widgets.newOrders.settings.customTo": "Hasta",
+  "sales.widgets.newQuotes.error": "No se pudieron cargar las cotizaciones",
+  "sales.widgets.newQuotes.empty": "No se encontraron cotizaciones en este período",
+  "sales.widgets.newQuotes.noCustomer": "Sin cliente",
+  "sales.widgets.newQuotes.validUntil": "Válido hasta {{date}}",
+  "sales.widgets.newQuotes.converted": "Convertido",
+  "sales.widgets.newQuotes.unknownDate": "Fecha desconocida",
+  "sales.widgets.newQuotes.settings.pageSize": "Número de cotizaciones",
+  "sales.widgets.newQuotes.settings.datePeriod": "Período",
+  "sales.widgets.newQuotes.settings.last24h": "Últimas 24 horas",
+  "sales.widgets.newQuotes.settings.last7d": "Últimos 7 días",
+  "sales.widgets.newQuotes.settings.last30d": "Últimos 30 días",
+  "sales.widgets.newQuotes.settings.custom": "Rango personalizado",
+  "sales.widgets.newQuotes.settings.customFrom": "Desde",
+  "sales.widgets.newQuotes.settings.customTo": "Hasta"
 }

package/src/modules/sales/i18n/pl.json

@@ -1532,5 +1532,36 @@
   "sales.search.badge.deliveryWindow": "Okno dostawy",
   "sales.search.badge.paymentMethod": "Metoda płatności",
   "sales.search.badge.taxRate": "Stawka podatku",
-  "sales.search.badge.documentTag": "Tag dokumentu"
+  "sales.search.badge.documentTag": "Tag dokumentu",
+  "sales.errors.invalid_query": "Nieprawidłowe parametry zapytania",
+  "sales.errors.tenant_required": "Wymagany kontekst najemcy",
+  "sales.errors.organization_required": "Wymagany kontekst organizacji",
+  "sales.errors.unauthorized": "Brak autoryzacji",
+  "sales.errors.invalid_date": "Nieprawidłowy zakres dat",
+  "sales.widgets.newOrders.error": "Nie udało się wczytać zamówień",
+  "sales.widgets.newOrders.empty": "Brak zamówień w tym okresie",
+  "sales.widgets.newOrders.noCustomer": "Brak klienta",
+  "sales.widgets.newOrders.unknownDate": "Nieznana data",
+  "sales.widgets.newOrders.settings.pageSize": "Liczba zamówień",
+  "sales.widgets.newOrders.settings.datePeriod": "Okres",
+  "sales.widgets.newOrders.settings.last24h": "Ostatnie 24 godziny",
+  "sales.widgets.newOrders.settings.last7d": "Ostatnie 7 dni",
+  "sales.widgets.newOrders.settings.last30d": "Ostatnie 30 dni",
+  "sales.widgets.newOrders.settings.custom": "Zakres niestandardowy",
+  "sales.widgets.newOrders.settings.customFrom": "Od",
+  "sales.widgets.newOrders.settings.customTo": "Do",
+  "sales.widgets.newQuotes.error": "Nie udało się wczytać ofert",
+  "sales.widgets.newQuotes.empty": "Brak ofert w tym okresie",
+  "sales.widgets.newQuotes.noCustomer": "Brak klienta",
+  "sales.widgets.newQuotes.validUntil": "Ważne do {{date}}",
+  "sales.widgets.newQuotes.converted": "Przekształcona",
+  "sales.widgets.newQuotes.unknownDate": "Nieznana data",
+  "sales.widgets.newQuotes.settings.pageSize": "Liczba ofert",
+  "sales.widgets.newQuotes.settings.datePeriod": "Okres",
+  "sales.widgets.newQuotes.settings.last24h": "Ostatnie 24 godziny",
+  "sales.widgets.newQuotes.settings.last7d": "Ostatnie 7 dni",
+  "sales.widgets.newQuotes.settings.last30d": "Ostatnie 30 dni",
+  "sales.widgets.newQuotes.settings.custom": "Zakres niestandardowy",
+  "sales.widgets.newQuotes.settings.customFrom": "Od",
+  "sales.widgets.newQuotes.settings.customTo": "Do"
 }