diff --git a/src/automats/index.js b/src/automats/index.js
index ddde60d..a2cd1a0 100644
--- a/src/automats/index.js
+++ b/src/automats/index.js
@@ -88,7 +88,17 @@ export { default as customergroupAutomat } from './customergroupAutomat';
export { default as numberAutomat } from './numberAutomat';
export { default as accountAutomat } from './accountAutomat';
export { default as backupAutomat } from './backupAutomat';
-export { default as shipmentAutomat } from './shipmentAutomat';
+export {
+ default as shipmentAutomat,
+ CHUNK_SIZE as SHIPMENT_CHUNK_SIZE,
+ selectShipments,
+ selectShipmentTotal,
+ selectShipmentUnfilteredTotal,
+ selectShipmentPagination,
+ selectStateFilter,
+ getChunkStats as getShipmentChunkStats,
+ subscribeChunkStats as subscribeShipmentChunkStats,
+} from './shipmentAutomat';
export { createListAutomat, selectListItems, selectListStatus } from './createListAutomat';
diff --git a/src/automats/shipmentAutomat.js b/src/automats/shipmentAutomat.js
index 0be4777..a56ddc8 100644
--- a/src/automats/shipmentAutomat.js
+++ b/src/automats/shipmentAutomat.js
@@ -1,18 +1,18 @@
/**
* @file shipmentAutomat.js
- * @description Manages cached and paginated company shipment manifests (Lieferscheine) (`GET /api/shipment`).
+ * @description Manages cached and chunk-paginated company shipment manifests (`GET /api/shipment`).
+ *
+ * Implements a multi-filter chunk cache identical to `orderAutomat`:
+ * - Each filter combination has its own isolated cache entry (total, unfilteredTotal, items array, loadedChunks).
+ * - Total chunk capacity across all filter combinations is bounded by a global LRU limit of 50 chunks.
+ * - When filter settings change, previously loaded chunks remain cached in memory up to the 50-chunk limit.
+ * - Switching back to a previously used filter is instant with zero network requests if its chunks are in RAM.
+ * - Supports chunked pagination via `requireChunk(chunkIndex)` and `loadChunk(chunkIndex)`.
*
* Upstream Triggers:
* - `authAutomat`: Triggers `actions.reset()` on `'anon'` or when `selectedCompanyId` changes.
- * - `sseAutomat`: Triggers `actions.reload()` on `'shipment'` SSE events.
- *
- * Actions:
- * - `load()`: Fetches shipments with current filters.
- * - `reload()`: Silently re-fetches shipments.
- * - `setFilter(filter)`: Updates free-text search filter.
- * - `setStateFilter(state)`: Updates delivery state filter ('', 'new', 'delivered', 'returned').
- * - `updateState(id, state)`: Calls `PATCH /api/shipment/:id` and updates local cache.
- * - `deleteShipment(id)`: Calls `DELETE /api/shipment/:id` and removes from local cache.
+ * - `sseAutomat`: Triggers `actions.reload()` on `'shipment'` and `'order'` SSE events.
+ * - UI / Routes: Calls `getItems()`, `requireChunk(chunkIndex)`, `loadChunk(chunkIndex)`, or `reload()`.
*/
import { Automat } from 'react-automat';
@@ -41,17 +41,23 @@ import orderAutomat from './orderAutomat';
/**
* @typedef {Object} ShipmentAutomatState
- * @property {ShipmentSummary[]|null} items
- * @property {number} total
- * @property {number} unfilteredTotal
- * @property {string} filter
- * @property {string} stateFilter
- * @property {number} seekMonths
- * @property {number} seekYears
- * @property {'idle'|'loading'|'ready'|'failed'} status
- * @property {Error|string|null} error
+ * @property {ShipmentSummary[]|null} items Pre-filled array of shipments/nulls, initially null.
+ * @property {number} total Total unpaged count for pagination calculation.
+ * @property {number} unfilteredTotal Unfiltered total count.
+ * @property {string} filter Search term.
+ * @property {string} stateFilter Delivery state filter ('', 'new', 'delivered', 'returned').
+ * @property {number} seekMonths Seek month count.
+ * @property {number} seekYears Seek year count.
+ * @property {number} negativeSeekMonths Negative seek months offset.
+ * @property {'idle'|'loading'|'ready'|'failed'} status Load lifecycle state.
+ * @property {Error|string|null} error Last load error.
*/
+export const CHUNK_SIZE = 50;
+export const MAX_LRU_CHUNKS = 50;
+const PREFETCH_CHUNKS = 1;
+const CHUNK_DEBOUNCE_MS = 130;
+
const initialState = {
items: null,
total: 0,
@@ -60,192 +66,1008 @@ const initialState = {
stateFilter: '',
seekMonths: 0,
seekYears: 0,
+ negativeSeekMonths: 0,
status: 'idle',
error: null,
};
let automat;
-let inflightLoad = null;
-let debounceTimer = null;
+let queryEpoch = 0;
+let filterDebounceTimer = null;
+let chunkDebounceTimer = null;
+let currentEventTick = 0;
+let lastRequireChunkTick = -1;
-// #region fetch helper
-async function fetchShipments(state) {
- const params = {
- limit: 100,
+const pendingTargetChunks = new Set();
+let pendingChunkPromise = null;
+let pendingChunkResolve = null;
+let pendingChunkReject = null;
+
+// Multi-Filter Cache & Global LRU Management
+const filterCaches = new Map();
+const lruChunks = new Map();
+const inflightChunks = new Map();
+
+// Dev / Observability: Chunk event history and subscriber registry
+const MAX_CHUNK_EVENTS = 150;
+let nextEventId = 0;
+const chunkEvents = [];
+const chunkStatsListeners = new Set();
+
+export function makeLruKey(filterKey, chunkIndex) {
+ return `${filterKey}:::${chunkIndex}`;
+}
+
+export function parseLruKey(key) {
+ const [filterKey, chunkStr] = key.split(':::');
+ return { filterKey, chunkIndex: Number(chunkStr) };
+}
+
+// MARK: pure filter helpers
+export function getFilterParams(state = automat?.state || initialState) {
+ const filter = String(state.filter ?? '').trim();
+ const stateFilter = String(state.stateFilter ?? '').trim();
+ const negativeSeekMonths = (state.negativeSeekMonths != null && Number(state.negativeSeekMonths) < 0)
+ ? Number(state.negativeSeekMonths)
+ : 0;
+ return { filter, stateFilter, negativeSeekMonths };
+}
+
+export function getFilterKey(state = automat?.state || initialState) {
+ const { filter, stateFilter, negativeSeekMonths } = getFilterParams(state);
+ return JSON.stringify({ f: filter, st: stateFilter, s: negativeSeekMonths });
+}
+
+export function formatNegativeSeek(months) {
+ if (!months || months >= 0) return '';
+ const total = Math.abs(months);
+ const years = Math.floor(total / 12);
+ const remMonths = total % 12;
+ const parts = [];
+ if (years > 0) {
+ parts.push(`${years} ${years === 1 ? 'Jahr' : 'Jahre'}`);
+ }
+ if (remMonths > 0) {
+ parts.push(`${remMonths} ${remMonths === 1 ? 'Monat' : 'Monate'}`);
+ }
+ return `-${parts.join(' ')}`;
+}
+
+export function formatFilterLabel(filterKeyOrState) {
+ let f, st, s;
+ if (typeof filterKeyOrState === 'string') {
+ try {
+ const parsed = JSON.parse(filterKeyOrState);
+ f = parsed.f;
+ st = parsed.st;
+ s = parsed.s;
+ } catch {
+ return filterKeyOrState;
+ }
+ } else if (filterKeyOrState && typeof filterKeyOrState === 'object') {
+ if ('f' in filterKeyOrState) {
+ f = filterKeyOrState.f;
+ st = filterKeyOrState.st;
+ s = filterKeyOrState.s;
+ } else {
+ const params = getFilterParams(filterKeyOrState);
+ f = params.filter;
+ st = params.stateFilter;
+ s = params.negativeSeekMonths;
+ }
+ }
+
+ const parts = [];
+ if (f) parts.push(`Suche: „${f}“`);
+ if (st) parts.push(`Status: ${st}`);
+ if (s < 0) parts.push(`Seek: ${formatNegativeSeek(s)}`);
+ if (parts.length === 0) return 'Standard (Alle Lieferscheine)';
+ return parts.join(' · ');
+}
+
+function countNonNullItems(items) {
+ if (!Array.isArray(items)) return 0;
+ let count = 0;
+ for (let i = 0; i < items.length; i++) {
+ if (items[i] != null) count++;
+ }
+ return count;
+}
+
+function getOrCreateFilterCache(filterKey, filterState = automat?.state || initialState) {
+ let entry = filterCaches.get(filterKey);
+ if (!entry) {
+ const params = getFilterParams(filterState);
+ entry = {
+ key: filterKey,
+ label: formatFilterLabel(params),
+ params,
+ total: 0,
+ unfilteredTotal: automat?.state?.unfilteredTotal || 0,
+ items: null,
+ loadedChunks: new Set(),
+ status: 'idle',
+ error: null,
+ lastAccessed: Date.now(),
+ epoch: queryEpoch,
+ };
+ filterCaches.set(filterKey, entry);
+ }
+ return entry;
+}
+
+function touchChunkLRU(filterKey, chunkIndex) {
+ const key = makeLruKey(filterKey, chunkIndex);
+ const existing = lruChunks.get(key);
+ if (existing) {
+ lruChunks.delete(key);
+ lruChunks.set(key, { ...existing, accessedAt: Date.now() });
+ }
+}
+
+function registerChunkLRU(filterKey, chunkIndex, shipmentCount = 0) {
+ const key = makeLruKey(filterKey, chunkIndex);
+ if (lruChunks.has(key)) {
+ lruChunks.delete(key);
+ }
+ const now = Date.now();
+ lruChunks.set(key, {
+ filterKey,
+ chunkIndex,
+ loadedAt: now,
+ accessedAt: now,
+ shipmentCount,
+ });
+
+ while (lruChunks.size > MAX_LRU_CHUNKS) {
+ const oldestKey = lruChunks.keys().next().value;
+ const oldestInfo = lruChunks.get(oldestKey);
+ lruChunks.delete(oldestKey);
+ if (oldestInfo) {
+ evictChunkFromMemory(oldestInfo.filterKey, oldestInfo.chunkIndex, 'lru');
+ }
+ }
+}
+
+function evictChunkFromMemory(filterKey, chunkIndex, reason = 'manual') {
+ const entry = filterCaches.get(filterKey);
+ if (!entry) return;
+
+ if (entry.loadedChunks.has(chunkIndex)) {
+ entry.loadedChunks.delete(chunkIndex);
+ if (Array.isArray(entry.items)) {
+ const offset = chunkIndex * CHUNK_SIZE;
+ for (let i = offset; i < offset + CHUNK_SIZE && i < entry.items.length; i++) {
+ entry.items[i] = null;
+ }
+ }
+
+ const currentKey = getFilterKey(automat.state);
+ if (filterKey === currentKey) {
+ automat.setState({ items: [...entry.items] });
+ }
+
+ const eventType = reason === 'lru' ? 'lru_evict' : 'evict';
+ const msg = reason === 'lru'
+ ? `LRU-Eviction: Chunk #${chunkIndex} von Filter "${entry.label}" verworfen (${lruChunks.size}/${MAX_LRU_CHUNKS} im Cache)`
+ : `Chunk #${chunkIndex} von Filter "${entry.label}" verworfen`;
+
+ recordChunkEvent({
+ type: eventType,
+ chunkIndex,
+ filterKey,
+ message: msg,
+ });
+ notifyChunkStats();
+ }
+}
+
+function recordChunkEvent(entry) {
+ const event = {
+ id: ++nextEventId,
+ time: Date.now(),
+ epoch: queryEpoch,
+ filterKey: entry.filterKey ?? getFilterKey(automat?.state),
+ ...entry,
};
- if (state.filter && state.filter.trim()) {
- params.search = state.filter.trim();
+ chunkEvents.push(event);
+ if (chunkEvents.length > MAX_CHUNK_EVENTS) {
+ chunkEvents.shift();
}
- if (state.stateFilter) {
- params.state = state.stateFilter;
+ notifyChunkStats();
+}
+
+function notifyChunkStats() {
+ if (chunkStatsListeners.size === 0) return;
+ const stats = getChunkStats();
+ for (const listener of chunkStatsListeners) {
+ try {
+ listener(stats);
+ } catch (e) {
+ console.error('[shipmentAutomat] chunkStatsListener error', e);
+ }
}
- const totalMonths = (state.seekMonths || 0) + (state.seekYears || 0) * 12;
- if (totalMonths > 0) {
- params.seekMonths = totalMonths;
+}
+
+export function getChunkStats() {
+ const currentKey = getFilterKey(automat?.state);
+ const activeEntry = filterCaches.get(currentKey);
+
+ const total = activeEntry?.total ?? automat?.state?.total ?? 0;
+ const activeLoaded = activeEntry?.loadedChunks ?? new Set();
+ const chunkCount = total > 0 ? Math.ceil(total / CHUNK_SIZE) : (activeLoaded.size > 0 ? Math.max(...activeLoaded) + 1 : 0);
+ const items = activeEntry?.items ?? automat?.state?.items;
+ const loadedItemsCount = countNonNullItems(items);
+
+ const cachedFiltersSummary = Array.from(filterCaches.values()).map((entry) => ({
+ key: entry.key,
+ label: entry.label,
+ params: entry.params,
+ total: entry.total,
+ loadedChunksCount: entry.loadedChunks.size,
+ loadedChunks: Array.from(entry.loadedChunks).sort((a, b) => a - b),
+ chunkCount: entry.total > 0 ? Math.ceil(entry.total / CHUNK_SIZE) : (entry.loadedChunks.size > 0 ? Math.max(...entry.loadedChunks) + 1 : 0),
+ loadedItemsCount: countNonNullItems(entry.items),
+ lastAccessed: entry.lastAccessed,
+ isActive: entry.key === currentKey,
+ status: entry.status,
+ items: entry.items,
+ }));
+
+ const lruEntries = Array.from(lruChunks.entries()).map(([key, info], idx) => ({
+ lruKey: key,
+ filterKey: info.filterKey,
+ filterLabel: filterCaches.get(info.filterKey)?.label || info.filterKey,
+ chunkIndex: info.chunkIndex,
+ loadedAt: info.loadedAt,
+ accessedAt: info.accessedAt,
+ shipmentCount: info.shipmentCount,
+ lruRank: idx + 1,
+ }));
+
+ const activeInflight = [];
+ for (const key of inflightChunks.keys()) {
+ if (key.startsWith(`${currentKey}:::`)) {
+ const parsed = parseLruKey(key);
+ activeInflight.push(parsed.chunkIndex);
+ }
}
- const res = await shipmentApi.list(params);
return {
- items: res?.shipments || [],
- total: res?.total ?? (res?.shipments?.length || 0),
- unfilteredTotal: res?.unfilteredTotal ?? res?.total ?? (res?.shipments?.length || 0),
+ automatName: 'shipment',
+ chunkSize: CHUNK_SIZE,
+ maxLruChunks: MAX_LRU_CHUNKS,
+ lruChunksCount: lruChunks.size,
+ total,
+ chunkCount,
+ loadedChunks: Array.from(activeLoaded).sort((a, b) => a - b),
+ inflightChunks: activeInflight.sort((a, b) => a - b),
+ pendingChunks: Array.from(pendingTargetChunks).sort((a, b) => a - b),
+ loadedItemsCount,
+ status: automat?.state?.status ?? 'idle',
+ queryEpoch,
+ filter: automat?.state?.filter ?? '',
+ stateFilter: automat?.state?.stateFilter ?? '',
+ seekMonths: automat?.state?.seekMonths ?? 0,
+ seekYears: automat?.state?.seekYears ?? 0,
+ negativeSeekMonths: automat?.state?.negativeSeekMonths ?? 0,
+ items,
+ activeFilterKey: currentKey,
+ activeFilterLabel: formatFilterLabel(currentKey),
+ filterCaches: cachedFiltersSummary,
+ lruEntries,
+ events: [...chunkEvents],
};
}
-// #endregion
+
+export function subscribeChunkStats(listener) {
+ chunkStatsListeners.add(listener);
+ try {
+ listener(getChunkStats());
+ } catch (e) {
+ console.error(e);
+ }
+ return () => {
+ chunkStatsListeners.delete(listener);
+ };
+}
+
+function clearChunkDebounce() {
+ if (chunkDebounceTimer) {
+ clearTimeout(chunkDebounceTimer);
+ chunkDebounceTimer = null;
+ }
+ if (pendingTargetChunks.size > 0) {
+ pendingTargetChunks.clear();
+ notifyChunkStats();
+ }
+ pendingChunkPromise = null;
+ pendingChunkResolve = null;
+ pendingChunkReject = null;
+}
+
+function _executeRequiredChunks(chunks, targetEpoch, prefetch = true, targetFilterKey = getFilterKey(automat.state)) {
+ if (targetEpoch !== queryEpoch) {
+ return Promise.resolve(automat.state.items);
+ }
+
+ const chunkList = Array.from(chunks).sort((a, b) => a - b);
+ if (chunkList.length === 0) {
+ return Promise.resolve(automat.state.items);
+ }
+
+ recordChunkEvent({
+ type: 'execute',
+ chunks: chunkList,
+ filterKey: targetFilterKey,
+ message: `Lade Chunks [${chunkList.join(', ')}] für "${formatFilterLabel(targetFilterKey)}" (Epoch ${targetEpoch})`,
+ });
+
+ const promises = [];
+ for (const c of chunkList) {
+ promises.push(actions.loadChunk(c, targetEpoch, targetFilterKey));
+ }
+
+ return Promise.all(promises).then(() => {
+ if (targetEpoch !== queryEpoch) return automat.state.items;
+ if (prefetch) {
+ const maxChunk = chunkList[chunkList.length - 1];
+ const entry = filterCaches.get(targetFilterKey);
+ const total = entry?.total || automat.state.total || 0;
+ for (let c = maxChunk + 1; c <= maxChunk + PREFETCH_CHUNKS; c++) {
+ if (total > 0 && c * CHUNK_SIZE >= total) {
+ break;
+ }
+ recordChunkEvent({
+ type: 'prefetch',
+ chunkIndex: c,
+ filterKey: targetFilterKey,
+ message: `Prefetch Chunk #${c} für "${formatFilterLabel(targetFilterKey)}"`,
+ });
+ void actions.loadChunk(c, targetEpoch, targetFilterKey);
+ }
+ }
+ return automat.state.items;
+ });
+}
+
+function buildQueryParamsFor(filterParams, offset = 0, limit = CHUNK_SIZE) {
+ const params = { offset, limit };
+ const trimmed = String(filterParams.filter ?? '').trim();
+ if (trimmed) params.search = trimmed;
+ if (filterParams.stateFilter) params.state = filterParams.stateFilter;
+ if (filterParams.negativeSeekMonths != null && Number(filterParams.negativeSeekMonths) < 0) {
+ params.seekMonths = Number(filterParams.negativeSeekMonths);
+ }
+ return params;
+}
+
+async function fetchShipmentsPageFor(filterParams, offset = 0, limit = CHUNK_SIZE) {
+ const params = buildQueryParamsFor(filterParams, offset, limit);
+ const res = await shipmentApi.list(params);
+ const shipments = Array.isArray(res?.shipments) ? res.shipments : [];
+ const total = Number(res?.total ?? shipments.length);
+ const unfilteredTotal = res?.unfilteredTotal != null ? Number(res.unfilteredTotal) : total;
+ return { shipments, total, unfilteredTotal };
+}
+
+function onFilterChange(immediate = false) {
+ if (filterDebounceTimer) {
+ clearTimeout(filterDebounceTimer);
+ filterDebounceTimer = null;
+ }
+ if (immediate) {
+ applyFilterReload();
+ } else {
+ filterDebounceTimer = setTimeout(() => {
+ filterDebounceTimer = null;
+ applyFilterReload();
+ }, 200);
+ }
+}
+
+function applyFilterReload() {
+ queryEpoch++;
+ clearChunkDebounce();
+
+ const currentKey = getFilterKey(automat.state);
+ const cached = filterCaches.get(currentKey);
+
+ if (cached && cached.items !== null) {
+ cached.lastAccessed = Date.now();
+ for (const c of cached.loadedChunks) {
+ touchChunkLRU(currentKey, c);
+ }
+
+ automat.setState({
+ items: cached.items,
+ total: cached.total,
+ unfilteredTotal: cached.unfilteredTotal ?? automat.state.unfilteredTotal ?? 0,
+ status: cached.status || 'ready',
+ error: cached.error || null,
+ });
+
+ recordChunkEvent({
+ type: 'filter_hit',
+ epoch: queryEpoch,
+ filterKey: currentKey,
+ message: `Filter gewechselt: "${cached.label}" (Cache-Hit: ${cached.loadedChunks.size} Chunks / ${countNonNullItems(cached.items)} Lieferscheine im RAM)`,
+ });
+ notifyChunkStats();
+
+ if (!cached.loadedChunks.has(0)) {
+ void actions.loadChunk(0, queryEpoch, currentKey);
+ }
+ } else {
+ const entry = getOrCreateFilterCache(currentKey, automat.state);
+ entry.lastAccessed = Date.now();
+
+ automat.setState({
+ items: null,
+ total: 0,
+ unfilteredTotal: automat.state.unfilteredTotal ?? 0,
+ status: 'loading',
+ error: null,
+ });
+
+ recordChunkEvent({
+ type: 'filter_miss',
+ epoch: queryEpoch,
+ filterKey: currentKey,
+ message: `Filter gewechselt: "${entry.label}" (Cache-Miss: Lade Chunk #0)`,
+ });
+ notifyChunkStats();
+
+ void actions.loadChunk(0, queryEpoch, currentKey);
+ }
+}
const actions = {
- // #region load & reload
- async load() {
- if (inflightLoad) return inflightLoad;
+ getItems() {
+ if (automat.state.items === null) {
+ void actions.requireChunk(0, 0, { prefetch: false, immediate: true });
+ return null;
+ }
+ return automat.state.items;
+ },
- automat.setState((s) => ({
- status: s.items === null ? 'loading' : s.status,
- error: null,
- }));
+ requireChunk(chunkIndex, endOrOptions = chunkIndex, maybeOptions = {}) {
+ let start;
+ let end;
+ let options = {};
- inflightLoad = (async () => {
- try {
- const { items, total, unfilteredTotal } = await fetchShipments(automat.state);
+ if (Array.isArray(chunkIndex)) {
+ start = chunkIndex[0] ?? 0;
+ end = chunkIndex[chunkIndex.length - 1] ?? start;
+ if (typeof endOrOptions === 'object' && endOrOptions !== null) {
+ options = endOrOptions;
+ }
+ } else {
+ start = Number(chunkIndex) || 0;
+ if (typeof endOrOptions === 'object' && endOrOptions !== null) {
+ end = start;
+ options = endOrOptions;
+ } else {
+ end = Number(endOrOptions ?? start) || start;
+ if (typeof maybeOptions === 'object' && maybeOptions !== null) {
+ options = maybeOptions;
+ }
+ }
+ }
+
+ start = Math.max(0, Math.floor(start));
+ end = Math.max(start, Math.floor(end));
+ const prefetch = options.prefetch !== false;
+ const currentKey = getFilterKey(automat.state);
+
+ if (options.immediate || automat.state.items === null) {
+ clearChunkDebounce();
+ const chunks = new Set();
+ for (let c = start; c <= end; c++) chunks.add(c);
+ recordChunkEvent({
+ type: 'require_immediate',
+ chunks: Array.from(chunks),
+ filterKey: currentKey,
+ message: `Sofortige Anforderung: Chunks ${start}..${end} (${formatFilterLabel(currentKey)})`,
+ });
+ return _executeRequiredChunks(chunks, queryEpoch, prefetch, currentKey);
+ }
+
+ if (lastRequireChunkTick !== currentEventTick) {
+ pendingTargetChunks.clear();
+ lastRequireChunkTick = currentEventTick;
+ if (typeof queueMicrotask === 'function') {
+ queueMicrotask(() => {
+ currentEventTick++;
+ });
+ } else {
+ Promise.resolve().then(() => {
+ currentEventTick++;
+ });
+ }
+ }
+
+ for (let c = start; c <= end; c++) {
+ pendingTargetChunks.add(c);
+ }
+ recordChunkEvent({
+ type: 'pending',
+ chunks: Array.from(pendingTargetChunks),
+ filterKey: currentKey,
+ message: `Debounce vorgemerkt (${CHUNK_DEBOUNCE_MS}ms): Chunks [${Array.from(pendingTargetChunks).join(', ')}]`,
+ });
+ notifyChunkStats();
+
+ if (chunkDebounceTimer) {
+ clearTimeout(chunkDebounceTimer);
+ chunkDebounceTimer = null;
+ }
+
+ if (!pendingChunkPromise) {
+ pendingChunkPromise = new Promise((resolve, reject) => {
+ pendingChunkResolve = resolve;
+ pendingChunkReject = reject;
+ });
+ }
+
+ const captureEpoch = queryEpoch;
+ chunkDebounceTimer = setTimeout(() => {
+ chunkDebounceTimer = null;
+ const chunksToLoad = new Set(pendingTargetChunks);
+ pendingTargetChunks.clear();
+ notifyChunkStats();
+
+ const resolve = pendingChunkResolve;
+ const reject = pendingChunkReject;
+ pendingChunkPromise = null;
+ pendingChunkResolve = null;
+ pendingChunkReject = null;
+
+ recordChunkEvent({
+ type: 'debounce_fire',
+ chunks: Array.from(chunksToLoad),
+ filterKey: currentKey,
+ message: `Debounce abgelaufen: Starte Chunks [${Array.from(chunksToLoad).join(', ')}]`,
+ });
+
+ _executeRequiredChunks(chunksToLoad, captureEpoch, true, currentKey)
+ .then((res) => resolve?.(res))
+ .catch((err) => reject?.(err));
+ }, CHUNK_DEBOUNCE_MS);
+
+ return pendingChunkPromise;
+ },
+
+ loadChunk(chunkIndex, targetEpoch = queryEpoch, targetFilterKey = getFilterKey(automat.state)) {
+ const index = Math.max(0, Number(chunkIndex) || 0);
+ const entry = getOrCreateFilterCache(targetFilterKey, automat.state);
+
+ if (targetEpoch !== queryEpoch && targetFilterKey !== getFilterKey(automat.state)) {
+ return Promise.resolve(entry.items);
+ }
+
+ if (entry.loadedChunks.has(index)) {
+ touchChunkLRU(targetFilterKey, index);
+ recordChunkEvent({
+ type: 'hit',
+ chunkIndex: index,
+ filterKey: targetFilterKey,
+ message: `Cache-Hit: Chunk #${index} für Filter "${entry.label}" bereits im Speicher`,
+ });
+ return Promise.resolve(targetFilterKey === getFilterKey(automat.state) ? automat.state.items : entry.items);
+ }
+
+ const inflightKey = makeLruKey(targetFilterKey, index);
+ if (inflightChunks.has(inflightKey)) {
+ recordChunkEvent({
+ type: 'inflight_hit',
+ chunkIndex: index,
+ filterKey: targetFilterKey,
+ message: `Inflight-Hit: Chunk #${index} für Filter "${entry.label}" lädt bereits`,
+ });
+ return inflightChunks.get(inflightKey);
+ }
+
+ const offset = index * CHUNK_SIZE;
+ const limit = CHUNK_SIZE;
+ const isActiveFilter = targetFilterKey === getFilterKey(automat.state);
+
+ if (index === 0 && (entry.items === null || (isActiveFilter && automat.state.items === null))) {
+ entry.status = 'loading';
+ entry.error = null;
+ if (isActiveFilter) {
+ automat.setState({ status: 'loading', error: null });
+ }
+ }
+
+ const startTime = Date.now();
+ recordChunkEvent({
+ type: 'start',
+ chunkIndex: index,
+ filterKey: targetFilterKey,
+ message: `Netzwerk-Request: Lade Chunk #${index} (Offset ${offset}..${offset + limit - 1}) für "${entry.label}"`,
+ });
+
+ const filterParams = entry.params || getFilterParams(automat.state);
+ const promise = fetchShipmentsPageFor(filterParams, offset, limit)
+ .then(({ shipments, total, unfilteredTotal }) => {
+ const currentTotal = total > 0 ? total : 0;
+ entry.total = currentTotal;
+ entry.unfilteredTotal = unfilteredTotal;
+
+ if (entry.items === null || entry.items.length !== currentTotal) {
+ entry.items = new Array(currentTotal).fill(null);
+ } else {
+ entry.items = [...entry.items];
+ }
+
+ for (let i = 0; i < shipments.length; i++) {
+ const idx = offset + i;
+ if (idx < entry.items.length) {
+ entry.items[idx] = shipments[i];
+ }
+ }
+
+ entry.loadedChunks.add(index);
+ entry.status = 'ready';
+ entry.error = null;
+ entry.lastAccessed = Date.now();
+
+ registerChunkLRU(targetFilterKey, index, shipments.length);
+
+ const currentActive = targetFilterKey === getFilterKey(automat.state);
+ if (currentActive) {
automat.setState({
- items,
- total,
+ items: entry.items,
+ total: currentTotal,
unfilteredTotal,
status: 'ready',
error: null,
});
- return items;
- } catch (err) {
- automat.setState({
- status: 'failed',
- error: err,
- });
- throw err;
- } finally {
- inflightLoad = null;
}
- })();
- return inflightLoad;
- },
-
- async reload() {
- try {
- const { items, total, unfilteredTotal } = await fetchShipments(automat.state);
- automat.setState({
- items,
- total,
- unfilteredTotal,
- status: 'ready',
- error: null,
+ const duration = Date.now() - startTime;
+ recordChunkEvent({
+ type: 'loaded',
+ chunkIndex: index,
+ filterKey: targetFilterKey,
+ count: shipments.length,
+ duration,
+ message: `Chunk #${index} geladen (${shipments.length} Lieferscheine in ${duration}ms) für "${entry.label}"`,
});
- return items;
- } catch (err) {
- console.warn('[shipmentAutomat] silent reload failed:', err);
- }
- },
- // #endregion
- // #region filters
- setFilter(filterText) {
- const next = typeof filterText === 'string' ? filterText : '';
- if (automat.state.filter === next) return;
-
- automat.setState({ filter: next });
- if (debounceTimer) clearTimeout(debounceTimer);
- debounceTimer = setTimeout(() => {
- void automat.actions.load().catch(() => {});
- }, 200);
- },
-
- setStateFilter(stateFilter) {
- const next = typeof stateFilter === 'string' ? stateFilter : '';
- if (automat.state.stateFilter === next) return;
-
- automat.setState({ stateFilter: next });
- void automat.actions.load().catch(() => {});
- },
-
- setSeekMonths(months) {
- automat.setState({ seekMonths: months, seekYears: 0 });
- void automat.actions.load().catch(() => {});
- },
-
- addSeekMonth() {
- automat.setState((s) => ({ seekMonths: (s.seekMonths ?? 0) + 1 }));
- void automat.actions.load().catch(() => {});
- },
-
- addSeekYear() {
- automat.setState((s) => ({ seekYears: (s.seekYears ?? 0) + 1 }));
- void automat.actions.load().catch(() => {});
- },
-
- resetNegativeSeek() {
- automat.setState({ seekMonths: 0, seekYears: 0 });
- void automat.actions.load().catch(() => {});
- },
- // #endregion
-
- // #region item mutations
- patchShipment(id, patch) {
- automat.setState((s) => {
- if (!Array.isArray(s.items)) return null;
- const next = s.items.map((item) => (item.id === id ? { ...item, ...patch } : item));
- return { items: next };
- });
- },
-
- async updateState(id, newState) {
- // Optimistic update
- automat.actions.patchShipment(id, { state: newState });
- try {
- await shipmentApi.update(id, { state: newState });
- void orderAutomat.actions.reload().catch(() => {});
- } catch (err) {
- // Rollback on error
- void automat.actions.reload();
+ return currentActive ? automat.state.items : entry.items;
+ })
+ .catch((err) => {
+ entry.status = 'failed';
+ entry.error = err;
+ const currentActive = targetFilterKey === getFilterKey(automat.state);
+ if (currentActive) {
+ if (index === 0 && automat.state.items === null) {
+ automat.setState({ status: 'failed', error: err });
+ }
+ }
+ const duration = Date.now() - startTime;
+ console.error(`[shipmentAutomat] loadChunk(${index}, ${targetFilterKey}) error:`, err);
+ recordChunkEvent({
+ type: 'error',
+ chunkIndex: index,
+ filterKey: targetFilterKey,
+ duration,
+ error: err?.message || String(err),
+ message: `Fehler bei Chunk #${index} ("${entry.label}"): ${err?.message || err}`,
+ });
throw err;
- }
- },
-
- async deleteShipment(id) {
- await shipmentApi.delete(id);
- automat.setState((s) => {
- if (!Array.isArray(s.items)) return null;
- const next = s.items.filter((item) => item.id !== id);
- return {
- items: next,
- total: Math.max(0, s.total - 1),
- unfilteredTotal: Math.max(0, s.unfilteredTotal - 1),
- };
+ })
+ .finally(() => {
+ inflightChunks.delete(inflightKey);
+ notifyChunkStats();
});
- void orderAutomat.actions.reload().catch(() => {});
- },
- reset() {
- if (debounceTimer) clearTimeout(debounceTimer);
- inflightLoad = null;
- automat.setState({ ...initialState });
- },
- // #endregion
- };
+ inflightChunks.set(inflightKey, promise);
+ notifyChunkStats();
+ return promise;
+ },
+
+ // MARK: server-side filter actions
+ filter(query) {
+ automat.setState({ filter: String(query ?? '') });
+ onFilterChange(false);
+ },
+
+ setFilter(query) {
+ actions.filter(query);
+ },
+
+ setStateFilter(stateFilter) {
+ automat.setState({ stateFilter: String(stateFilter ?? '') });
+ onFilterChange(true);
+ },
+
+ setSeekMonths(months) {
+ actions.addNegativeSeek(-months);
+ },
+
+ addSeekMonth() {
+ const seekMonths = (automat.state.seekMonths ?? 0) + 1;
+ const seekYears = automat.state.seekYears ?? 0;
+ const totalMonths = -(seekMonths + seekYears * 12);
+ automat.setState({ seekMonths, negativeSeekMonths: totalMonths });
+ onFilterChange(true);
+ },
+
+ addSeekYear() {
+ const seekMonths = automat.state.seekMonths ?? 0;
+ const seekYears = (automat.state.seekYears ?? 0) + 1;
+ const totalMonths = -(seekMonths + seekYears * 12);
+ automat.setState({ seekYears, negativeSeekMonths: totalMonths });
+ onFilterChange(true);
+ },
+
+ addNegativeSeek(months) {
+ if (months === -12) {
+ actions.addSeekYear();
+ } else if (months === -1) {
+ actions.addSeekMonth();
+ } else {
+ const current = Math.min(0, Number(automat.state.negativeSeekMonths ?? 0));
+ const next = current + months;
+ automat.setState({ negativeSeekMonths: Math.min(0, next) });
+ onFilterChange(true);
+ }
+ },
+
+ resetNegativeSeek() {
+ automat.setState({ seekMonths: 0, seekYears: 0, negativeSeekMonths: 0 });
+ onFilterChange(true);
+ },
+
+ resetFilters() {
+ automat.setState({
+ filter: '',
+ stateFilter: '',
+ seekMonths: 0,
+ seekYears: 0,
+ negativeSeekMonths: 0,
+ });
+ onFilterChange(true);
+ },
+
+ load() {
+ return actions.loadChunk(0, queryEpoch, getFilterKey(automat.state));
+ },
+
+ ensureLoaded() {
+ if (automat.state.items !== null) {
+ return Promise.resolve(automat.state.items);
+ }
+ return actions.loadChunk(0, queryEpoch, getFilterKey(automat.state));
+ },
+
+ async reload(onlyCurrent = false) {
+ queryEpoch++;
+ clearChunkDebounce();
+
+ if (onlyCurrent) {
+ const currentKey = getFilterKey(automat.state);
+ actions.clearFilterCache(currentKey);
+ } else {
+ actions.clearCache();
+ }
+
+ await actions.loadChunk(0, queryEpoch, getFilterKey(automat.state));
+ return automat.state.items;
+ },
+
+ replace(items) {
+ clearChunkDebounce();
+ const currentKey = getFilterKey(automat.state);
+ actions.clearFilterCache(currentKey);
+
+ const count = Array.isArray(items) ? items.length : 0;
+ const entry = getOrCreateFilterCache(currentKey, automat.state);
+ entry.items = items;
+ entry.total = count;
+ entry.status = 'ready';
+ entry.error = null;
+
+ recordChunkEvent({
+ type: 'replace',
+ filterKey: currentKey,
+ message: `Items ersetzt (${count} Einträge)`,
+ });
+ notifyChunkStats();
+ automat.setState({
+ items,
+ total: count,
+ status: 'ready',
+ error: null,
+ });
+ return items;
+ },
+
+ evictChunk(chunkIndex, filterKey = getFilterKey(automat.state)) {
+ const index = Math.max(0, Number(chunkIndex) || 0);
+ const key = makeLruKey(filterKey, index);
+ if (lruChunks.has(key)) {
+ lruChunks.delete(key);
+ }
+ evictChunkFromMemory(filterKey, index, 'manual');
+ return automat.state.items;
+ },
+
+ clearFilterCache(filterKey = getFilterKey(automat.state)) {
+ for (const [lruKey, info] of Array.from(lruChunks.entries())) {
+ if (info.filterKey === filterKey) {
+ lruChunks.delete(lruKey);
+ }
+ }
+
+ const entry = filterCaches.get(filterKey);
+ if (entry) {
+ entry.loadedChunks.clear();
+ entry.items = null;
+ entry.total = 0;
+ entry.status = 'idle';
+ entry.error = null;
+ }
+
+ if (filterKey === getFilterKey(automat.state)) {
+ automat.setState({
+ items: null,
+ total: 0,
+ status: 'idle',
+ error: null,
+ });
+ }
+
+ recordChunkEvent({
+ type: 'clear_filter',
+ filterKey,
+ message: `Filter-Cache für "${formatFilterLabel(filterKey)}" geleert`,
+ });
+ notifyChunkStats();
+ return automat.state.items;
+ },
+
+ clearCache() {
+ clearChunkDebounce();
+ lruChunks.clear();
+ inflightChunks.clear();
+
+ for (const entry of filterCaches.values()) {
+ entry.loadedChunks.clear();
+ entry.items = null;
+ entry.total = 0;
+ entry.status = 'idle';
+ entry.error = null;
+ }
+
+ automat.setState({
+ items: null,
+ total: 0,
+ status: 'idle',
+ error: null,
+ });
+
+ recordChunkEvent({
+ type: 'clear',
+ message: 'Gesamter LRU-Cache und alle Filter-Caches geleert',
+ });
+ notifyChunkStats();
+ return automat.state.items;
+ },
+
+ prefetchAllChunks(filterKey = getFilterKey(automat.state)) {
+ const entry = getOrCreateFilterCache(filterKey, automat.state);
+ const total = entry.total || automat.state.total || 0;
+ const chunkCount = Math.ceil(total / CHUNK_SIZE);
+
+ recordChunkEvent({
+ type: 'prefetch_all',
+ filterKey,
+ message: `Starte Prefetch aller ${chunkCount} Chunks für "${entry.label}"`,
+ });
+
+ for (let c = 0; c < chunkCount; c++) {
+ const inflightKey = makeLruKey(filterKey, c);
+ if (!entry.loadedChunks.has(c) && !inflightChunks.has(inflightKey)) {
+ void actions.loadChunk(c, queryEpoch, filterKey);
+ }
+ }
+ notifyChunkStats();
+ },
+
+ patchShipment(id, patch) {
+ let changed = false;
+ for (const entry of filterCaches.values()) {
+ if (Array.isArray(entry.items)) {
+ entry.items = entry.items.map((s) => {
+ if (s && s.id === id) {
+ changed = true;
+ return { ...s, ...patch };
+ }
+ return s;
+ });
+ }
+ }
+
+ if (Array.isArray(automat.state.items)) {
+ const items = automat.state.items.map((s) => {
+ if (s && s.id === id) {
+ changed = true;
+ return { ...s, ...patch };
+ }
+ return s;
+ });
+ if (changed) {
+ automat.setState({ items });
+ }
+ }
+ return automat.state.items;
+ },
+
+ async updateState(id, newState) {
+ actions.patchShipment(id, { state: newState });
+ try {
+ await shipmentApi.update(id, { state: newState });
+ void orderAutomat.actions.reload().catch(() => {});
+ } catch (err) {
+ void actions.reload();
+ throw err;
+ }
+ },
+
+ async deleteShipment(id) {
+ await shipmentApi.delete(id);
+ for (const entry of filterCaches.values()) {
+ if (Array.isArray(entry.items)) {
+ entry.items = entry.items.filter((item) => !item || item.id !== id);
+ entry.total = Math.max(0, entry.total - 1);
+ entry.unfilteredTotal = Math.max(0, entry.unfilteredTotal - 1);
+ }
+ }
+ automat.setState((s) => {
+ const items = Array.isArray(s.items) ? s.items.filter((item) => !item || item.id !== id) : s.items;
+ return {
+ items,
+ total: Math.max(0, s.total - 1),
+ unfilteredTotal: Math.max(0, s.unfilteredTotal - 1),
+ };
+ });
+ void orderAutomat.actions.reload().catch(() => {});
+ },
+
+ reset() {
+ queryEpoch++;
+ if (filterDebounceTimer) {
+ clearTimeout(filterDebounceTimer);
+ filterDebounceTimer = null;
+ }
+ clearChunkDebounce();
+ lruChunks.clear();
+ inflightChunks.clear();
+ filterCaches.clear();
+ chunkEvents.length = 0;
+ notifyChunkStats();
+ automat.setState({ ...initialState });
+ },
+};
automat = new Automat(initialState, actions, { name: 'shipment' });
-// MARK: filter key & items helpers
-export function getFilterKey(state = automat?.state || initialState) {
- return `${state.filter || ''}|${state.stateFilter || ''}|${state.seekMonths || 0}|${state.seekYears || 0}`;
-}
-
-export function getItems() {
- if (automat.state.status === 'idle') {
- void automat.actions.load().catch(() => {});
- }
- return automat.state.items;
-}
-
+automat.getItems = actions.getItems;
+automat.requireChunk = actions.requireChunk;
+automat.CHUNK_SIZE = CHUNK_SIZE;
+automat.MAX_LRU_CHUNKS = MAX_LRU_CHUNKS;
+automat.getChunkStats = getChunkStats;
+automat.subscribeChunkStats = subscribeChunkStats;
+automat.evictChunk = actions.evictChunk;
+automat.clearFilterCache = actions.clearFilterCache;
+automat.clearCache = actions.clearCache;
+automat.prefetchAllChunks = actions.prefetchAllChunks;
automat.getFilterKey = getFilterKey;
-automat.getItems = getItems;
+automat.formatFilterLabel = formatFilterLabel;
// #region authAutomat synchronization
let lastCompanyId = null;
@@ -267,6 +1089,61 @@ authAutomat.subscribe((auth) => {
}
}
});
+
+if (authAutomat.state.status === 'authed' && authAutomat.state.user?.selectedCompanyId != null) {
+ lastCompanyId = authAutomat.state.user.selectedCompanyId;
+ void automat.actions.load().catch(() => {});
+}
// #endregion
+/** Selects current shipments */
+export function selectShipments(state = automat.state) {
+ return state.items;
+}
+
+/** Selects total unpaged count */
+export function selectShipmentTotal(state = automat.state) {
+ return state.total ?? 0;
+}
+
+/** Selects unfiltered total count */
+export function selectShipmentUnfilteredTotal(state = automat.state) {
+ return state.unfilteredTotal ?? 0;
+}
+
+/** Selects state filter */
+export function selectStateFilter(state = automat.state) {
+ return state.stateFilter;
+}
+
+/** Selects negative seek offset in months */
+export function selectNegativeSeekMonths(state = automat.state) {
+ return state.negativeSeekMonths;
+}
+
+/** Selects seek month count */
+export function selectSeekMonths(state = automat.state) {
+ return state.seekMonths ?? 0;
+}
+
+/** Selects seek year count */
+export function selectSeekYears(state = automat.state) {
+ return state.seekYears ?? 0;
+}
+
+/**
+ * Calculates client pagination metadata.
+ */
+export function selectShipmentPagination(state = automat.state) {
+ const total = state.total ?? 0;
+ return {
+ total,
+ unfilteredTotal: state.unfilteredTotal ?? total,
+ offset: 0,
+ limit: CHUNK_SIZE,
+ currentPage: 1,
+ pageCount: Math.max(1, Math.ceil(total / CHUNK_SIZE)),
+ };
+}
+
export default automat;
diff --git a/src/automats/sseAutomat.js b/src/automats/sseAutomat.js
index f038245..120bb9e 100644
--- a/src/automats/sseAutomat.js
+++ b/src/automats/sseAutomat.js
@@ -245,6 +245,9 @@ function connect() {
void orderAutomat.actions.reload().catch((err) => {
console.error('[sse] order refresh failed', err);
});
+ void shipmentAutomat.actions.reload().catch((err) => {
+ console.error('[sse] shipment refresh failed', err);
+ });
});
addTrackedListener(es, 'quote', () => {
diff --git a/src/components/manifest/ShipmentList.jsx b/src/components/manifest/ShipmentList.jsx
index 7023c07..d6206b6 100644
--- a/src/components/manifest/ShipmentList.jsx
+++ b/src/components/manifest/ShipmentList.jsx
@@ -22,7 +22,7 @@ import FillSpace from 'dashgui/FillSpace';
import { PanelTile, PanelTileGrid } from 'dashgui/panels';
import BackendError from '../BackendError';
import AppDialog from '../AppDialog';
-import shipmentAutomat from '../../automats/shipmentAutomat';
+import shipmentAutomat, { CHUNK_SIZE } from '../../automats/shipmentAutomat';
import orderAutomat from '../../automats/orderAutomat';
import numberAutomat from '../../automats/numberAutomat';
import { shipment as shipmentApi } from '../../api';
@@ -841,6 +841,7 @@ export class ShipmentList extends PureComponent {
this.headerItem = createDummyTestShipment();
this.state = {
items: shipmentAutomat.getItems(),
+ total: shipmentAutomat.state.total ?? 0,
unfilteredTotal: shipmentAutomat.state.unfilteredTotal ?? 0,
filterKey: shipmentAutomat.getFilterKey?.() ?? '',
orders: orderAutomat.state?.items || [],
@@ -855,12 +856,14 @@ export class ShipmentList extends PureComponent {
this.handleOpenShipment = this.handleOpenShipment.bind(this);
this.handleCloseShipment = this.handleCloseShipment.bind(this);
this.handleDeleteShipment = this.handleDeleteShipment.bind(this);
+ this.handlePageChange = this.handlePageChange.bind(this);
}
componentDidMount() {
this._cancelled = false;
this.unsub = shipmentAutomat.subscribe(this, (state) => ({
items: state.items,
+ total: state.total ?? 0,
unfilteredTotal: state.unfilteredTotal ?? 0,
filterKey: shipmentAutomat.getFilterKey(state),
}));
@@ -917,8 +920,21 @@ export class ShipmentList extends PureComponent {
}
}
+ handlePageChange(page, meta) {
+ const pageSize = meta?.pageSize ?? 10;
+ const startIndex = (page - 1) * pageSize;
+ const items = this.state.items;
+ const maxIndex = items ? items.length - 1 : startIndex;
+ const endIndex = Math.min(maxIndex, startIndex + pageSize - 1);
+
+ const startChunk = Math.floor(startIndex / CHUNK_SIZE);
+ const endChunk = Math.floor(endIndex / CHUNK_SIZE);
+
+ shipmentAutomat.requireChunk(startChunk, endChunk);
+ }
+
handleRetry() {
- void shipmentAutomat.actions.load().catch(() => {});
+ void shipmentAutomat.actions.requireChunk(0, 0, { immediate: true }).catch(() => {});
}
handleOpenShipment(shipment) {
@@ -946,6 +962,7 @@ export class ShipmentList extends PureComponent {
render() {
const {
items,
+ total,
unfilteredTotal,
filterKey,
orders,
@@ -1017,6 +1034,7 @@ export class ShipmentList extends PureComponent {
}
+ onPageChange={this.handlePageChange}
/>
{items === null && (
{
const reqTarget = event?.detail?.target;
- if (reqTarget === 'quote' || reqTarget === 'order') {
+ if (reqTarget === 'quote' || reqTarget === 'order' || reqTarget === 'shipment') {
this.switchTarget(reqTarget);
} else {
const detected = getInitialTarget();
@@ -292,6 +296,9 @@ class ChunkCacheMonitor extends PureComponent {
if (p.onlyUnpaid) automat.actions.setOnlyUnpaid(true);
if (p.onlyUndelivered) automat.actions.setOnlyUndelivered(true);
}
+ if (this.state.target === 'shipment') {
+ if (p.stateFilter) automat.actions.setStateFilter(p.stateFilter);
+ }
if (p.negativeSeekMonths) automat.actions.addNegativeSeek(p.negativeSeekMonths);
this.setState({ inspectFilterKey: null, selectedChunk: null });
}
@@ -715,9 +722,10 @@ class ChunkCacheMonitor extends PureComponent {
{chunkOrders.map(({ item: order, index }) => {
const isOrd = this.state.target === 'order';
+ const isShip = this.state.target === 'shipment';
const paid = isOrd ? isOrderPaid(order) : false;
const delivered = isOrd ? isOrderDelivered(order) : false;
- const gross = order.grossTotal != null ? Number(order.grossTotal) : orderGrossTotal(order.lines);
+ const gross = order.grossTotal != null ? Number(order.grossTotal) : (order.lines ? orderGrossTotal(order.lines) : 0);
const customer = order.customerName || (order.entityId ? `Kunde #${order.entityId}` : '–');
const posCount = order.positions != null ? order.positions : (order.lines?.length ?? 0);
@@ -772,11 +780,29 @@ class ChunkCacheMonitor extends PureComponent {
/>
)}
+ {isShip && (
+ <>
+
+ {order.carrier && (
+
+ )}
+
+ )}
- {gross > 0 ? formatPrice(gross) : '–'}
+ {!isShip && gross > 0 ? formatPrice(gross) : (isShip && order.totalQuantity ? `${order.totalQuantity} Stk` : '–')}
);
@@ -1046,6 +1072,14 @@ class ChunkCacheMonitor extends PureComponent {
onClick={() => this.switchTarget('order')}
sx={{ cursor: 'pointer', height: 24, fontSize: '0.72rem', fontWeight: this.state.target === 'order' ? 700 : 500 }}
/>
+ this.switchTarget('shipment')}
+ sx={{ cursor: 'pointer', height: 24, fontSize: '0.72rem', fontWeight: this.state.target === 'shipment' ? 700 : 500 }}
+ />