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.
2026-07-29 09:05:23 +02:00
parent 661bd07a26
commit 61dde3eb08
4 changed files with 221 additions and 10 deletions
@@ -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());
@@ -244,6 +244,61 @@ test('nextEntryId als Null liefert null', () => {
  assert.equal(loadSession(store), null);
 });

+// --- Erweiterung: Barcode-Inhalte je Stapel ueberleben Sichern und Laden ---
+
+test('Codes eines Stapels ueberleben Sichern und Laden', () => {
+  const store = fakeStore();
+  const session = createSession();
+  commitAssignment(
+    session,
+    { ...emptySpec(), partNumber: 'HMA84GL7AFR4N-UH' },
+    'barcode',
+    'A',
+    ['HMA84GL7AFR4N-UH', 'SN-000'],
+  );
+  saveSession(session, store);
+
+  const reloaded = loadSession(store);
+  assert.notEqual(reloaded, null);
+  assert.deepEqual([...reloaded.stacks[0].codes].sort(), ['HMA84GL7AFR4N-UH', 'SN-000'].sort());
+
+  const plan = proposeAssignment(reloaded, emptySpec(), ['HMA84GL7AFR4N-UH']);
+  assert.equal(plan.kind, 'match');
+  assert.equal(plan.stackId, 'A');
+});
+
+test('ein Stand ohne codes-Feld (aeltere Fassung) wird nicht verworfen, der Stapel gilt als ohne bekannte Codes', () => {
+  const store = fakeStore();
+  store.setItem('ram-sortierhilfe:session', JSON.stringify({
+    stacks: [{ id: 'A', count: 1, spec: { ...emptySpec(), capacityGb: 64 } }],
+    entries: [{ entryId: 1, stackId: 'A', spec: { ...emptySpec(), capacityGb: 64 }, source: 'barcode' }],
+    nextEntryId: 2,
+  }));
+  const reloaded = loadSession(store);
+  assert.notEqual(reloaded, null, 'ein Stand ohne codes-Feld darf nicht verworfen werden');
+  assert.deepEqual(reloaded.stacks[0].codes, []);
+});
+
+test('Stapel mit codes als Nicht-Array liefert null', () => {
+  const store = fakeStore();
+  store.setItem('ram-sortierhilfe:session', JSON.stringify({
+    stacks: [{ id: 'A', count: 0, spec: emptySpec(), codes: 'nicht-array' }],
+    entries: [],
+    nextEntryId: 1,
+  }));
+  assert.equal(loadSession(store), null);
+});
+
+test('Stapel mit codes-Array, das Nicht-Zeichenketten enthaelt, liefert null', () => {
+  const store = fakeStore();
+  store.setItem('ram-sortierhilfe:session', JSON.stringify({
+    stacks: [{ id: 'A', count: 0, spec: emptySpec(), codes: [123] }],
+    entries: [],
+    nextEntryId: 1,
+  }));
+  assert.equal(loadSession(store), null);
+});
+
 test('Eintrag mit gebrochener entryId liefert null', () => {
  const store = fakeStore();
  store.setItem('ram-sortierhilfe:session', JSON.stringify({