ClaudeandClaude Sonnet 5.5
f231f4b887
Reine Funktionen in public/neu/auftrags-zeitleiste.js: laufende Aufträge vor erledigten (jeweils jüngste Aktivität zuerst, Storniertes zuletzt), höchstens fünf Aufträge offen, vier Fortschrittsabschnitte aus status.step, Zeilen der Zeitleiste neueste zuerst mit Datum TT.MM. und Kurztext. Test zuerst (rot: Modul fehlte), dann grün. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
133 lines
8.8 KiB
JavaScript
133 lines
8.8 KiB
JavaScript
// „Was wir zuletzt erledigt haben“ als Zeitleiste (Variante C, Pilot-Feedback 17.10.): reine Logik (Fortschritt, Reihenfolge, Gruppierung, Kürzen).
|
|
// Antwortform von GET /api/activity laut server/routes/customerData.js und services/customerProjectView.js. Der DOM-Bau steht in knAuftragsZeitleisteDom.test.js.
|
|
import { test } from 'node:test'
|
|
import assert from 'node:assert/strict'
|
|
import {
|
|
MAX_AUFTRAEGE, MAX_ZEILEN, STUFEN, fortschritt, braucheInfo, letzteAktivitaet, sortiereAuftraege, gruppiereAuftraege, kuerze,
|
|
eintragsKurztext, datumKurz, zeitleistenZeilen,
|
|
} from '../public/neu/auftrags-zeitleiste.js'
|
|
import { AUFTRAG_SCHRITTE } from '../public/neu/website-details.js'
|
|
|
|
const JETZT = new Date('2026-10-16T09:00:00Z')
|
|
const ST = {
|
|
neu: { label: 'Eingegangen', tone: 'new', step: 1 },
|
|
arbeit: { label: 'In Arbeit', tone: 'active', step: 2 },
|
|
wartet: { label: 'Wartet auf deine Rückmeldung', tone: 'waiting', step: 2 },
|
|
pruefung: { label: 'Wird geprüft', tone: 'review', step: 3 },
|
|
fertig: { label: 'Erledigt', tone: 'done', step: 4 },
|
|
pause: { label: 'Pausiert', tone: 'paused', step: 0 },
|
|
storniert: { label: 'Storniert', tone: 'stopped', step: 0 },
|
|
}
|
|
const auftrag = (nr, st, createdAt, entries = [], topic = `Thema ${nr}`) => ({ number: String(nr), topic, status: ST[st], createdAt, entries })
|
|
const eintrag = (date, text, over = {}) => ({ kind: 'online', label: 'Online erledigt', date, minutes: 15, person: 'Lena Vogel', text, ...over })
|
|
const nummern = (liste) => liste.map((a) => a.number)
|
|
|
|
/* ------------------------------------------------------------------ reine Logik --- */
|
|
|
|
test('Stufen: dieselben vier Namen wie der Fortschritt der Projektdetails', () => {
|
|
assert.deepEqual(STUFEN, ['Eingegangen', 'In Arbeit', 'Prüfung', 'Erledigt'])
|
|
assert.deepEqual(STUFEN, AUFTRAG_SCHRITTE)
|
|
})
|
|
|
|
test('Fortschritt: erreichte Abschnitte bis zum aktuellen, Stufe 0 ist leer', () => {
|
|
const stand = (step) => fortschritt({ step }).map((s) => [s.erreicht, s.aktuell])
|
|
assert.deepEqual(stand(1), [[true, true], [false, false], [false, false], [false, false]])
|
|
assert.deepEqual(stand(2), [[true, false], [true, true], [false, false], [false, false]])
|
|
assert.deepEqual(stand(3), [[true, false], [true, false], [true, true], [false, false]])
|
|
assert.deepEqual(stand(4), [[true, false], [true, false], [true, false], [true, true]])
|
|
assert.deepEqual(fortschritt({ step: 4 }).map((s) => s.name), STUFEN)
|
|
for (const leer of [0, undefined, null, 'x', -1, 9]) assert.deepEqual(fortschritt({ step: leer }).map((s) => s.erreicht), [false, false, false, false], `step ${String(leer)}`)
|
|
assert.deepEqual(fortschritt(null).map((s) => s.erreicht), [false, false, false, false])
|
|
})
|
|
|
|
test('Info vom Kunden nötig: genau der Ton „waiting“ (Status „awaiting“ des Servers)', () => {
|
|
assert.equal(braucheInfo(auftrag(1, 'wartet', '2026-10-01T00:00:00Z')), true)
|
|
for (const st of ['neu', 'arbeit', 'pruefung', 'fertig', 'pause', 'storniert']) assert.equal(braucheInfo(auftrag(1, st, '2026-10-01T00:00:00Z')), false, st)
|
|
assert.equal(braucheInfo({}), false); assert.equal(braucheInfo(null), false)
|
|
})
|
|
|
|
test('Letzte Aktivität: der jüngste Eintrag oder die Anlage des Auftrags, je nachdem, was später ist', () => {
|
|
const a = auftrag(1, 'arbeit', '2026-10-01T10:00:00Z', [eintrag('2026-10-05', 'x'), eintrag('2026-10-09', 'y'), eintrag('', 'ohne Datum')])
|
|
assert.equal(letzteAktivitaet(a), Date.parse('2026-10-09T00:00:00Z'))
|
|
assert.equal(letzteAktivitaet(auftrag(2, 'arbeit', '2026-10-12T10:00:00Z', [eintrag('2026-10-05', 'x')])), Date.parse('2026-10-12T10:00:00Z'))
|
|
assert.equal(letzteAktivitaet(auftrag(3, 'arbeit', '', [])), 0)
|
|
assert.equal(letzteAktivitaet({ entries: 'kaputt', createdAt: 'nie' }), 0)
|
|
})
|
|
|
|
test('Reihenfolge: laufende zuerst (letzte Aktivität), dann erledigte (neueste zuerst), Storniertes ganz hinten', () => {
|
|
const liste = [
|
|
auftrag(1, 'fertig', '2026-09-01T00:00:00Z', [eintrag('2026-10-14', 'fertig, aber jüngster Eintrag')]),
|
|
auftrag(2, 'arbeit', '2026-10-01T00:00:00Z', [eintrag('2026-10-03', 'alt')]),
|
|
auftrag(3, 'storniert', '2026-10-15T00:00:00Z'),
|
|
auftrag(4, 'wartet', '2026-10-02T00:00:00Z', [eintrag('2026-10-13', 'neuer')]),
|
|
auftrag(5, 'fertig', '2026-09-20T00:00:00Z', [eintrag('2026-09-25', 'älter')]),
|
|
auftrag(6, 'pause', '2026-10-04T00:00:00Z'),
|
|
auftrag(7, 'pruefung', '2026-10-05T00:00:00Z'),
|
|
auftrag(8, 'neu', '2026-10-12T00:00:00Z'),
|
|
]
|
|
assert.deepEqual(nummern(sortiereAuftraege(liste)), ['4', '8', '7', '6', '2', '1', '5', '3'])
|
|
assert.deepEqual(nummern(liste), ['1', '2', '3', '4', '5', '6', '7', '8'], 'die Eingabe bleibt unverändert')
|
|
})
|
|
|
|
test('Reihenfolge: bei gleicher Aktivität bleibt die Reihenfolge des Servers', () => {
|
|
const liste = ['9', '8', '7'].map((n) => auftrag(n, 'arbeit', '2026-10-10T00:00:00Z'))
|
|
assert.deepEqual(nummern(sortiereAuftraege(liste)), ['9', '8', '7'])
|
|
})
|
|
|
|
test('Gruppierung: höchstens fünf Aufträge sichtbar, der Rest ist „älter“', () => {
|
|
assert.equal(MAX_AUFTRAEGE, 5)
|
|
const liste = Array.from({ length: 7 }, (_, i) => auftrag(100 + i, 'arbeit', `2026-10-0${i + 1}T00:00:00Z`))
|
|
const g = gruppiereAuftraege(liste)
|
|
assert.deepEqual(nummern(g.sichtbar), ['106', '105', '104', '103', '102']); assert.deepEqual(nummern(g.aeltere), ['101', '100'])
|
|
const fuenf = gruppiereAuftraege(liste.slice(0, 5)); assert.equal(fuenf.sichtbar.length, 5); assert.deepEqual(fuenf.aeltere, [])
|
|
assert.deepEqual(gruppiereAuftraege([]), { sichtbar: [], aeltere: [] }); assert.deepEqual(gruppiereAuftraege(undefined), { sichtbar: [], aeltere: [] })
|
|
assert.equal(gruppiereAuftraege(liste, 2).aeltere.length, 5)
|
|
})
|
|
|
|
test('Gruppierung: ein erledigter Auftrag rutscht hinter laufende, auch wenn er neuer ist', () => {
|
|
const liste = [auftrag(1, 'fertig', '2026-10-15T00:00:00Z'), ...Array.from({ length: 5 }, (_, i) => auftrag(10 + i, 'arbeit', `2026-09-0${i + 1}T00:00:00Z`))]
|
|
const g = gruppiereAuftraege(liste)
|
|
assert.deepEqual(nummern(g.aeltere), ['1'])
|
|
})
|
|
|
|
test('Kürzen: die ersten n sichtbar, der Rest getrennt; Eingabe bleibt', () => {
|
|
assert.equal(MAX_ZEILEN, 3)
|
|
const a = [1, 2, 3, 4, 5]
|
|
assert.deepEqual(kuerze(a, 3), { sichtbar: [1, 2, 3], rest: [4, 5] })
|
|
assert.deepEqual(kuerze([1, 2], 3), { sichtbar: [1, 2], rest: [] })
|
|
assert.deepEqual(kuerze(undefined, 3), { sichtbar: [], rest: [] })
|
|
assert.deepEqual(a, [1, 2, 3, 4, 5])
|
|
})
|
|
|
|
test('Datum: TT.MM., mit Jahr nur wenn es nicht das laufende ist', () => {
|
|
assert.equal(datumKurz('2026-10-02', JETZT), '02.10.')
|
|
assert.equal(datumKurz('2025-12-24', JETZT), '24.12.25')
|
|
assert.equal(datumKurz('2026-10-02T08:00:00.000Z', JETZT), '02.10.')
|
|
for (const kaputt of ['', null, undefined, 'gestern', '2026-13']) assert.equal(datumKurz(kaputt, JETZT), '', String(kaputt))
|
|
})
|
|
|
|
test('Kurztext: Änderungen, freier Text oder Art der Arbeit; nie lang', () => {
|
|
assert.equal(eintragsKurztext({ kind: 'update', label: 'Website aktualisiert', changes: ['Menü angepasst'] }), 'Menü angepasst')
|
|
assert.equal(eintragsKurztext({ kind: 'update', label: 'Website aktualisiert', changes: ['Menü angepasst', 'Bilder getauscht'] }), 'Menü angepasst und 1 weitere Änderung')
|
|
assert.equal(eintragsKurztext({ kind: 'update', label: 'Website aktualisiert', changes: ['A', 'B', 'C', 'D'] }), 'A und 3 weitere Änderungen')
|
|
assert.equal(eintragsKurztext({ kind: 'online', label: 'Online erledigt', text: 'Neue Öffnungszeiten eingetragen.' }), 'Neue Öffnungszeiten eingetragen.')
|
|
assert.equal(eintragsKurztext({ kind: 'onsite', label: 'Vor Ort bei dir', text: '' }), 'Vor Ort bei dir')
|
|
assert.equal(eintragsKurztext({ kind: 'work', label: '', text: '' }), 'Arbeit am Projekt')
|
|
assert.equal(eintragsKurztext({ kind: 'online', label: 'Online erledigt', text: 'Erste Zeile\n\nZweite Zeile mit Lücken' }), 'Erste Zeile')
|
|
assert.equal(eintragsKurztext({ kind: 'online', label: 'x', text: ' viel Leerraum ' }), 'viel Leerraum')
|
|
const lang = eintragsKurztext({ kind: 'online', label: 'x', text: 'Wort '.repeat(60) })
|
|
assert.ok(lang.length <= 91 && lang.endsWith('…') && !lang.includes(' '), lang)
|
|
assert.equal(eintragsKurztext(null), 'Arbeit am Projekt')
|
|
})
|
|
|
|
test('Zeitleiste: neueste zuerst, Datum TT.MM., ohne Datum ganz unten, keine Namen und Minuten', () => {
|
|
const a = auftrag(1, 'arbeit', '2026-10-01T00:00:00Z', [
|
|
eintrag('2026-10-03', 'Alt'), eintrag('2026-10-12', 'Neu', { person: 'Kenso', minutes: 90 }), eintrag('', 'Ohne Datum'), eintrag('2026-10-07', 'Mitte'),
|
|
])
|
|
const zeilen = zeitleistenZeilen(a, JETZT)
|
|
assert.deepEqual(zeilen.map((z) => [z.datum, z.text]), [['12.10.', 'Neu'], ['07.10.', 'Mitte'], ['03.10.', 'Alt'], ['', 'Ohne Datum']])
|
|
assert.deepEqual(Object.keys(zeilen[0]).sort(), ['datum', 'iso', 'text'])
|
|
assert.equal(zeilen[0].iso, '2026-10-12')
|
|
assert.deepEqual(zeitleistenZeilen({ entries: null }, JETZT), []); assert.deepEqual(zeitleistenZeilen(null, JETZT), [])
|
|
})
|