update window range

apps/edr-freight-api/src/modules/train-scheduling/batch-window.util.ts

@@ -159,6 +159,154 @@ export function listBatchWindowsForBookings(
   return [...byKey.values()].sort(compareBatchWindows);
 }
 
+// ---------------------------------------------------------------------------
+// Board-display windows: full-day, midnight-based 3h slots over a date range.
+// These are used ONLY for the batch-board UI grouping (not persisted, and
+// independent of the cron intake hours above).
+// ---------------------------------------------------------------------------
+
+/** Midnight-based 3-hour slot starts (00–03, 03–06, … 21–24). */
+export const BOARD_WINDOW_HOURS = [0, 3, 6, 9, 12, 15, 18, 21] as const;
+
+/** A board window carries an EAT calendar date in addition to the slot times. */
+export interface BoardWindow extends BatchWindow {
+  /** EAT calendar day as ISO `YYYY-MM-DD`. */
+  date: string;
+  /** Human label for the day, e.g. `Thu, 05 Jun`. */
+  dateLabel: string;
+}
+
+const dayLabelFmt = new Intl.DateTimeFormat('en-GB', {
+  weekday: 'short',
+  day: '2-digit',
+  month: 'short',
+  timeZone: BATCH_TIMEZONE,
+});
+
+function pad2(n: number): string {
+  return String(n).padStart(2, '0');
+}
+
+/** Build a midnight-based 3h board window for an EAT calendar day + slot start hour. */
+function boardWindowFromEatStart(
+  year: number,
+  month: number,
+  day: number,
+  startHour: number,
+): BoardWindow {
+  const start = eatToUtc(year, month, day, startHour);
+  const endHour = startHour + 3; // 21 -> 24 (handled by Date.UTC roll-over)
+  const end = eatToUtc(year, month, day, endHour);
+  const endLabel = endHour >= 24 ? '24:00' : `${pad2(endHour)}:00`;
+  return {
+    key: start.toISOString(),
+    start,
+    end,
+    label: formatWindowLabel(start, end, endLabel),
+    date: `${year}-${pad2(month)}-${pad2(day)}`,
+    dateLabel: dayLabelFmt.format(start),
+  };
+}
+
+/** Which midnight-based 3h EAT slot a timestamp falls in. */
+export function boardWindowForTimestamp(date: Date): BoardWindow {
+  const { year, month, day, hour } = eatParts(date);
+  let startHour: (typeof BOARD_WINDOW_HOURS)[number] = 0;
+  for (const h of BOARD_WINDOW_HOURS) {
+    if (hour >= h) startHour = h;
+  }
+  return boardWindowFromEatStart(year, month, day, startHour);
+}
+
+/**
+ * Continuous list of board windows from `openDate` to `departureDate` (inclusive),
+ * clamped to the slot containing `openDate` on the first day and the slot
+ * containing `departureDate` on the last day. Returned in chronological order.
+ */
+export function listBoardWindowsForRange(
+  openDate: Date,
+  departureDate: Date,
+): BoardWindow[] {
+  const startWin = boardWindowForTimestamp(openDate);
+  const endWin = boardWindowForTimestamp(departureDate);
+  // Guard against an inverted range (departure before open).
+  if (endWin.start.getTime() < startWin.start.getTime()) {
+    return [startWin];
+  }
+
+  const windows: BoardWindow[] = [];
+  const seen = new Set<string>();
+  // Walk day-by-day in EAT, emitting each day's slots, stepping via UTC noon to
+  // avoid any boundary ambiguity, then filter to [startWin.start, endWin.start].
+  let cursor = new Date(eatToUtc(
+    Number(startWin.date.slice(0, 4)),
+    Number(startWin.date.slice(5, 7)),
+    Number(startWin.date.slice(8, 10)),
+    12,
+  ));
+  const lastDayMs = eatToUtc(
+    Number(endWin.date.slice(0, 4)),
+    Number(endWin.date.slice(5, 7)),
+    Number(endWin.date.slice(8, 10)),
+    12,
+  ).getTime();
+
+  while (cursor.getTime() <= lastDayMs) {
+    const { year, month, day } = eatParts(cursor);
+    for (const h of BOARD_WINDOW_HOURS) {
+      const w = boardWindowFromEatStart(year, month, day, h);
+      if (
+        w.start.getTime() >= startWin.start.getTime() &&
+        w.start.getTime() <= endWin.start.getTime() &&
+        !seen.has(w.key)
+      ) {
+        seen.add(w.key);
+        windows.push(w);
+      }
+    }
+    cursor = new Date(cursor.getTime() + 24 * 60 * 60 * 1000);
+  }
+
+  windows.sort(compareBatchWindows);
+  return windows;
+}
+
+/**
+ * Group items into board windows spanning [openDate, departureDate]. Empty
+ * windows are kept so the UI shows every slot. Items whose timestamp falls
+ * outside the range still get their own window (nothing hidden). Items without
+ * a timestamp go to `pendingKey`.
+ */
+export function groupBookingsIntoBoardWindows<T>(
+  items: T[],
+  getTimestamp: (item: T) => Date | null | undefined,
+  openDate: Date,
+  departureDate: Date,
+  pendingKey = 'pending-contract',
+): Map<string, { window: BoardWindow | null; items: T[] }> {
+  const map = new Map<string, { window: BoardWindow | null; items: T[] }>();
+
+  for (const w of listBoardWindowsForRange(openDate, departureDate)) {
+    map.set(w.key, { window: w, items: [] });
+  }
+  map.set(pendingKey, { window: null, items: [] });
+
+  for (const item of items) {
+    const ts = getTimestamp(item);
+    if (!ts) {
+      map.get(pendingKey)!.items.push(item);
+      continue;
+    }
+    const w = boardWindowForTimestamp(ts);
+    if (!map.has(w.key)) {
+      map.set(w.key, { window: w, items: [] });
+    }
+    map.get(w.key)!.items.push(item);
+  }
+
+  return map;
+}
+
 /** Group items by batch window key; items without a timestamp go to `pendingKey`. */
 export function groupByBatchWindow<T>(
   items: T[],