fix(pedido): el mismo articulo salia repetido, una fila por ficha de proveedor

La pantalla de pedido pintaba una fila por cada ficha article_supplier,
no por articulo. CLOUDTOWN daba 98 filas para 89 articulos: cuando un
articulo tenia dos fichas del mismo proveedor (una con codigo y formato,
otra sin nada) aparecia dos veces, y la segunda caia al formato base
imprimiendo "ml" en vez del envase.

- supplierCatalogService: mergeEntriesByItem() agrupa por recipe_item_id
  y elige representante con fichaScore (preferido > codigo > formato >
  precio). Rellena huecos desde las hermanas, toma el bloque de formato
  entero de una sola ficha (no mezcla formato de una con medida de otra)
  y recoge los codigos alternativos en otherSupplierCodes.
- SupplyOrderBuilder: selector de formato por fila cuando el articulo
  tiene mas de uno, etiqueta con la medida ("Garrafa (5 L)"), DraftLine
  lleva formatId y el guardado escala el precio al formato elegido.
  Aviso ambar cuando el articulo no tiene formato de ese proveedor.
- 12 pruebas nuevas del merge.

Verificado contra datos reales: CLOUDTOWN 98 -> 89 filas.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Vy4yW6xBAtXcaSGgKybquB

Author: claude

src/modules/supply/pages/SupplyOrderBuilder.tsx

@@ -52,6 +52,10 @@ interface DraftLine {
   qty: string
   note: string
   showNote?: boolean
+  // Formato elegido en la fila. Vacío = el de la ficha del proveedor
+  // (e.purchaseFormatId). Se guarda aquí y no en el catálogo porque es una
+  // decisión del pedido que se está montando, no un dato del proveedor.
+  formatId?: string
 }
 
 // Etiqueta legible de la fuente de la sugerencia.
@@ -73,11 +77,25 @@ function formatShortOrderDate(iso: string | null): string {
 }
 
 // Unidad legible de la fila (formato "caja" o unidad base "kg").
