Stapel merken sich gelesene Barcode-Inhalte, entscheiden die Zuordnung

Jeder Stapel fuehrt jetzt die Menge der Barcode-Zeichenketten, die bei
seinen Modulen gelesen wurden (stack.codes). Traegt ein gescanntes Modul
einen Code, den ein Stapel bereits kennt, hat das Vorrang vor dem Vergleich
der technischen Angaben - ein Barcode ist exakt gelesen, abgeleitete Angaben
koennen fehlerbehaftet sein. Genau ein Stapel ueber einen bekannten Code
-> Zuweisung, auch bei unvollstaendigen Angaben; mehrere -> weiterhin
mehrdeutig, der Nutzer entscheidet; kein passender Code -> unveraendert die
bisherige Regel. Eine Seriennummer, die bei jedem Modul anders ist, laeuft
dabei einfach ins Leere, ohne die Zuordnung ueber die Teilenummer zu
verhindern.

proposeAssignment und commitAssignment bekommen dafuer einen neuen, optional
en codes-Parameter (Vorgabe []); bestehende Aufrufe ohne diesen Parameter
verhalten sich unveraendert.

storage.js sichert und prueft stack.codes jetzt mit: fehlt das Feld (Stand
aus einer aelteren Fassung), gilt der Stapel als ohne bekannte Codes statt
den ganzen Stand zu verwerfen; ist es vorhanden, muss es eine Liste von
Zeichenketten sein wie jedes andere Feld auch.

test/session.test.js

@@ -158,6 +158,89 @@ test('ein voellig unerkanntes Modul erzeugt einen eigenen Stapel und zieht keine
   assert.equal(plan.kind, 'new', 'der leere Stapel darf ein erkanntes Modul nicht an sich ziehen');
 });
 
+// --- Erweiterung: bekannte Barcode-Inhalte entscheiden die Zuordnung ---
+
+test('bekannter Barcode-Inhalt entscheidet die Zuordnung, auch bei unvollstaendigen Angaben', () => {
+  const session = createSession();
+  const unknownScheme = { ...emptySpec(), partNumber: 'HMA84GL7AFR4N-UH' };
+  commitAssignment(session, unknownScheme, 'barcode', 'A', ['HMA84GL7AFR4N-UH']);
+
+  // Angaben diesmal komplett leer - ohne Codeabgleich waere das mangels
+  // gemeinsamen Merkmals (sharesSetField) niemals ein Treffer.
+  const plan = proposeAssignment(session, emptySpec(), ['HMA84GL7AFR4N-UH']);
+  assert.equal(plan.kind, 'match');
+  assert.equal(plan.stackId, 'A');
+});
+
+test('anderer Barcode-Inhalt erzeugt einen eigenen Stapel', () => {
+  const session = createSession();
+  commitAssignment(session, { ...emptySpec(), partNumber: 'HMA84GL7AFR4N-UH' }, 'barcode', 'A', ['HMA84GL7AFR4N-UH']);
+  const plan = proposeAssignment(session, { ...emptySpec(), partNumber: 'ANDERE-PN' }, ['ANDERE-PN']);
+  assert.equal(plan.kind, 'new');
+  assert.notEqual(plan.stackId, 'A');
+});
+
+test('eine bei jedem Modul wechselnde Seriennummer verhindert die Zuordnung ueber die stabile Teilenummer nicht', () => {
+  const session = createSession();
+  commitAssignment(
+    session,
+    { ...emptySpec(), partNumber: 'HMA84GL7AFR4N-UH' },
+    'barcode',
+    'A',
+    ['HMA84GL7AFR4N-UH', 'SN-AAA111'],
+  );
+  // Gleiche Teilenummer, aber eine andere Seriennummer als beim ersten Mal -
+  // die Seriennummer laeuft ins Leere, die Teilenummer traegt trotzdem.
+  const plan = proposeAssignment(session, emptySpec(), ['HMA84GL7AFR4N-UH', 'SN-BBB222']);
+  assert.equal(plan.kind, 'match');
+  assert.equal(plan.stackId, 'A');
+});
+
+test('Codeabgleich hat Vorrang vor dem Vergleich der technischen Angaben', () => {
+  const session = createSession();
+  // B ist technisch identisch zu A (waere ohne Codeabgleich ebenfalls
+  // Kandidat und wuerde damit sogar Mehrdeutigkeit ausloesen), kennt den
+  // gescannten Code aber nicht.
+  commitAssignment(session, s64(), 'barcode', 'A', ['CODE-A']);
+  commitAssignment(session, s64(), 'barcode', 'B');
+  const plan = proposeAssignment(session, s64(), ['CODE-A']);
+  assert.equal(plan.kind, 'match');
+  assert.equal(plan.stackId, 'A');
+});
+
+test('mehrere Stapel mit passendem Code sind mehrdeutig, der Nutzer entscheidet', () => {
+  const session = createSession();
+  commitAssignment(session, emptySpec(), 'barcode', 'A', ['CODE-X']);
+  commitAssignment(session, emptySpec(), 'barcode', 'B', ['CODE-X']);
+  const plan = proposeAssignment(session, emptySpec(), ['CODE-X']);
+  assert.equal(plan.kind, 'ambiguous');
+  assert.deepEqual(plan.candidates.sort(), ['A', 'B']);
+});
+
+test('passt kein Code, bleibt die bisherige Regel (Vergleich der Angaben) unveraendert', () => {
+  const session = createSession();
+  commitAssignment(session, s64(), 'barcode', 'A', ['CODE-A']);
+  const plan = proposeAssignment(session, s64(), ['VOELLIG-ANDERER-CODE']);
+  assert.equal(plan.kind, 'match');
+  assert.equal(plan.stackId, 'A');
+});
+
+test('proposeAssignment und commitAssignment funktionieren ohne codes-Parameter weiterhin (Abwaertskompatibilitaet)', () => {
+  const session = createSession();
+  const plan = proposeAssignment(session, s64());
+  const entry = commitAssignment(session, s64(), 'barcode', plan.stackId);
+  assert.equal(entry.stackId, 'A');
+  assert.deepEqual(session.stacks[0].codes, []);
+});
+
+test('ein Stapel sammelt unterschiedliche Codes ueber mehrere Scans hinweg', () => {
+  const session = createSession();
+  commitAssignment(session, emptySpec(), 'barcode', 'A', ['CODE-1']);
+  commitAssignment(session, emptySpec(), 'barcode', 'A', ['CODE-1', 'CODE-2']);
+  const stackA = session.stacks.find((s) => s.id === 'A');
+  assert.deepEqual([...stackA.codes].sort(), ['CODE-1', 'CODE-2']);
+});
+
 test('undoLast-Vertrag: nach einem Umsortieren wird weiterhin der zuletzt erfasste Eintrag zurueckgenommen', () => {
   const session = createSession();
   const a = scan(session, s64());