@dainamite/cpq 0.2.2

package/src/modules/cpq/backend/cpq/pricing/[id]/xlsxImport.ts

@@ -0,0 +1,338 @@
+// Browser-side Excel import for pricing tables.
+//
+// Parses an .xlsx produced by `exportPricingTableToXlsx` (or any sheet with
+// the matching column shape) and computes a diff against the current
+// in-memory entries. Reconciliation key is the `id` UUID column from the
+// export — rows without an id are treated as INSERTS, entries whose id is
+// absent from the file are treated as DELETES.
+
+import * as XLSX from 'xlsx'
+
+type Dimension = { key: string; label: string }
+type PriceColumn = { key: string; label: string }
+
+export type ImportEntry = {
+  id: string
+  dimensionValues: Record<string, string>
+  tierNumber: number | null
+  rangeFrom: string | null
+  rangeTo: string | null
+  currencyCode: string
+  prices: Record<string, number>
+}
+
+type TableShape = {
+  dimensions: Dimension[]
+  priceColumns: PriceColumn[]
+  currencyCodeList: string[]
+}
+
+type ParsedRow = {
+  rowNumber: number // 1-indexed (excluding header)
+  id: string | null
+  dimensionValues: Record<string, string>
+  tierNumber: number | null
+  rangeFrom: string | null
+  rangeTo: string | null
+  currencyCode: string
+  prices: Record<string, number>
+}
+
+export type ImportDiff = {
+  inserts: ParsedRow[]
+  updates: Array<{ before: ImportEntry; after: ParsedRow }>
+  deletes: ImportEntry[]
+  unchanged: ImportEntry[]
+  warnings: string[]
+}
+
+export type ImportResult =
+  | { ok: true; diff: ImportDiff }
+  | { ok: false; error: string }
+
+export async function parsePricingTableXlsx(
+  file: File,
+  table: TableShape,
+  existingEntries: ImportEntry[],
+): Promise<ImportResult> {
+  let workbook: XLSX.WorkBook
+  try {
+    const buffer = await file.arrayBuffer()
+    workbook = XLSX.read(buffer, { type: 'array' })
+  } catch (err) {
+    return { ok: false, error: err instanceof Error ? `Failed to read file: ${err.message}` : 'Failed to read file' }
+  }
+
+  const sheetName = workbook.SheetNames[0]
+  if (!sheetName) return { ok: false, error: 'Workbook has no sheets' }
+  const sheet = workbook.Sheets[sheetName]
+
+  // Two-row header strategy: row 1 is human labels (from export), row 2+ is
+  // data. But during round-trip the original technical keys are not in the
+  // file — only labels. Re-derive keys from the table's `dimensions` and
+  // `priceColumns` by matching labels first; fall back to keys for the
+  // fixed columns (id, tier_number, range_from, range_to, currency_code).
+  const rows = XLSX.utils.sheet_to_json<Record<string, unknown>>(sheet, {
+    defval: '',
+    raw: false, // keep strings, parse numbers ourselves
+  })
+
+  if (rows.length === 0) {
+    return { ok: false, error: 'Sheet has no data rows' }
+  }
+
+  // Build label→key map for dimensions and price columns so we can match
+  // either the label or the technical key (both are valid header forms).
+  const headerToKey = new Map<string, { kind: 'dimension' | 'price'; key: string }>()
+  for (const d of table.dimensions) {
+    headerToKey.set(d.label.toLowerCase(), { kind: 'dimension', key: d.key })
+    headerToKey.set(d.key.toLowerCase(), { kind: 'dimension', key: d.key })
+  }
+  for (const c of table.priceColumns) {
+    headerToKey.set(c.label.toLowerCase(), { kind: 'price', key: c.key })
+    headerToKey.set(c.key.toLowerCase(), { kind: 'price', key: c.key })
+  }
+
+  // Inspect first row to discover which technical keys each column maps to.
+  const firstRow = rows[0]
+  const headers = Object.keys(firstRow)
+  const dimensionHeaders: Array<{ header: string; key: string }> = []
+  const priceHeaders: Array<{ header: string; key: string }> = []
+  let idHeader: string | null = null
+  let tierHeader: string | null = null
+  let rangeFromHeader: string | null = null
+  let rangeToHeader: string | null = null
+  let currencyHeader: string | null = null
+
+  for (const header of headers) {
+    const lower = header.trim().toLowerCase()
+    if (lower === 'id') { idHeader = header; continue }
+    if (lower === 'tier_number' || lower === 'tier #' || lower === 'tier number') { tierHeader = header; continue }
+    if (lower === 'range_from' || lower === 'range from') { rangeFromHeader = header; continue }
+    if (lower === 'range_to' || lower === 'range to') { rangeToHeader = header; continue }
+    if (lower === 'currency_code' || lower === 'currency code' || lower === 'currency') { currencyHeader = header; continue }
+    const mapped = headerToKey.get(lower)
+    if (!mapped) continue // unknown column — silently ignored (with warning later)
+    if (mapped.kind === 'dimension') dimensionHeaders.push({ header, key: mapped.key })
+    else priceHeaders.push({ header, key: mapped.key })
+  }
+
+  const warnings: string[] = []
+
+  // Unknown columns → warning (not error — Excel files often have stray
+  // columns from user notes).
+  const knownHeaders = new Set<string>([
+    idHeader,
+    tierHeader,
+    rangeFromHeader,
+    rangeToHeader,
+    currencyHeader,
+    ...dimensionHeaders.map((d) => d.header),
+    ...priceHeaders.map((p) => p.header),
+  ].filter((h): h is string => h !== null))
+  for (const h of headers) {
+    if (!knownHeaders.has(h)) warnings.push(`Ignored unknown column "${h}"`)
+  }
+
+  // Missing required columns from the table → error.
+  const missingDims = table.dimensions.filter((d) => !dimensionHeaders.some((h) => h.key === d.key))
+  const missingPrices = table.priceColumns.filter((c) => !priceHeaders.some((h) => h.key === c.key))
+  if (missingDims.length > 0) {
+    return { ok: false, error: `Missing dimension column(s): ${missingDims.map((d) => d.label).join(', ')}` }
+  }
+  if (missingPrices.length > 0) {
+    return { ok: false, error: `Missing price column(s): ${missingPrices.map((c) => c.label).join(', ')}` }
+  }
+  if (!currencyHeader) {
+    return { ok: false, error: 'Missing "currency_code" column' }
+  }
+
+  // ─── Parse rows ──────────────────────────────────────────────
+
+  const parsed: ParsedRow[] = []
+  for (let i = 0; i < rows.length; i++) {
+    const raw = rows[i]
+    const rowNumber = i + 2 // +1 for header, +1 because rows are 1-indexed in Excel
+
+    const id = idHeader ? toStringOrNull(raw[idHeader]) : null
+    const tierStr = tierHeader ? toStringOrNull(raw[tierHeader]) : null
+    const rangeFromStr = rangeFromHeader ? toStringOrNull(raw[rangeFromHeader]) : null
+    const rangeToStr = rangeToHeader ? toStringOrNull(raw[rangeToHeader]) : null
+    const currency = toStringOrNull(raw[currencyHeader]) ?? ''
+
+    if (!currency) {
+      return { ok: false, error: `Row ${rowNumber}: missing currency_code` }
+    }
+    if (!table.currencyCodeList.includes(currency.toUpperCase())) {
+      return { ok: false, error: `Row ${rowNumber}: currency "${currency}" is not in the table's currency list (${table.currencyCodeList.join(', ')})` }
+    }
+
+    const tierNumber = tierStr ? Number(tierStr) : null
+    if (tierNumber !== null && Number.isNaN(tierNumber)) {
+      return { ok: false, error: `Row ${rowNumber}: tier_number must be a number, got "${tierStr}"` }
+    }
+
+    const dimensionValues: Record<string, string> = {}
+    for (const { header, key } of dimensionHeaders) {
+      dimensionValues[key] = toStringOrNull(raw[header]) ?? ''
+    }
+
+    const prices: Record<string, number> = {}
+    for (const { header, key } of priceHeaders) {
+      const v = raw[header]
+      if (v === '' || v === null || v === undefined) {
+        prices[key] = 0
+        continue
+      }
+      const num = Number(v)
+      if (Number.isNaN(num)) {
+        return { ok: false, error: `Row ${rowNumber}: price column "${header}" must be a number, got "${String(v)}"` }
+      }
+      prices[key] = num
+    }
+
+    parsed.push({
+      rowNumber,
+      id,
+      dimensionValues,
+      tierNumber,
+      rangeFrom: rangeFromStr,
+      rangeTo: rangeToStr,
+      currencyCode: currency.toUpperCase(),
+      prices,
+    })
+  }
+
+  // ─── Compute diff ────────────────────────────────────────────
+
+  const existingById = new Map<string, ImportEntry>(existingEntries.map((e) => [e.id, e]))
+  const fileIds = new Set<string>(parsed.map((p) => p.id).filter((id): id is string => !!id))
+
+  const inserts: ParsedRow[] = []
+  const updates: Array<{ before: ImportEntry; after: ParsedRow }> = []
+  const unchanged: ImportEntry[] = []
+
+  for (const row of parsed) {
+    if (!row.id) {
+      inserts.push(row)
+      continue
+    }
+    const existing = existingById.get(row.id)
+    if (!existing) {
+      warnings.push(`Row ${row.rowNumber}: id "${row.id}" not found in current entries — will be inserted as new`)
+      inserts.push({ ...row, id: null })
+      continue
+    }
+    if (rowMatchesEntry(row, existing)) {
+      unchanged.push(existing)
+    } else {
+      updates.push({ before: existing, after: row })
+    }
+  }
+
+  const deletes = existingEntries.filter((e) => !fileIds.has(e.id))
+
+  return {
+    ok: true,
+    diff: { inserts, updates, deletes, unchanged, warnings },
+  }
+}
+
+// ─── Commit ────────────────────────────────────────────────────
+
+export async function commitImportDiff(
+  pricingTableId: string,
+  diff: ImportDiff,
+): Promise<{ ok: true } | { ok: false; error: string }> {
+  // INSERTS (batch — route accepts arrays)
+  if (diff.inserts.length > 0) {
+    const payload = diff.inserts.map((r) => ({
+      pricingTableId,
+      dimensionValues: r.dimensionValues,
+      tierNumber: r.tierNumber ?? undefined,
+      rangeFrom: r.rangeFrom !== null ? Number(r.rangeFrom) : undefined,
+      rangeTo: r.rangeTo !== null ? Number(r.rangeTo) : undefined,
+      currencyCode: r.currencyCode,
+      prices: r.prices,
+    }))
+    const res = await fetch('/api/cpq/pricing-table-entries', {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(payload),
+    })
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}))
+      return { ok: false, error: body.error ?? 'Failed to insert entries' }
+    }
+  }
+
+  // UPDATES (one-by-one)
+  for (const { before, after } of diff.updates) {
+    const res = await fetch('/api/cpq/pricing-table-entries', {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        id: before.id,
+        dimensionValues: after.dimensionValues,
+        tierNumber: after.tierNumber ?? null,
+        rangeFrom: after.rangeFrom !== null ? Number(after.rangeFrom) : null,
+        rangeTo: after.rangeTo !== null ? Number(after.rangeTo) : null,
+        currencyCode: after.currencyCode,
+        prices: after.prices,
+      }),
+    })
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}))
+      return { ok: false, error: body.error ?? `Failed to update entry ${before.id}` }
+    }
+  }
+
+  // DELETES (one-by-one)
+  for (const entry of diff.deletes) {
+    const res = await fetch('/api/cpq/pricing-table-entries', {
+      method: 'DELETE',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ id: entry.id }),
+    })
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}))
+      return { ok: false, error: body.error ?? `Failed to delete entry ${entry.id}` }
+    }
+  }
+
+  return { ok: true }
+}
+
+// ─── helpers ───────────────────────────────────────────────────
+
+function toStringOrNull(v: unknown): string | null {
+  if (v === null || v === undefined) return null
+  const s = String(v).trim()
+  return s === '' ? null : s
+}
+
+function rowMatchesEntry(row: ParsedRow, entry: ImportEntry): boolean {
+  if (row.currencyCode !== entry.currencyCode) return false
+  if ((row.tierNumber ?? null) !== (entry.tierNumber ?? null)) return false
+  if (!numericEqual(row.rangeFrom, entry.rangeFrom)) return false
+  if (!numericEqual(row.rangeTo, entry.rangeTo)) return false
+  // dimensions
+  const dimKeys = new Set([...Object.keys(row.dimensionValues), ...Object.keys(entry.dimensionValues)])
+  for (const k of dimKeys) {
+    if ((row.dimensionValues[k] ?? '') !== (entry.dimensionValues[k] ?? '')) return false
+  }
+  // prices
+  const priceKeys = new Set([...Object.keys(row.prices), ...Object.keys(entry.prices)])
+  for (const k of priceKeys) {
+    if ((row.prices[k] ?? 0) !== (entry.prices[k] ?? 0)) return false
+  }
+  return true
+}
+
+function numericEqual(a: string | null, b: string | null): boolean {
+  const an = a == null ? null : Number(a)
+  const bn = b == null ? null : Number(b)
+  if (an === null && bn === null) return true
+  if (an === null || bn === null) return false
+  return an === bn
+}

