@open-mercato/core 0.4.5-develop-3ce83a8b24 → 0.4.5-develop-4849712ccb

package/src/modules/catalog/components/products/productFormUtils.ts

@@ -0,0 +1,82 @@
+import { REFERENCE_UNIT_CODES, type ReferenceUnitCode } from "@open-mercato/shared/lib/units/unitCodes";
+import { canonicalizeUnitCode } from "../../lib/unitCodes";
+import { createCrudFormError } from "@open-mercato/ui/backend/utils/serverErrors";
+import type { ProductUnitConversionDraft } from "./productForm";
+
+export const UNIT_PRICE_REFERENCE_UNITS = new Set<ReferenceUnitCode>(REFERENCE_UNIT_CODES);
+
+export function toTrimmedOrNull(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const trimmed = value.trim();
+  return trimmed.length ? trimmed : null;
+}
+
+export function parseNumericInput(value: unknown): number {
+  if (typeof value === "number") return value;
+  if (typeof value === "string") {
+    const normalized = value.trim().replace(/\s+/g, "").replace(/,/g, ".");
+    if (!normalized.length) return Number.NaN;
+    return Number(normalized);
+  }
+  return Number(value);
+}
+
+export function toPositiveNumberOrNull(value: unknown): number | null {
+  const numeric = parseNumericInput(value);
+  if (!Number.isFinite(numeric) || numeric <= 0) return null;
+  return numeric;
+}
+
+export function toIntegerInRangeOrDefault(
+  value: unknown,
+  min: number,
+  max: number,
+  fallback: number,
+): number {
+  const numeric = parseNumericInput(value);
+  if (!Number.isInteger(numeric) || numeric < min || numeric > max)
+    return fallback;
+  return numeric;
+}
+
+export type ProductUnitConversionInput = {
+  id?: string | null;
+  unitCode: string;
+  toBaseFactor: number;
+  sortOrder: number;
+  isActive: boolean;
+};
+
+export function normalizeProductConversionInputs(
+  rows: ProductUnitConversionDraft[] | undefined,
+  duplicateMessage: string,
+): ProductUnitConversionInput[] {
+  const list = Array.isArray(rows) ? rows : [];
+  const normalized: ProductUnitConversionInput[] = [];
+  const seen = new Set<string>();
+  for (const row of list) {
+    const unitCode = canonicalizeUnitCode(row?.unitCode);
+    const toBaseFactor = toPositiveNumberOrNull(row?.toBaseFactor);
+    if (!unitCode || toBaseFactor === null) continue;
+    const unitKey = unitCode.toLowerCase();
+    if (seen.has(unitKey)) {
+      throw createCrudFormError(duplicateMessage, {
+        unitConversions: duplicateMessage,
+      });
+    }
+    seen.add(unitKey);
+    normalized.push({
+      id: toTrimmedOrNull(row?.id),
+      unitCode,
+      toBaseFactor,
+      sortOrder: toIntegerInRangeOrDefault(
+        row?.sortOrder,
+        0,
+        100000,
+        normalized.length * 10,
+      ),
+      isActive: row?.isActive !== false,
+    });
+  }
+  return normalized;
+}

package/src/modules/catalog/data/entities.ts

@@ -15,6 +15,7 @@ import type {
   CatalogProductRelationType,
   CatalogProductType,
 } from './types'