-function unitLabel(e: SupplierCatalogEntry): string {
+// Etiqueta de la unidad de pedido. SIEMPRE con la medida cuando se conoce:
+// "bidón" no distingue dos bidones distintos, y ése es justo el error que la
+// pantalla tiene que impedir (§4.3 del encargo del 20/08).
+function unitLabel(e: SupplierCatalogEntry, formatId?: string): string {
+  const elegido = formatId
+    ? e.formats.find((f) => f.id === formatId)
+    : null
+  if (elegido) return (elegido.label ?? elegido.name ?? '').toLowerCase()
+  if (e.formatLabel) return e.formatLabel.toLowerCase()
   if (e.formatName) return e.formatName.toLowerCase()
   return e.baseUnitAbbr ?? ''
 }
 
+// Qué formato se pide en esta fila: el elegido a mano, o el de la ficha del
+// proveedor. Nunca se inventa uno cuando no hay ficha (§4.5).
+function formatoDeLaFila(e: SupplierCatalogEntry, d?: DraftLine): string {
+  return d?.formatId ?? e.purchaseFormatId ?? ''
+}
+
 export default function SupplyOrderBuilder({ onBack, onSaved }: SupplyOrderBuilderProps) {
   const { userProfile, authUserId } = useApp()
   const { activeAccountId, accountsLoading } = useActiveAccount()
@@ -192,6 +210,9 @@ export default function SupplyOrderBuilder({ onBack, onSaved }: SupplyOrderBuild
   function setNote(id: string, note: string) {
     setDraft(d => ({ ...d, [id]: { ...(d[id] ?? { qty: '', note: '' }), note } }))
   }
+  function setFormato(id: string, formatId: string) {
+    setDraft(d => ({ ...d, [id]: { ...(d[id] ?? { qty: '', note: '' }), formatId } }))
+  }
   function toggleNote(id: string) {
     setDraft(d => ({ ...d, [id]: { ...(d[id] ?? { qty: '', note: '' }), showNote: !d[id]?.showNote } }))
   }
@@ -277,15 +298,21 @@ export default function SupplyOrderBuilder({ onBack, onSaved }: SupplyOrderBuild
         const n = parseQty(draft[e.articleSupplierId]?.qty)
         if (n <= 0) continue
         const note = draft[e.articleSupplierId]?.note?.trim() || null
-        const eurPorCaja = e.lastPrice !== null ? e.lastPrice * (e.formatQtyInBase ?? 1) : null
+        // El formato que se pide puede haberse cambiado en la fila; el precio
+        // (€/unidad base) se escala por la equivalencia del formato ELEGIDO.
+        const formatIdElegido = formatoDeLaFila(e, draft[e.articleSupplierId])
+        const qtyInBaseElegido = formatIdElegido
+          ? (e.formats.find((f) => f.id === formatIdElegido)?.qtyInBase ?? e.formatQtyInBase)
+          : e.formatQtyInBase
+        const eurPorCaja = e.lastPrice !== null ? e.lastPrice * (qtyInBaseElegido ?? 1) : null
         const lineTotal = eurPorCaja !== null ? Math.round(n * eurPorCaja * 100) / 100 : null
         await createPurchaseOrderLine({
           accountId: activeAccountId,
           purchaseOrderId: order.id,
           recipeItemId: e.recipeItemId,
           productName: e.itemName,
           qtyOrdered: n,
-          purchaseFormatId: e.purchaseFormatId,
+          purchaseFormatId: formatIdElegido || null,
           estUnitPrice: eurPorCaja,
           estLineTotal: lineTotal,
           position: position++,
@@ -438,9 +465,25 @@ export default function SupplyOrderBuilder({ onBack, onSaved }: SupplyOrderBuild
                             {e.supplierCode && (
                               <span className="text-[11px] text-text-tertiary">{e.supplierCode}</span>
                             )}
+                            {/* La fila se agrupa por ARTÍCULO, pero si el proveedor
+                                tiene más de un código para él, no se esconde: es lo
+                                que el operario compara con el albarán. */}
+                            {e.otherSupplierCodes.length > 0 && (
+                              <span
+                                className="text-[11px] text-text-secondary"
+                                title={`Este proveedor tiene más de un código para este artículo: ${[e.supplierCode, ...e.otherSupplierCodes].filter(Boolean).join(', ')}`}
+                              >
+                                · también {e.otherSupplierCodes.join(', ')}
+                              </span>
+                            )}
                             {e.isPreferred && (
                               <span className="text-[10px] px-1.5 py-0.5 rounded-full bg-accent-bg text-accent">preferente</span>
                             )}
+                            {!e.purchaseFormatId && (
+                              <span className="text-[10px] px-1.5 py-0.5 rounded-full bg-warning-bg text-text-primary">
+                                sin formato de este proveedor
+                              </span>
+                            )}
                           </div>
                           {pending && (
                             <div className="text-[11px] text-accent mt-0.5 truncate">
@@ -496,9 +539,39 @@ export default function SupplyOrderBuilder({ onBack, onSaved }: SupplyOrderBuild
                               placeholder="0"
                               className="w-14 px-2 text-right text-[17px] font-medium bg-transparent text-text-primary focus:outline-none disabled:opacity-50"
                             />
-                            <div className="flex items-center px-2 bg-page border-l border-border-default text-[12px] text-text-secondary whitespace-nowrap">
-                              {unitLabel(e)}
-                            </div>
+                            {/* La unidad de pedido. Con más de un formato es un
+                                desplegable DENTRO de la fila: el formato se elige
+                                aquí, no compitiendo con el artículo en la lista
+                                (§4.2). La etiqueta lleva la medida, porque dos
+                                "cajas" del mismo artículo pueden no medir igual. */}
+                            {e.formats.length === 0 ? (
+                              // Ni ficha ni formatos: NO se inventa una unidad de
+                              // compra. Antes caía a la unidad base y escribía "ml",
+                              // que no es el formato de compra de nada (§4.5).
+                              <div
+                                title="Este proveedor no tiene formato de compra para este artículo"
+                                className="flex items-center px-2 bg-warning-bg border-l border-border-default text-[12px] text-text-primary whitespace-nowrap"
+                              >
+                                sin formato
+                              </div>
+                            ) : (e.formats.length > 1 || !e.purchaseFormatId) ? (
+                              <select
+                                value={formatoDeLaFila(e, d)}
+                                onChange={ev => setFormato(e.articleSupplierId, ev.target.value)}
+                                disabled={saving}
+                                aria-label={`En qué formato se pide ${e.itemName}`}
+                                className="px-2 bg-page border-l border-border-default text-[12px] text-text-secondary max-w-[150px] focus:outline-none disabled:opacity-50"
+                              >
+                                {!formatoDeLaFila(e, d) && <option value="">— elige formato —</option>}
+                                {e.formats.map(f => (
+                                  <option key={f.id} value={f.id}>{f.label ?? f.name ?? '(sin nombre)'}</option>
+                                ))}
+                              </select>
+                            ) : (
+                              <div className="flex items-center px-2 bg-page border-l border-border-default text-[12px] text-text-secondary whitespace-nowrap">
+                                {unitLabel(e, formatoDeLaFila(e, d))}
+                              </div>
+                            )}
                           </div>
                         </div>
 

src/modules/supply/services/supplierCatalogService.ts

@@ -34,6 +34,10 @@ export interface SupplierCatalogEntry {
   // elegir el formato que coincide con la unidad del albarán (bote vs caja). El
   // preferente sigue expuesto arriba (purchaseFormatId/formatName/formatQtyInBase).
   formats: SupplierFormatOption[]
+  // Otros códigos de ESTE proveedor para el MISMO artículo, cuando hay más de
+  // una ficha. La fila se agrupa por artículo (una fila = un artículo), pero un
+  // código que existe no se esconde: se enseña al lado del principal.
+  otherSupplierCodes: string[]
   // Stock de referencia: vacío hoy (no hay inventario); gancho para cuando exista.
   stockOnHand: number | null
   // ── Sugerencia de repedido (motor suggest_purchase_qty) ──
@@ -136,6 +140,64 @@ export function formatStockForOrder(
   return formatBaseQty(stockOnHand, baseAbbr)
 }
 
+// Prioridad para elegir qué ficha representa al artículo. Nunca al azar: la
+// preferente manda, luego la que trae código (es lo que el operario compara con
+// el albarán), luego la que trae formato, luego la que trae precio.
+export function fichaScore(e: SupplierCatalogEntry): number {
+  return (e.isPreferred ? 8 : 0)
+    + (e.supplierCode ? 4 : 0)
+    + (e.purchaseFormatId ? 2 : 0)
+    + (e.lastPrice != null ? 1 : 0)
+}
+
+export function mergeEntriesByItem(list: SupplierCatalogEntry[]): SupplierCatalogEntry[] {
+  const byItem = new Map<string, SupplierCatalogEntry[]>()
+  for (const e of list) {
+    const arr = byItem.get(e.recipeItemId) ?? []
+    arr.push(e)
+    byItem.set(e.recipeItemId, arr)
+  }
+
+  const out: SupplierCatalogEntry[] = []
+  for (const grupo of byItem.values()) {
+    if (grupo.length === 1) { out.push(grupo[0]); continue }
+
+    const ordenadas = [...grupo].sort((a, b) => fichaScore(b) - fichaScore(a))
+    const jefe = ordenadas[0]
+
+    // El bloque de formato se toma ENTERO de la misma ficha: mezclar el nombre
+    // de una con la equivalencia de otra daría un formato que no existe.
+    const conFormato = ordenadas.find((e) => e.purchaseFormatId)
+    const conCodigo = ordenadas.find((e) => e.supplierCode)
+    const conPrecio = ordenadas.find((e) => e.lastPrice != null)
+    const conNombre = ordenadas.find((e) => e.supplierItemName)
+
+    const codigoElegido = jefe.supplierCode ?? conCodigo?.supplierCode ?? null
+    const otros = Array.from(new Set(
+      ordenadas
+        .map((e) => e.supplierCode)
+        .filter((c): c is string => !!c && c !== codigoElegido),
+    ))
+
+    out.push({
+      ...jefe,
+      supplierCode: codigoElegido,
+      supplierItemName: jefe.supplierItemName ?? conNombre?.supplierItemName ?? null,
+      lastPrice: jefe.lastPrice ?? conPrecio?.lastPrice ?? null,
+      isPreferred: grupo.some((e) => e.isPreferred),
+      purchaseFormatId: jefe.purchaseFormatId ?? conFormato?.purchaseFormatId ?? null,
+      formatName: jefe.purchaseFormatId ? jefe.formatName : (conFormato?.formatName ?? null),
+      formatQtyInBase: jefe.purchaseFormatId ? jefe.formatQtyInBase : (conFormato?.formatQtyInBase ?? null),
+      formatLabel: jefe.purchaseFormatId ? jefe.formatLabel : (conFormato?.formatLabel ?? null),
+      otherSupplierCodes: otros,
+    })
+  }
+
+  // Mismo orden que antes: por nombre de artículo.
+  out.sort((a, b) => a.itemName.localeCompare(b.itemName, 'es'))
+  return out
+}
+
 /**
  * Catálogo de un proveedor: todos sus article_supplier activos, con artículo,
  * código, formato (nombre+equivalencia) y precio. Ordenado por nombre de artículo.
@@ -223,13 +285,37 @@ export async function getSupplierCatalog(
       baseUnitAbbr: baseAbbr,
       formatLabel: buildFormatLabel(fmt?.name ?? null, fmt?.qty_in_base ?? null, baseAbbr),
       formats: formatsByItem.get(r.recipe_item_id as string) ?? [],
+      otherSupplierCodes: [],
       stockOnHand: null, // gancho inventario
       suggestedQty: null,
       suggestionSource: null,
       suggestionConfidence: null,
     }
   })
 
+  // ── UNA FILA POR ARTÍCULO (ENCARGO 20/08) ───────────────────────────────
+  // article_supplier puede tener VARIAS fichas del mismo artículo para el mismo
+  // proveedor: la misma referencia dada de alta dos veces, una con código y otra
+  // sin él, una con formato y otra sin asignar. La pantalla pintaba UNA FILA POR
+  // FICHA, así que el mismo artículo salía dos veces, con el mismo stock y el
+  // mismo "en camino", y el operario tenía que elegir entre filas que se llaman
+  // igual. Medido en Foodint: Cloudtown daba 98 filas para 89 artículos.
+  //
+  // Y el caso feo: "Aceite de Oliva Suave 0,4º" tenía una ficha con código y
+  // Garrafa, y otra sin código y SIN FORMATO — esa segunda caía a la unidad base
+  // y la pantalla escribía "ml", que no es un formato de compra de nada.
+  //
+  // Regla del encargo, y vale para toda la aplicación: una lista operativa se
+  // agrupa por la cosa que el usuario nombra. El cocinero pide "aceite", no
+  // "aceite-en-bidón-formato-3".
+  //
+  // NO se descarta información. Se elige una ficha representante y sus huecos se
+  // rellenan con lo que tengan las hermanas; los códigos que quedan fuera van a
+  // otherSupplierCodes para que la pantalla los diga en vez de esconderlos.
+  const mergedByItem = mergeEntriesByItem(entries)
+  entries.length = 0
+  entries.push(...mergedByItem)
+
   // Stock real del local activo (T1 inventario, vivo desde 14/06): si nos pasan
   // un locationId, leemos recipe_item_location_stock para los artículos del
   // catálogo y rellenamos stockOnHand (qty_on_hand en unidad base). Sin local,

tests/unit/modules/supply/supplierCatalogMerge.test.ts

@@ -0,0 +1,112 @@
+// Una fila por ARTÍCULO en la pantalla de pedido.
+//
+// Casos sacados del dato real de Foodint (20/08): CLOUDTOWN, S.L. daba 98
+// filas para 89 artículos, y "Aceite de Oliva Suave 0,4º" salía dos veces —
+// una con código y Garrafa, otra sin código y SIN FORMATO, que la pantalla
+// pintaba como "ml".
+
+import { describe, it, expect } from 'vitest'
+import { mergeEntriesByItem, buildFormatLabel } from '@/modules/supply/services/supplierCatalogService'
+import type { SupplierCatalogEntry } from '@/modules/supply/services/supplierCatalogService'
+
+function ficha(over: Partial<SupplierCatalogEntry>): SupplierCatalogEntry {
+  return {
+    articleSupplierId: 'as-1',
+    recipeItemId: 'item-1',
+    itemName: 'Artículo',
+    supplierCode: null,
+    supplierItemName: null,
+    lastPrice: null,
+    isPreferred: false,
+    purchaseFormatId: null,
+    formatName: null,
+    formatQtyInBase: null,
+    baseUnitAbbr: 'ml',
+    formatLabel: null,
+    formats: [],
+    otherSupplierCodes: [],
+    stockOnHand: null,
+    suggestedQty: null,
+    suggestionSource: null,
+    suggestionConfidence: null,
+    ...over,
+  }
+}
+
+describe('mergeEntriesByItem · una fila por artículo', () => {
+  it('dos fichas del mismo artículo se funden en UNA fila', () => {
+    const r = mergeEntriesByItem([
+      ficha({ articleSupplierId: 'a', supplierCode: '510101007', purchaseFormatId: 'f-garrafa', formatName: 'Garrafa', formatQtyInBase: 5000 }),
+      ficha({ articleSupplierId: 'b' }),
+    ])
+    expect(r).toHaveLength(1)
+  })
+
+  it('el caso real: la ficha SIN formato no borra el formato de la hermana', () => {
+    // Antes: la fila sin purchase_format_id caía a la unidad base -> "ml".
+    const r = mergeEntriesByItem([
+      ficha({ articleSupplierId: 'sin', supplierCode: null }),
+      ficha({ articleSupplierId: 'con', supplierCode: '510101007', purchaseFormatId: 'f-garrafa', formatName: 'Garrafa', formatQtyInBase: 5000, formatLabel: 'Garrafa (5 L)' }),
+    ])
+    expect(r[0].purchaseFormatId).toBe('f-garrafa')
+    expect(r[0].formatLabel).toBe('Garrafa (5 L)')
+    expect(r[0].supplierCode).toBe('510101007')
+  })
+
+  it('el bloque de formato se toma ENTERO de una sola ficha, sin mezclar', () => {
+    const r = mergeEntriesByItem([
+      ficha({ articleSupplierId: 'a', supplierCode: 'AAA' }),
+      ficha({ articleSupplierId: 'b', purchaseFormatId: 'f-caja', formatName: 'Caja', formatQtyInBase: 6000, formatLabel: 'Caja (6 L)' }),
+    ])
+    expect(r[0].formatName).toBe('Caja')
+    expect(r[0].formatQtyInBase).toBe(6000)
+    expect(r[0].formatLabel).toBe('Caja (6 L)')
+  })
+
+  it('un código que existe NO se esconde: va a otherSupplierCodes', () => {
+    const r = mergeEntriesByItem([
+      ficha({ articleSupplierId: 'a', supplierCode: '111', isPreferred: true }),
+      ficha({ articleSupplierId: 'b', supplierCode: '222' }),
+    ])
+    expect(r[0].supplierCode).toBe('111')
+    expect(r[0].otherSupplierCodes).toEqual(['222'])
+  })
+
+  it('la preferente manda sobre la que sólo tiene código', () => {
+    const r = mergeEntriesByItem([
+      ficha({ articleSupplierId: 'a', supplierCode: '111' }),
+      ficha({ articleSupplierId: 'b', supplierCode: '222', isPreferred: true }),
+    ])
+    expect(r[0].articleSupplierId).toBe('b')
+    expect(r[0].isPreferred).toBe(true)
+  })
+
+  it('artículos distintos NO se funden', () => {
+    const r = mergeEntriesByItem([
+      ficha({ recipeItemId: 'i1', itemName: 'Aceite' }),
+      ficha({ recipeItemId: 'i2', itemName: 'Vinagre' }),
+    ])
+    expect(r).toHaveLength(2)
+  })
+
+  it('se ordena por nombre de artículo', () => {
+    const r = mergeEntriesByItem([
+      ficha({ recipeItemId: 'i2', itemName: 'Vinagre' }),
+      ficha({ recipeItemId: 'i1', itemName: 'Aceite' }),
+    ])
+    expect(r.map(e => e.itemName)).toEqual(['Aceite', 'Vinagre'])
+  })
+})
+
+describe('buildFormatLabel · la etiqueta lleva la medida', () => {
+  it('escala mililitros a litros', () => {
+    expect(buildFormatLabel('Garrafa', 5000, 'ml')).toBe('Garrafa (5 L)')
+    expect(buildFormatLabel('Bidón', 25000, 'ml')).toBe('Bidón (25 L)')
+  })
+  it('por debajo de mil se queda en la unidad base', () => {
+    expect(buildFormatLabel('Botella', 250, 'ml')).toBe('Botella (250 ml)')
+  })
+  it('gramos a kilos', () => {
+    expect(buildFormatLabel('Caja', 4800, 'g')).toBe('Caja (4,8 kg)')
+  })
+})