package/src/modules/cpq/backend/cpq/pricing/page.meta.ts

@@ -0,0 +1,16 @@
+import React from 'react'
+import { Calculator } from 'lucide-react'
+
+const pricingIcon = React.createElement(Calculator, { size: 16 })
+
+export const metadata = {
+  requireAuth: true,
+  requireFeatures: ['cpq.pricing.view'],
+  pageTitle: 'Pricing Tables',
+  pageTitleKey: 'cpq.pricing.list.title',
+  pageGroup: 'CPQ',
+  pageGroupKey: 'customers~sales~cpq.nav.group',
+  pageOrder: 20,
+  icon: pricingIcon,
+  breadcrumb: [{ label: 'Pricing Tables', labelKey: 'cpq.pricing.list.title' }],
+} as const

package/src/modules/cpq/backend/cpq/pricing/page.tsx

@@ -0,0 +1,111 @@
+"use client"
+import * as React from 'react'
+import { useT } from '@open-mercato/shared/lib/i18n/context'
+import { useRouter } from 'next/navigation'
+import type { ColumnDef } from '@tanstack/react-table'
+import { Button } from '@open-mercato/ui/primitives/button'
+import { Tag } from '@open-mercato/ui/primitives/tag'
+import type { FilterDef, FilterValues } from '@open-mercato/ui/backend/FilterBar'
+import { CpqListView, useCpqListData } from '../../../components/CpqListView'
+
+type PricingTable = {
+  id: string
+  code: string
+  name: string
+  priceColumns: Array<{ key: string; label: string }>
+  currencyCodeList: string[]
+  isActive: boolean
+}
+
+const PAGE_SIZE = 50
+
+function buildFilterParams(values: FilterValues, params: URLSearchParams) {
+  if (values.isActive === true) params.set('isActive', 'true')
+  if (values.isActive === false) params.set('isActive', 'false')
+}
+
+export default function PricingTablesPage() {
+  const t = useT()
+  const router = useRouter()
+
+  const data = useCpqListData<PricingTable>({
+    endpoint: '/api/cpq/pricing-tables',
+    pageSize: PAGE_SIZE,
+    buildFilterParams,
+    loadErrorMessage: t('cpq.pricing.list.error.load', 'Failed to load pricing tables'),
+  })
+
+  const filters = React.useMemo<FilterDef[]>(
+    () => [
+      {
+        id: 'isActive',
+        label: t('cpq.pricing.filters.isActive', 'Active'),
+        type: 'checkbox',
+      },
+    ],
+    [t],
+  )
+
+  const columns = React.useMemo<ColumnDef<PricingTable>[]>(
+    () => [
+      {
+        accessorKey: 'name',
+        header: t('cpq.pricing.name', 'Name'),
+        cell: ({ row }) => <span className="font-medium">{row.original.name}</span>,
+      },
+      {
+        accessorKey: 'code',
+        header: t('cpq.pricing.code', 'Code'),
+        cell: ({ row }) => <span className="font-mono text-xs">{row.original.code}</span>,
+      },
+      {
+        id: 'priceColumns',
+        header: t('cpq.pricing.priceColumns', 'Price Columns'),
+        cell: ({ row }) => <span>{row.original.priceColumns?.length ?? 0}</span>,
+      },
+      {
+        id: 'currencies',
+        header: t('cpq.pricing.currencies', 'Currencies'),
+        cell: ({ row }) => <span>{row.original.currencyCodeList?.join(', ') ?? '—'}</span>,
+      },
+      {
+        accessorKey: 'isActive',
+        header: t('cpq.pricing.status', 'Status'),
+        cell: ({ row }) => (
+          <Tag variant={row.original.isActive ? 'success' : 'neutral'} dot>
+            {row.original.isActive ? t('common.active', 'Active') : t('common.inactive', 'Inactive')}
+          </Tag>
+        ),
+      },
+    ],
+    [t],
+  )
+
+  return (
+    <CpqListView<PricingTable>
+      title={t('cpq.pricing.list.title', 'Pricing Tables')}
+      tableId="cpq.pricing.list"
+      data={data}
+      columns={columns}
+      filters={filters}
+      pageSize={PAGE_SIZE}
+      searchPlaceholder={t('cpq.pricing.search.placeholder', 'Search pricing tables...')}
+      actions={
+        <Button asChild>
+          <a href="/backend/cpq/pricing/new">{t('cpq.pricing.add', 'New Pricing Table')}</a>
+        </Button>
+      }
+      crud={{
+        endpoint: '/api/cpq/pricing-tables',
+        entityName: t('cpq.pricing.entityName', 'pricing table'),
+        editHref: (row) => `/backend/cpq/pricing/${row.id}`,
+      }}
+      onRowClick={(row) => router.push(`/backend/cpq/pricing/${row.id}`)}
+      emptyState={
+        <div className="rounded-lg border bg-card p-6 text-center text-sm text-muted-foreground">
+          {t('cpq.pricing.empty', 'No pricing tables found.')}
+        </div>
+      }
+    />
+  )
+}