+import type { ReferenceUnitCode } from '@open-mercato/shared/lib/units/unitCodes'
 
 @Entity({ tableName: 'catalog_product_option_schemas' })
 @Index({
@@ -70,7 +71,14 @@ export class CatalogOptionSchemaTemplate {
 @Unique({ name: 'catalog_products_sku_scope_unique', properties: ['organizationId', 'tenantId', 'sku'] })
 @Unique({ name: 'catalog_products_handle_scope_unique', properties: ['organizationId', 'tenantId', 'handle'] })
 export class CatalogProduct {
-  [OptionalProps]?: 'createdAt' | 'updatedAt' | 'deletedAt'
+  [OptionalProps]?:
+    | 'createdAt'
+    | 'updatedAt'
+    | 'deletedAt'
+    | 'defaultSalesUnitQuantity'
+    | 'uomRoundingScale'
+    | 'uomRoundingMode'
+    | 'unitPriceEnabled'
 
   @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
   id!: string
@@ -114,6 +122,27 @@ export class CatalogProduct {
   @Property({ name: 'default_unit', type: 'text', nullable: true })
   defaultUnit?: string | null
 
+  @Property({ name: 'default_sales_unit', type: 'text', nullable: true })
+  defaultSalesUnit?: string | null
+
+  @Property({ name: 'default_sales_unit_quantity', type: 'numeric', precision: 18, scale: 6, default: '1' })
+  defaultSalesUnitQuantity: string = '1'
+
+  @Property({ name: 'uom_rounding_scale', type: 'smallint', default: 4 })
+  uomRoundingScale: number = 4
+
+  @Property({ name: 'uom_rounding_mode', type: 'text', default: 'half_up' })
+  uomRoundingMode: 'half_up' | 'down' | 'up' = 'half_up'
+
+  @Property({ name: 'unit_price_enabled', type: 'boolean', default: false })
+  unitPriceEnabled: boolean = false
+
+  @Property({ name: 'unit_price_reference_unit', type: 'text', nullable: true })
+  unitPriceReferenceUnit?: ReferenceUnitCode | null
+
+  @Property({ name: 'unit_price_base_quantity', type: 'numeric', precision: 18, scale: 6, nullable: true })
+  unitPriceBaseQuantity?: string | null
+
   @Property({ name: 'default_media_id', type: 'uuid', nullable: true })
   defaultMediaId?: string | null
 
@@ -174,7 +203,59 @@ export class CatalogProduct {
   @OneToMany(() => CatalogProductTagAssignment, (assignment) => assignment.product)
   tagAssignments = new Collection<CatalogProductTagAssignment>(this)
 
+  @OneToMany(() => CatalogProductUnitConversion, (conversion) => conversion.product)
+  unitConversions = new Collection<CatalogProductUnitConversion>(this)
 }
+
+@Entity({ tableName: 'catalog_product_unit_conversions' })
+@Index({
+  name: 'catalog_product_unit_conversions_scope_idx',
+  properties: ['organizationId', 'tenantId', 'product'],
+})
+@Unique({
+  name: 'catalog_product_unit_conversions_unique',
+  properties: ['product', 'unitCode'],
+})
+export class CatalogProductUnitConversion {
+  [OptionalProps]?: 'createdAt' | 'updatedAt' | 'deletedAt' | 'sortOrder' | 'isActive'
+
+  @PrimaryKey({ type: 'uuid', defaultRaw: 'gen_random_uuid()' })
+  id!: string
+
+  @ManyToOne(() => CatalogProduct, { fieldName: 'product_id', deleteRule: 'cascade' })
+  product!: CatalogProduct
+
+  @Property({ name: 'organization_id', type: 'uuid' })
+  organizationId!: string
+
+  @Property({ name: 'tenant_id', type: 'uuid' })
+  tenantId!: string
+
+  @Property({ name: 'unit_code', type: 'text' })
+  unitCode!: string
+
+  @Property({ name: 'to_base_factor', type: 'numeric', precision: 24, scale: 12 })
+  toBaseFactor!: string
+
+  @Property({ name: 'sort_order', type: 'integer', default: 0 })
+  sortOrder: number = 0
+
+  @Property({ name: 'is_active', type: 'boolean', default: true })
+  isActive: boolean = true
+
+  @Property({ name: 'metadata', type: 'jsonb', nullable: true })
+  metadata?: Record<string, unknown> | null
+
+  @Property({ name: 'created_at', type: Date, onCreate: () => new Date() })
+  createdAt: Date = new Date()
+
+  @Property({ name: 'updated_at', type: Date, onUpdate: () => new Date() })
+  updatedAt: Date = new Date()
+
+  @Property({ name: 'deleted_at', type: Date, nullable: true })
+  deletedAt?: Date | null
+}
+
 @Entity({ tableName: 'catalog_product_categories' })
 @Index({ name: 'catalog_product_categories_scope_idx', properties: ['organizationId', 'tenantId'] })
 @Unique({ name: 'catalog_product_categories_slug_unique', properties: ['organizationId', 'tenantId', 'slug'] })

package/src/modules/catalog/data/validators.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod'
 import { CATALOG_PRICE_DISPLAY_MODES, CATALOG_PRODUCT_TYPES } from './types'
+import { REFERENCE_UNIT_CODES } from '../lib/unitCodes'
 
 const uuid = () => z.string().uuid()
 
@@ -107,42 +108,102 @@ export const offerUpdateSchema = z
   )
 
 const productTypeSchema = z.enum(CATALOG_PRODUCT_TYPES)
+const uomRoundingModeSchema = z.enum(['half_up', 'down', 'up'])
+const unitPriceReferenceUnitSchema = z.enum(REFERENCE_UNIT_CODES)
+const unitPriceConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  referenceUnit: unitPriceReferenceUnitSchema.nullable().optional(),
+  baseQuantity: z.coerce.number().positive().optional(),
+})
 
-export const productCreateSchema = scoped.extend({
-  title: z.string().trim().min(1).max(255),
-  subtitle: z.string().trim().max(255).optional(),
-  description: z.string().trim().max(4000).optional(),
-  sku: skuSchema.optional(),
-  handle: handleSchema.optional(),
-  taxRateId: uuid().nullable().optional(),
-  taxRate: z.coerce.number().min(0).max(100).optional().nullable(),
-  productType: productTypeSchema.default('simple'),
-  statusEntryId: uuid().optional(),
-  primaryCurrencyCode: currencyCodeSchema.optional(),
-  defaultUnit: z.string().trim().max(50).optional(),
-  defaultMediaId: uuid().optional().nullable(),
-  defaultMediaUrl: z.string().trim().max(500).optional().nullable(),
-  weightValue: z.coerce.number().min(0).optional().nullable(),
-  weightUnit: z.string().trim().max(25).optional().nullable(),
-  dimensions: z
-    .object({
-      width: z.coerce.number().min(0).optional(),
-      height: z.coerce.number().min(0).optional(),
-      depth: z.coerce.number().min(0).optional(),
-      unit: z.string().trim().max(25).optional(),
+function productUomCrossFieldRefinement(
+  input: {
+    defaultUnit?: string | null
+    defaultSalesUnit?: string | null
+    unitPriceEnabled?: boolean
+    unitPriceReferenceUnit?: string | null
+    unitPriceBaseQuantity?: number
+    unitPrice?: { enabled?: boolean; referenceUnit?: string | null; baseQuantity?: number }
+  },
+  ctx: z.RefinementCtx,
+) {
+  const defaultUnit = typeof input.defaultUnit === 'string' ? input.defaultUnit.trim() : ''
+  const defaultSalesUnit =
+    typeof input.defaultSalesUnit === 'string' ? input.defaultSalesUnit.trim() : ''
+  if (defaultSalesUnit && !defaultUnit) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['defaultSalesUnit'],
+      message: 'catalog.products.validation.baseUnitRequired',
     })
-    .optional()
-    .nullable(),
-  optionSchemaId: uuid().nullable().optional(),
-  optionSchema: optionSchema.optional(),
-  customFieldsetCode: slugSchema.nullable().optional(),
-  isConfigurable: z.boolean().optional(),
-  isActive: z.boolean().optional(),
-  metadata: metadataSchema,
-  offers: z.array(offerInputSchema.omit({ id: true })).optional(),
-  categoryIds: z.array(uuid()).max(100).optional(),
-  tags: z.array(tagLabelSchema).max(100).optional(),
-})
+  }
+  const unitPriceEnabled = input.unitPrice?.enabled ?? input.unitPriceEnabled ?? false
+  if (!unitPriceEnabled) return
+  const referenceUnit =
+    input.unitPrice?.referenceUnit ?? input.unitPriceReferenceUnit ?? null
+  const baseQuantity =
+    input.unitPrice?.baseQuantity ?? input.unitPriceBaseQuantity ?? null
+  if (!referenceUnit) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['unitPrice'],
+      message: 'catalog.products.validation.referenceUnitRequired',
+    })
+  }
+  if (baseQuantity === null || baseQuantity === undefined || Number(baseQuantity) <= 0) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['unitPrice'],
+      message: 'catalog.products.unitPrice.errors.baseQuantity',
+    })
+  }
+}
+
+export const productCreateSchema = scoped
+  .extend({
+    title: z.string().trim().min(1).max(255),
+    subtitle: z.string().trim().max(255).optional(),
+    description: z.string().trim().max(4000).optional(),
+    sku: skuSchema.optional(),
+    handle: handleSchema.optional(),
+    taxRateId: uuid().nullable().optional(),
+    taxRate: z.coerce.number().min(0).max(100).optional().nullable(),
+    productType: productTypeSchema.default('simple'),
+    statusEntryId: uuid().optional(),
+    primaryCurrencyCode: currencyCodeSchema.optional(),
+    defaultUnit: z.string().trim().max(50).optional().nullable(),
+    defaultSalesUnit: z.string().trim().max(50).optional().nullable(),
+    defaultSalesUnitQuantity: z.coerce.number().positive().optional(),
+    uomRoundingScale: z.coerce.number().int().min(0).max(6).optional(),
+    uomRoundingMode: uomRoundingModeSchema.optional(),
+    unitPriceEnabled: z.boolean().optional(),
+    unitPriceReferenceUnit: unitPriceReferenceUnitSchema.nullable().optional(),
+    unitPriceBaseQuantity: z.coerce.number().positive().optional(),
+    unitPrice: unitPriceConfigSchema.optional(),
+    defaultMediaId: uuid().optional().nullable(),
+    defaultMediaUrl: z.string().trim().max(500).optional().nullable(),
+    weightValue: z.coerce.number().min(0).optional().nullable(),
+    weightUnit: z.string().trim().max(25).optional().nullable(),
+    dimensions: z
+      .object({
+        width: z.coerce.number().min(0).optional(),
+        height: z.coerce.number().min(0).optional(),
+        depth: z.coerce.number().min(0).optional(),
+        unit: z.string().trim().max(25).optional(),
+      })
+      .optional()
+      .nullable(),
+    optionSchemaId: uuid().nullable().optional(),
+    optionSchema: optionSchema.optional(),
+    customFieldsetCode: slugSchema.nullable().optional(),
+    isConfigurable: z.boolean().optional(),
+    isActive: z.boolean().optional(),
+    metadata: metadataSchema,
+    offers: z.array(offerInputSchema.omit({ id: true })).optional(),
+    categoryIds: z.array(uuid()).max(100).optional(),
+    tags: z.array(tagLabelSchema).max(100).optional(),
+  })
+  .superRefine(productUomCrossFieldRefinement)
 
 export const productUpdateSchema = z
   .object({
@@ -152,6 +213,7 @@ export const productUpdateSchema = z
   .extend({
     productType: productTypeSchema.optional(),
   })
+  .superRefine(productUomCrossFieldRefinement)
 
 export const variantCreateSchema = scoped.extend({
   productId: uuid(),
@@ -265,6 +327,25 @@ export const categoryUpdateSchema = z
   })
   .merge(categoryCreateSchema.partial())
 
+export const productUnitConversionCreateSchema = scoped.extend({
+  productId: uuid(),
+  unitCode: z.string().trim().min(1).max(50),
+  toBaseFactor: z.coerce.number().positive().max(1_000_000),
+  sortOrder: z.coerce.number().int().optional(),
+  isActive: z.boolean().optional(),
+  metadata: metadataSchema,
+})
+
+export const productUnitConversionUpdateSchema = z
+  .object({
+    id: uuid(),
+  })
+  .merge(productUnitConversionCreateSchema.omit({ productId: true }).partial())
+
+export const productUnitConversionDeleteSchema = scoped.extend({
+  id: uuid(),
+})
+
 export type ProductCreateInput = z.infer<typeof productCreateSchema>
 export type ProductUpdateInput = z.infer<typeof productUpdateSchema>
 export type VariantCreateInput = z.infer<typeof variantCreateSchema>
@@ -280,3 +361,6 @@ export type CategoryUpdateInput = z.infer<typeof categoryUpdateSchema>
 export type OfferInput = z.infer<typeof offerInputSchema>
 export type OfferCreateInput = z.infer<typeof offerCreateSchema>
 export type OfferUpdateInput = z.infer<typeof offerUpdateSchema>
+export type ProductUnitConversionCreateInput = z.infer<typeof productUnitConversionCreateSchema>
+export type ProductUnitConversionUpdateInput = z.infer<typeof productUnitConversionUpdateSchema>
+export type ProductUnitConversionDeleteInput = z.infer<typeof productUnitConversionDeleteSchema>

package/src/modules/catalog/events.ts

@@ -10,6 +10,9 @@ const events = [
   { id: 'catalog.product.created', label: 'Product Created', entity: 'product', category: 'crud' },
   { id: 'catalog.product.updated', label: 'Product Updated', entity: 'product', category: 'crud' },
   { id: 'catalog.product.deleted', label: 'Product Deleted', entity: 'product', category: 'crud' },
+  { id: 'catalog.product_unit_conversion.created', label: 'Product Unit Conversion Created', entity: 'product_unit_conversion', category: 'crud' },
+  { id: 'catalog.product_unit_conversion.updated', label: 'Product Unit Conversion Updated', entity: 'product_unit_conversion', category: 'crud' },
+  { id: 'catalog.product_unit_conversion.deleted', label: 'Product Unit Conversion Deleted', entity: 'product_unit_conversion', category: 'crud' },
 
   // Categories
   { id: 'catalog.category.created', label: 'Category Created', entity: 'category', category: 'crud' },

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

@@ -16,6 +16,9 @@
   "catalog.audit.prices.create": "Preis erstellen",
   "catalog.audit.prices.delete": "Preis löschen",
   "catalog.audit.prices.update": "Preis aktualisieren",
+  "catalog.audit.productUnitConversions.create": "Produkteinheiten-Umrechnung erstellen",
+  "catalog.audit.productUnitConversions.delete": "Produkteinheiten-Umrechnung löschen",
+  "catalog.audit.productUnitConversions.update": "Produkteinheiten-Umrechnung aktualisieren",
   "catalog.audit.products.create": "Produkt erstellen",
   "catalog.audit.products.delete": "Produkt löschen",
   "catalog.audit.products.update": "Produkt aktualisieren",
@@ -394,6 +397,7 @@
   "catalog.products.edit.weight.value": "Gewicht",
   "catalog.products.errors.handleExists": "Handle wird bereits verwendet.",
   "catalog.products.errors.skuExists": "SKU wird bereits verwendet.",
+  "catalog.products.errors.taxClassNotFound": "Steuerklasse nicht gefunden.",
   "catalog.products.filters.active": "Aktiv",
   "catalog.products.filters.categories": "Kategorien",
   "catalog.products.filters.categoriesLoadError": "Kategorien konnten nicht geladen werden",
@@ -454,12 +458,64 @@
   "catalog.products.types.grouped": "Gruppiert",
   "catalog.products.types.simple": "Einfach",
   "catalog.products.types.virtual": "Virtuell",
+  "catalog.products.unitPrice.baseQuantity": "Basismenge für Referenz",
+  "catalog.products.unitPrice.enable": "EU-Grundpreisanzeige aktivieren",
+  "catalog.products.unitPrice.errors.baseQuantity": "Basismenge ist erforderlich, wenn die Grundpreisanzeige aktiviert ist.",
+  "catalog.products.unitPrice.errors.referenceUnit": "Referenzeinheit ist erforderlich, wenn die Grundpreisanzeige aktiviert ist.",
+  "catalog.products.unitPrice.hint": "Zeigt den berechneten Preis pro ausgewählter Referenzeinheit. In den meisten Fällen Menge 1 verwenden.",
+  "catalog.products.unitPrice.hintWithPreview": "Zeigt den berechneten Preis pro {{quantity}} {{unit}}. Für die meisten Produkte 1 verwenden (z. B. 1 kg, 1 l, 1 m²).",
+  "catalog.products.unitPrice.options.kg": "1 kg",
+  "catalog.products.unitPrice.options.l": "1 l",
+  "catalog.products.unitPrice.options.m2": "1 m²",
+  "catalog.products.unitPrice.options.m3": "1 m³",
+  "catalog.products.unitPrice.options.pc": "1 Stk.",
+  "catalog.products.unitPrice.referenceUnit": "Referenzeinheit",
+  "catalog.products.unitPrice.selectReferenceUnit": "Referenzeinheit auswählen",
+  "catalog.products.uom.active": "Aktiv",
+  "catalog.products.uom.addConversion": "Umrechnung hinzufügen",
+  "catalog.products.uom.baseUnit": "Basiseinheit",
+  "catalog.products.uom.conversionOrderHint": "Nutze die Pfeile, um die Umrechnungspriorität neu zu ordnen.",
+  "catalog.products.uom.conversionPreview": "1 {{fromUnit}} = {{factor}} {{baseUnit}}",
+  "catalog.products.uom.conversionUnit": "Verkaufseinheit",
+  "catalog.products.uom.conversions": "Produktumrechnungen",
+  "catalog.products.uom.defaultSalesQuantity": "Standard-Verkaufsmenge",
+  "catalog.products.uom.defaultSalesQuantityHint": "Wird verwendet, um die Menge in Angebots-/Auftragspositionen vorzufüllen. Der Wert wird in der Standard-Verkaufseinheit interpretiert.",
+  "catalog.products.uom.defaultSalesQuantityLabel": "Standard-Positionsmenge (in Verkaufseinheit)",
+  "catalog.products.uom.defaultSalesQuantityPreview": "Standardposition: {{quantity}} {{salesUnit}}.",
+  "catalog.products.uom.defaultSalesQuantityPreviewWithNormalization": "Standardposition: {{quantity}} {{salesUnit}} (= {{normalized}} {{baseUnit}}).",
+  "catalog.products.uom.defaultSalesUnit": "Standard-Verkaufseinheit",
+  "catalog.products.uom.description": "Basis-/Verkaufseinheiten und Verpackungsumrechnungen festlegen.",
+  "catalog.products.uom.emptyConversions": "Noch keine Umrechnungen konfiguriert.",
+  "catalog.products.uom.errors.baseRequired": "Basiseinheit ist erforderlich, wenn eine Standard-Verkaufseinheit festgelegt ist.",
+  "catalog.products.uom.errors.baseRequiredForConversions": "Basiseinheit ist erforderlich, wenn Umrechnungen konfiguriert sind.",
+  "catalog.products.uom.errors.defaultSalesConversionRequired": "Aktive Umrechnung für die Standard-Verkaufseinheit ist erforderlich, wenn sie von der Basiseinheit abweicht.",
+  "catalog.products.uom.errors.duplicateConversion": "Doppelte Umrechnungseinheit ist nicht erlaubt.",
+  "catalog.products.uom.errors.loadUnits": "Einheiten konnten nicht geladen werden. Bitte versuchen Sie, die Seite zu aktualisieren.",
+  "catalog.products.uom.errors.sync": "Produktumrechnungen konnten nicht synchronisiert werden.",
+  "catalog.products.uom.loadingUnits": "Einheiten werden geladen...",
+  "catalog.products.uom.moveDown": "Umrechnung nach unten verschieben",
+  "catalog.products.uom.moveUp": "Umrechnung nach oben verschieben",
+  "catalog.products.uom.removeConversion": "Umrechnung entfernen",
+  "catalog.products.uom.roundingMode": "Rundungsmodus",
+  "catalog.products.uom.roundingModeDown": "Abrunden",
+  "catalog.products.uom.roundingModeHalfUp": "Kaufmännisch runden (Standard)",
+  "catalog.products.uom.roundingModeUp": "Aufrunden",
+  "catalog.products.uom.roundingScale": "Rundungsgenauigkeit (Dezimalstellen)",
+  "catalog.products.uom.selectUnit": "Einheit auswählen",
+  "catalog.products.uom.sortOrder": "Sortierung",
+  "catalog.products.uom.title": "Maßeinheiten",
+  "catalog.products.uom.toBaseFactor": "Basisfaktor",
+  "catalog.products.validation.baseUnitRequired": "Basiseinheit ist erforderlich, wenn eine Standard-Verkaufseinheit gesetzt ist.",
+  "catalog.products.validation.handleFormat": "Handle darf nur Kleinbuchstaben, Ziffern, Bindestriche oder Unterstriche enthalten.",
+  "catalog.products.validation.referenceUnitRequired": "Referenzeinheit ist erforderlich, wenn die Grundpreisanzeige aktiviert ist.",
+  "catalog.products.validation.titleRequired": "Titel ist erforderlich.",
   "catalog.search.badge.category": "Kategorie",
   "catalog.search.badge.offer": "Kanalangebot",
   "catalog.search.badge.optionSchema": "Optionsschema",
   "catalog.search.badge.priceKind": "Preisart",
   "catalog.search.badge.product": "Produkt",
   "catalog.search.badge.tag": "Schlagwort",
+  "catalog.search.badge.unitConversion": "Einheitenumrechnung",
   "catalog.search.badge.variant": "Variante",
   "catalog.search.priceKind.excludingTax": "Exkl. MwSt.",
   "catalog.search.priceKind.includingTax": "Inkl. MwSt.",

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

@@ -16,6 +16,9 @@
   "catalog.audit.prices.create": "Create price",
   "catalog.audit.prices.delete": "Delete price",
   "catalog.audit.prices.update": "Update price",
+  "catalog.audit.productUnitConversions.create": "Create product unit conversion",
+  "catalog.audit.productUnitConversions.delete": "Delete product unit conversion",
+  "catalog.audit.productUnitConversions.update": "Update product unit conversion",
   "catalog.audit.products.create": "Create product",
   "catalog.audit.products.delete": "Delete product",
   "catalog.audit.products.update": "Update product",
@@ -394,6 +397,7 @@
   "catalog.products.edit.weight.value": "Weight",
   "catalog.products.errors.handleExists": "Handle already in use.",
   "catalog.products.errors.skuExists": "SKU already in use.",
+  "catalog.products.errors.taxClassNotFound": "Tax class not found.",
   "catalog.products.filters.active": "Active",
   "catalog.products.filters.categories": "Categories",
   "catalog.products.filters.categoriesLoadError": "Failed to load categories",
@@ -454,12 +458,64 @@
   "catalog.products.types.grouped": "Grouped",
   "catalog.products.types.simple": "Simple",
   "catalog.products.types.virtual": "Virtual",
+  "catalog.products.unitPrice.baseQuantity": "Base quantity for reference",
+  "catalog.products.unitPrice.enable": "Enable EU unit price display",
+  "catalog.products.unitPrice.errors.baseQuantity": "Base quantity is required when unit price display is enabled.",
+  "catalog.products.unitPrice.errors.referenceUnit": "Reference unit is required when unit price display is enabled.",
+  "catalog.products.unitPrice.hint": "Show calculated price per selected reference unit. In most cases set quantity to 1.",
+  "catalog.products.unitPrice.hintWithPreview": "Show calculated price per {{quantity}} {{unit}}. For most products use 1 (for example: 1 kg, 1 l, 1 m²).",
+  "catalog.products.unitPrice.options.kg": "1 kg",
+  "catalog.products.unitPrice.options.l": "1 l",
+  "catalog.products.unitPrice.options.m2": "1 m²",
+  "catalog.products.unitPrice.options.m3": "1 m³",
+  "catalog.products.unitPrice.options.pc": "1 pc",
+  "catalog.products.unitPrice.referenceUnit": "Reference unit",
+  "catalog.products.unitPrice.selectReferenceUnit": "Select reference unit",
+  "catalog.products.uom.active": "Active",
+  "catalog.products.uom.addConversion": "Add conversion",
+  "catalog.products.uom.baseUnit": "Base unit",
+  "catalog.products.uom.conversionOrderHint": "Use arrows to reorder conversion priority.",
+  "catalog.products.uom.conversionPreview": "1 {{fromUnit}} = {{factor}} {{baseUnit}}",
+  "catalog.products.uom.conversionUnit": "Sales unit",
+  "catalog.products.uom.conversions": "Product conversions",
+  "catalog.products.uom.defaultSalesQuantity": "Default sales quantity",
+  "catalog.products.uom.defaultSalesQuantityHint": "Used to prefill quantity in quote/order lines. Value is interpreted in Default sales unit.",
+  "catalog.products.uom.defaultSalesQuantityLabel": "Default line quantity (in sales unit)",
+  "catalog.products.uom.defaultSalesQuantityPreview": "Default line: {{quantity}} {{salesUnit}}.",
+  "catalog.products.uom.defaultSalesQuantityPreviewWithNormalization": "Default line: {{quantity}} {{salesUnit}} (= {{normalized}} {{baseUnit}}).",
+  "catalog.products.uom.defaultSalesUnit": "Default sales unit",
+  "catalog.products.uom.description": "Set base/sales units and packaging conversions.",
+  "catalog.products.uom.emptyConversions": "No conversions configured yet.",
+  "catalog.products.uom.errors.baseRequired": "Base unit is required when default sales unit is set.",
+  "catalog.products.uom.errors.baseRequiredForConversions": "Base unit is required when conversions are configured.",
+  "catalog.products.uom.errors.defaultSalesConversionRequired": "Active conversion for default sales unit is required when it differs from base unit.",
+  "catalog.products.uom.errors.duplicateConversion": "Duplicate conversion unit is not allowed.",
+  "catalog.products.uom.errors.loadUnits": "Failed to load units. Please try refreshing the page.",
+  "catalog.products.uom.errors.sync": "Failed to synchronize product conversions.",
+  "catalog.products.uom.loadingUnits": "Loading units...",
+  "catalog.products.uom.moveDown": "Move conversion down",
+  "catalog.products.uom.moveUp": "Move conversion up",
+  "catalog.products.uom.removeConversion": "Remove conversion",
+  "catalog.products.uom.roundingMode": "Rounding mode",
+  "catalog.products.uom.roundingModeDown": "Down",
+  "catalog.products.uom.roundingModeHalfUp": "Half up",
+  "catalog.products.uom.roundingModeUp": "Up",
+  "catalog.products.uom.roundingScale": "Rounding scale",
+  "catalog.products.uom.selectUnit": "Select unit",
+  "catalog.products.uom.sortOrder": "Sort",
+  "catalog.products.uom.title": "Units of measure",
+  "catalog.products.uom.toBaseFactor": "To base factor",
+  "catalog.products.validation.baseUnitRequired": "Base unit is required when a default sales unit is set.",
+  "catalog.products.validation.handleFormat": "Handle must include lowercase letters, digits, hyphen, or underscore.",
+  "catalog.products.validation.referenceUnitRequired": "Reference unit is required when unit price display is enabled.",
+  "catalog.products.validation.titleRequired": "Title is required.",
   "catalog.search.badge.category": "Category",
   "catalog.search.badge.offer": "Channel Offer",
   "catalog.search.badge.optionSchema": "Option Schema",
   "catalog.search.badge.priceKind": "Price Kind",
   "catalog.search.badge.product": "Product",
   "catalog.search.badge.tag": "Tag",
+  "catalog.search.badge.unitConversion": "Unit Conversion",
   "catalog.search.badge.variant": "Variant",
   "catalog.search.priceKind.excludingTax": "Excl. tax",
   "catalog.search.priceKind.includingTax": "Incl. tax",

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

@@ -16,6 +16,9 @@
   "catalog.audit.prices.create": "Crear precio",
   "catalog.audit.prices.delete": "Eliminar precio",
   "catalog.audit.prices.update": "Actualizar precio",
+  "catalog.audit.productUnitConversions.create": "Crear conversión de unidad de producto",
+  "catalog.audit.productUnitConversions.delete": "Eliminar conversión de unidad de producto",
+  "catalog.audit.productUnitConversions.update": "Actualizar conversión de unidad de producto",
   "catalog.audit.products.create": "Crear producto",
   "catalog.audit.products.delete": "Eliminar producto",
   "catalog.audit.products.update": "Actualizar producto",
@@ -394,6 +397,7 @@
   "catalog.products.edit.weight.value": "Peso",
   "catalog.products.errors.handleExists": "El identificador ya está en uso.",
   "catalog.products.errors.skuExists": "El SKU ya está en uso.",
+  "catalog.products.errors.taxClassNotFound": "Clase de impuesto no encontrada.",
   "catalog.products.filters.active": "Activo",
   "catalog.products.filters.categories": "Categorías",
   "catalog.products.filters.categoriesLoadError": "No se pudieron cargar las categorías",
@@ -454,12 +458,64 @@
   "catalog.products.types.grouped": "Agrupado",
   "catalog.products.types.simple": "Simple",
   "catalog.products.types.virtual": "Virtual",
+  "catalog.products.unitPrice.baseQuantity": "Cantidad base de referencia",
+  "catalog.products.unitPrice.enable": "Activar precio unitario UE",
+  "catalog.products.unitPrice.errors.baseQuantity": "La cantidad base es obligatoria cuando la visualización del precio unitario está activada.",
+  "catalog.products.unitPrice.errors.referenceUnit": "La unidad de referencia es obligatoria cuando la visualización del precio unitario está activada.",
+  "catalog.products.unitPrice.hint": "Muestra el precio calculado por la unidad de referencia seleccionada. En la mayoría de casos usa cantidad 1.",
+  "catalog.products.unitPrice.hintWithPreview": "Muestra el precio calculado por {{quantity}} {{unit}}. Para la mayoría de productos usa 1 (por ejemplo: 1 kg, 1 l, 1 m²).",
+  "catalog.products.unitPrice.options.kg": "1 kg",
+  "catalog.products.unitPrice.options.l": "1 l",
+  "catalog.products.unitPrice.options.m2": "1 m²",
+  "catalog.products.unitPrice.options.m3": "1 m³",
+  "catalog.products.unitPrice.options.pc": "1 ud.",
+  "catalog.products.unitPrice.referenceUnit": "Unidad de referencia",
+  "catalog.products.unitPrice.selectReferenceUnit": "Seleccionar unidad de referencia",
+  "catalog.products.uom.active": "Activo",
+  "catalog.products.uom.addConversion": "Añadir conversión",
+  "catalog.products.uom.baseUnit": "Unidad base",
+  "catalog.products.uom.conversionOrderHint": "Usa las flechas para reordenar la prioridad de conversión.",
+  "catalog.products.uom.conversionPreview": "1 {{fromUnit}} = {{factor}} {{baseUnit}}",
+  "catalog.products.uom.conversionUnit": "Unidad de venta",
+  "catalog.products.uom.conversions": "Conversiones de producto",
+  "catalog.products.uom.defaultSalesQuantity": "Cantidad de venta predeterminada",
+  "catalog.products.uom.defaultSalesQuantityHint": "Se usa para rellenar la cantidad en líneas de oferta/pedido. El valor se interpreta en la unidad de venta predeterminada.",
+  "catalog.products.uom.defaultSalesQuantityLabel": "Cantidad predeterminada de línea (en unidad de venta)",
+  "catalog.products.uom.defaultSalesQuantityPreview": "Línea predeterminada: {{quantity}} {{salesUnit}}.",
+  "catalog.products.uom.defaultSalesQuantityPreviewWithNormalization": "Línea predeterminada: {{quantity}} {{salesUnit}} (= {{normalized}} {{baseUnit}}).",
+  "catalog.products.uom.defaultSalesUnit": "Unidad de venta predeterminada",
+  "catalog.products.uom.description": "Configurar unidades base/venta y conversiones de empaque.",
+  "catalog.products.uom.emptyConversions": "Aún no hay conversiones configuradas.",
+  "catalog.products.uom.errors.baseRequired": "La unidad base es obligatoria cuando se establece una unidad de venta predeterminada.",
+  "catalog.products.uom.errors.baseRequiredForConversions": "La unidad base es obligatoria cuando hay conversiones configuradas.",
+  "catalog.products.uom.errors.defaultSalesConversionRequired": "Se requiere una conversión activa para la unidad de venta predeterminada cuando difiere de la unidad base.",
+  "catalog.products.uom.errors.duplicateConversion": "No se permite una unidad de conversión duplicada.",
+  "catalog.products.uom.errors.loadUnits": "No se pudieron cargar las unidades. Intente actualizar la página.",
+  "catalog.products.uom.errors.sync": "No se pudieron sincronizar las conversiones de producto.",
+  "catalog.products.uom.loadingUnits": "Cargando unidades...",
+  "catalog.products.uom.moveDown": "Mover conversión hacia abajo",
+  "catalog.products.uom.moveUp": "Mover conversión hacia arriba",
+  "catalog.products.uom.removeConversion": "Eliminar conversión",
+  "catalog.products.uom.roundingMode": "Modo de redondeo",
+  "catalog.products.uom.roundingModeDown": "Redondeo hacia abajo",
+  "catalog.products.uom.roundingModeHalfUp": "Redondeo comercial (predeterminado)",
+  "catalog.products.uom.roundingModeUp": "Redondeo hacia arriba",
+  "catalog.products.uom.roundingScale": "Precisión de redondeo (decimales)",
+  "catalog.products.uom.selectUnit": "Seleccionar unidad",
+  "catalog.products.uom.sortOrder": "Orden",
+  "catalog.products.uom.title": "Unidades de medida",
+  "catalog.products.uom.toBaseFactor": "Factor base",
+  "catalog.products.validation.baseUnitRequired": "La unidad base es obligatoria cuando se establece una unidad de venta predeterminada.",
+  "catalog.products.validation.handleFormat": "El identificador solo puede contener letras minúsculas, dígitos, guiones o guiones bajos.",
+  "catalog.products.validation.referenceUnitRequired": "La unidad de referencia es obligatoria cuando la visualización del precio unitario está activada.",
+  "catalog.products.validation.titleRequired": "El título es obligatorio.",
   "catalog.search.badge.category": "Categoría",
   "catalog.search.badge.offer": "Oferta de canal",
   "catalog.search.badge.optionSchema": "Esquema de opciones",
   "catalog.search.badge.priceKind": "Tipo de precio",
   "catalog.search.badge.product": "Producto",
   "catalog.search.badge.tag": "Etiqueta",
+  "catalog.search.badge.unitConversion": "Conversión de unidad",
   "catalog.search.badge.variant": "Variante",
   "catalog.search.priceKind.excludingTax": "Excl. impuestos",
   "catalog.search.priceKind.includingTax": "Incl. impuestos",