From 40dea84085d58349f2af0be97571d5a30d2848c7 Mon Sep 17 00:00:00 2001 From: Maurice Date: Mon, 16 Nov 2026 10:45:22 +0100 Subject: [PATCH] fix(flight-live): leave a through flight's first sector aircraft to that sector With two booked sectors under one flight number, the second is in its watch window for the whole first one, and the aircraft flying the first sector was read as the second having departed, with its departure notice hours early. An aircraft that fits a sibling sector better is now left to it. --- .../flight-live/flight-live-poll.service.ts | 29 ++++++++- .../nest/flight-live/flight-live.derive.ts | 64 +++++++++++++++++-- .../flight-live-poll.service.test.ts | 49 +++++++++++++- .../flight-live/flight-live.derive.test.ts | 51 +++++++++++++++ 4 files changed, 180 insertions(+), 13 deletions(-) diff --git a/server/src/nest/flight-live/flight-live-poll.service.ts b/server/src/nest/flight-live/flight-live-poll.service.ts index 60ffbabdf..81988d22c 100644 --- a/server/src/nest/flight-live/flight-live-poll.service.ts +++ b/server/src/nest/flight-live/flight-live-poll.service.ts @@ -19,6 +19,7 @@ import { toLiveLeg, watchWindow, type LiveState, + type SiblingSector, } from './flight-live.derive'; import { FlightLiveFeedService, type FeedLookup } from './flight-live.feeds'; import { FlightLiveService, legKey, type TripLeg } from './flight-live.service'; @@ -96,6 +97,23 @@ function utcDate(now: number, days: number): string { return new Date(now + days * DAY_MS).toISOString().slice(0, 10); } +/** The other sectors in their window that fly under the same callsign as the flight `key`. */ +function siblingSectors( + key: string, + groups: ReadonlyMap, + stored: ReadonlyMap, +): SiblingSector[] { + const route = groups.get(key)?.[0]; + if (!route) return []; + const siblings: SiblingSector[] = []; + for (const [other, legs] of groups) { + const sector = legs[0]; + if (other === key || !sector || sector.callsign !== route.callsign) continue; + siblings.push({ route: sector, landed: stored.get(other)?.phase === 'landed' }); + } + return siblings; +} + /** * The poll behind live flight status, one tick a minute (FlightLiveJob). * @@ -176,7 +194,11 @@ export class FlightLivePollService { (a.state?.next_poll_at ?? 0) - (b.state?.next_poll_at ?? 0), ); - const queue = due.slice(0, MAX_REQUESTS_PER_TICK).map(({ key, state }) => ({ legs: groups.get(key) ?? [], state })); + const queue = due.slice(0, MAX_REQUESTS_PER_TICK).map(({ key, state }) => ({ + legs: groups.get(key) ?? [], + state, + siblings: siblingSectors(key, groups, stored), + })); const result: PollResult = { asked: 0, changed: 0, skipped: null }; await this.pollEach(queue, clock, result); return result; @@ -214,7 +236,7 @@ export class FlightLivePollService { * @txIndependent one write per flight (pollDue). */ private async pollEach( - queue: ReadonlyArray<{ legs: TripLeg[]; state: LiveState | null }>, + queue: ReadonlyArray<{ legs: TripLeg[]; state: LiveState | null; siblings: SiblingSector[] }>, clock: () => number, result: PollResult, ): Promise { @@ -231,7 +253,8 @@ export class FlightLivePollService { if (!answer.ok && (answer as Extract).reason === 'budget') return; result.asked++; const at = clock(); - let next = answer.ok ? advance(prev, pickAircraft(answer.aircraft, route), route, at, answer.source) : failed(prev); + const picked = answer.ok ? pickAircraft(answer.aircraft, route, { now: at, siblings: head.siblings }) : null; + let next = answer.ok ? advance(prev, picked, route, at, answer.source) : failed(prev); next = closeIfOver({ ...next, next_poll_at: nextPollAt(next, route, at) }, route, at); const notices = this.dueNotices(prev, next, head.legs, at); next = { ...next, ...notices.flags }; diff --git a/server/src/nest/flight-live/flight-live.derive.ts b/server/src/nest/flight-live/flight-live.derive.ts index 7dedc1cc6..a663f7626 100644 --- a/server/src/nest/flight-live/flight-live.derive.ts +++ b/server/src/nest/flight-live/flight-live.derive.ts @@ -117,23 +117,73 @@ export function inWatchWindow(leg: Schedule, now: number): boolean { return span !== null && now >= span.start && now <= span.end; } +/** Another sector the same callsign flies in its watch window right now, and whether it is down already. */ +export interface SiblingSector { + route: Route; + landed: boolean; +} + +function detourKm(lat: number, lng: number, route: Route): number { + const total = kmTo(route.origin.lat, route.origin.lng, route.destination); + return kmTo(lat, lng, route.origin) + kmTo(lat, lng, route.destination) - total; +} + +/** + * How far a position is from where the sector's aircraft should be at `now`, + * in km: at the origin before the scheduled departure, at the destination + * after the scheduled arrival, on the route in between. + */ +function sectorFitKm(lat: number, lng: number, route: Route, now: number): number { + if (route.scheduled_departure !== null && now < route.scheduled_departure) return kmTo(lat, lng, route.origin); + if (route.scheduled_arrival !== null && now > route.scheduled_arrival) return kmTo(lat, lng, route.destination); + return detourKm(lat, lng, route); +} + +function departsEarlier(a: Route, b: Route): boolean { + return (a.scheduled_departure ?? Number.POSITIVE_INFINITY) < (b.scheduled_departure ?? Number.POSITIVE_INFINITY); +} + +/** + * Whether a sibling sector of the same flight number claims this position: it + * fits that sector better, or as well and that sector flies first and has not + * landed yet. A through flight (BWI-MDW-DEN as one number) is in the second + * sector's window during the whole first one, and the aircraft flying to MDW + * must not read as the MDW-DEN sector having departed. + */ +function claimedBySibling( + lat: number, + lng: number, + route: Route, + now: number, + siblings: readonly SiblingSector[], +): boolean { + const own = sectorFitKm(lat, lng, route, now); + return siblings.some((sibling) => { + if (sibling.landed) return false; + const fit = sectorFitKm(lat, lng, sibling.route, now); + return fit < own || (fit === own && departsEarlier(sibling.route, route)); + }); +} + /** * The aircraft that flies this leg among those the feed answered for the * callsign: the one with a position nearest the great circle between the two * airports (least detour over the direct distance). A callsign is reused by - * the next leg of a rotation, so two can be in the air at once. + * the next leg of a rotation, so two can be in the air at once. An aircraft a + * sibling sector of the same flight number claims at `now` is left to it. */ -export function pickAircraft(aircraft: readonly FeedAircraft[], route: Route): FeedAircraft | null { - const total = kmTo(route.origin.lat, route.origin.lng, route.destination); +export function pickAircraft( + aircraft: readonly FeedAircraft[], + route: Route, + sectors: { now: number; siblings: readonly SiblingSector[] } = { now: 0, siblings: [] }, +): FeedAircraft | null { let best: FeedAircraft | null = null; let bestScore = Number.POSITIVE_INFINITY; for (const ac of aircraft) { const lat = finite(ac.lat); const lng = finite(ac.lon); - const score = - lat === null || lng === null - ? Number.MAX_VALUE - : kmTo(lat, lng, route.origin) + kmTo(lat, lng, route.destination) - total; + if (lat !== null && lng !== null && claimedBySibling(lat, lng, route, sectors.now, sectors.siblings)) continue; + const score = lat === null || lng === null ? Number.MAX_VALUE : detourKm(lat, lng, route); if (best === null || score < bestScore) { best = ac; bestScore = score; diff --git a/server/tests/unit/nest/flight-live/flight-live-poll.service.test.ts b/server/tests/unit/nest/flight-live/flight-live-poll.service.test.ts index 41f84bee4..25688b443 100644 --- a/server/tests/unit/nest/flight-live/flight-live-poll.service.test.ts +++ b/server/tests/unit/nest/flight-live/flight-live-poll.service.test.ts @@ -347,10 +347,53 @@ describe('FlightLivePollService: closing and sectors', () => { expect(await poll.poll(at(DEP + 5 * MIN))).toMatchObject({ asked: 2 }); const rows = await findRows(orm, FlightLiveStates, { callsign: 'DLH100' }); // Seen climbing out of Frankfurt: wheels-up for the first sector, nothing claimed for the second. - expect(rows.map((r) => [r.origin, r.destination, r.departed_at]).sort()).toEqual([ - ['BER', 'FRA', null], - ['FRA', 'BER', '2026-07-01 10:05:00'], + expect(rows.map((r) => [r.origin, r.destination, r.phase, r.departed_at]).sort()).toEqual([ + ['BER', 'FRA', 'scheduled', null], + ['FRA', 'BER', 'airborne', '2026-07-01 10:05:00'], ]); + expect(events()).toEqual(['flight_departed']); + feed.lookup.mockReset(); + }); + + it('FLPOLL-013: the second sector of a through flight departs only when its own aircraft leaves', async () => { + const { user } = await makeUser(orm); + const trip = await makeTrip(orm, user.id, { title: 'Onwards' }); + const day = await makeDay(orm, trip.id, { day_number: 1, date: '2026-07-01' }); + const legs = [ + { from: 'FRA', to: 'BER', flight_number: 'LH 100', dep_day_id: day.id, dep_time: '12:00', arr_time: '13:10' }, + { from: 'BER', to: 'VIE', flight_number: 'LH 100', dep_day_id: day.id, dep_time: '13:55', arr_time: '15:05' }, + ]; + const flight = await makeReservation(orm, trip.id, { + title: 'Through flight', + type: 'flight', + metadata: JSON.stringify({ legs }), + }); + const fra = { name: 'Frankfurt (FRA)', code: 'FRA', lat: 50.0333, lng: 8.5706, timezone: 'Europe/Berlin' }; + const ber = { name: 'Berlin (BER)', code: 'BER', lat: 52.3667, lng: 13.5033, timezone: 'Europe/Berlin' }; + const vie = { name: 'Vienna (VIE)', code: 'VIE', lat: 48.1103, lng: 16.5697, timezone: 'Europe/Vienna' }; + await makeReservationEndpoint(orm, flight.id, { role: 'from', sequence: 0, ...fra, local_date: '2026-07-01' }); + await makeReservationEndpoint(orm, flight.id, { role: 'stop', sequence: 1, ...ber, local_date: '2026-07-01' }); + await makeReservationEndpoint(orm, flight.id, { role: 'to', sequence: 2, ...vie, local_date: '2026-07-01' }); + const sector = (origin: string) => findRow(orm, FlightLiveStates, { callsign: 'DLH100', origin }); + + // Cruising towards Berlin on the first sector: the Vienna sector stays on the ground. + feed.lookup.mockResolvedValue(seen(aircraft({ alt_baro: 30000, lat: 51.2, lon: 11, gs: 450 }))); + await poll.poll(at(DEP + 30 * MIN)); + expect(await sector('BER')).toMatchObject({ phase: 'scheduled', departed_notified: 0 }); + expect(events()).toEqual(['flight_departed']); + + // Down in Berlin: the first sector lands, the second still waits for its own departure. + feed.lookup.mockResolvedValue(seen(aircraft({ alt_baro: 'ground', lat: 52.37, lon: 13.5, gs: 15 }))); + await poll.poll(at(ARR + 2 * MIN)); + expect(await sector('FRA')).toMatchObject({ phase: 'landed' }); + expect(await sector('BER')).toMatchObject({ departed_notified: 0, departed_at: null }); + + // Climbing out of Berlin towards Vienna: now the second sector has departed, told once. + notifications.send.mockClear(); + feed.lookup.mockResolvedValue(seen(aircraft({ alt_baro: 5000, lat: 52.3, lon: 13.6, gs: 230 }))); + await poll.poll(at(DEP + 120 * MIN)); + expect(await sector('BER')).toMatchObject({ phase: 'airborne', departed_at: '2026-07-01 12:00:00' }); + expect(events()).toEqual(['flight_departed']); feed.lookup.mockReset(); }); }); diff --git a/server/tests/unit/nest/flight-live/flight-live.derive.test.ts b/server/tests/unit/nest/flight-live/flight-live.derive.test.ts index cf15e0267..4313d3860 100644 --- a/server/tests/unit/nest/flight-live/flight-live.derive.test.ts +++ b/server/tests/unit/nest/flight-live/flight-live.derive.test.ts @@ -17,6 +17,7 @@ import { watchWindow, type FeedAircraft, type LiveState, + type SiblingSector, } from '../../../../src/nest/flight-live/flight-live.derive'; import type { ScheduledLeg } from '../../../../src/nest/flight-live/flight-live.schedule'; import { flightLiveLegSchema } from '@trek/shared'; @@ -87,6 +88,56 @@ describe('pickAircraft and observe', () => { expect(pickAircraft([], LEG)).toBeNull(); }); + it('FLDER-020: on a through flight the aircraft of the first sector is not taken for the second', () => { + const at = (iso: string) => Date.parse(iso); + const bwi = { code: 'BWI', name: 'Baltimore', lat: 39.1754, lng: -76.6683, timezone: 'America/New_York' }; + const mdw = { code: 'MDW', name: 'Chicago Midway', lat: 41.7868, lng: -87.7522, timezone: 'America/Chicago' }; + const den = { code: 'DEN', name: 'Denver', lat: 39.8561, lng: -104.6737, timezone: 'America/Denver' }; + const sector = { ...LEG, callsign: 'SWA1234', flight_number: 'WN 1234', service_date: '2026-07-01' }; + const first: ScheduledLeg = { + ...sector, + origin: bwi, + destination: mdw, + scheduled_departure: at('2026-07-01T12:00:00Z'), + scheduled_arrival: at('2026-07-01T14:00:00Z'), + }; + const second: ScheduledLeg = { + ...sector, + leg_index: 1, + origin: mdw, + destination: den, + scheduled_departure: at('2026-07-01T14:45:00Z'), + scheduled_arrival: at('2026-07-01T17:15:00Z'), + }; + const flying = [{ route: first, landed: false }]; + const landed = [{ route: first, landed: true }]; + const pick = (aircraft: FeedAircraft, leg: ScheduledLeg, now: number, siblings: SiblingSector[]) => + pickAircraft([aircraft], leg, { now, siblings })?.hex ?? null; + const swa = (overrides: Partial) => ac({ hex: 'swa', flight: 'SWA1234', ...overrides }); + + // At the gate in Baltimore and climbing out of it: the first sector's, not the second's. + const atGate = swa({ lat: 39.18, lon: -76.67 }); + const climbing = swa({ alt_baro: 8000, lat: 39.3, lon: -77.01 }); + const takeoff = at('2026-07-01T12:10:00Z'); + expect(pick(atGate, second, at('2026-07-01T11:45:00Z'), flying)).toBeNull(); + expect(pick(climbing, second, takeoff, flying)).toBeNull(); + expect(pick(climbing, first, takeoff, [{ route: second, landed: false }])).toBe('swa'); + const empty = emptyState('SWA1234', '2026-07-01', 'MDW', 'DEN'); + const picked = pickAircraft([climbing], second, { now: takeoff, siblings: flying }); + const quiet = advance(empty, picked, second, takeoff, 'adsb.lol'); + expect(quiet).toMatchObject({ phase: 'scheduled', departed_at: null, first_seen_at: null }); + + // Late on final into Midway, close to the second sector's departure: still the first sector's while it flies. + const onFinal = swa({ alt_baro: 2500, lat: 41.78, lon: -87.6 }); + const nearDeparture = at('2026-07-01T14:40:00Z'); + expect(pick(onFinal, second, nearDeparture, flying)).toBeNull(); + + // Once the first sector is down the aircraft at Midway is the second one's, and so is its climb towards Denver. + expect(pick(swa({ lat: 41.787, lon: -87.75 }), second, nearDeparture, landed)).toBe('swa'); + const westbound = swa({ alt_baro: 6000, lat: 41.77, lon: -88.1 }); + expect(pick(westbound, second, at('2026-07-01T14:52:00Z'), flying)).toBe('swa'); + }); + it('FLDER-003: reads a report at its own time, on the ground at zero feet, the geometric height as a fallback', () => { const now = DEP; expect(observe(ac(), now)).toEqual({