+
+
+
diff --git a/web/index.html b/web/index.html
index 6d92ad7..b0ebc17 100644
--- a/web/index.html
+++ b/web/index.html
@@ -566,9 +566,9 @@
const data = JSON.parse(event.data);
console.log('WebSocket message received:', data);
- // Refresh display when any PPR-related event occurs
- if (data.type && (data.type.includes('ppr_') || data.type === 'status_update')) {
- console.log('PPR update detected, refreshing display...');
+ // Refresh display when any PPR-related, local flight, departure, or arrival event occurs
+ if (data.type && (data.type.includes('ppr_') || data.type === 'status_update' || data.type.includes('local_flight_') || data.type.includes('departure_') || data.type.includes('arrival_'))) {
+ console.log('Flight update detected, refreshing display...');
loadArrivals();
loadDepartures();
}
@@ -634,32 +634,89 @@
return;
}
- // Build rows asynchronously to lookup airport names
- const rows = await Promise.all(arrivals.map(async (arrival) => {
- // Show callsign if available, otherwise registration
- const aircraftId = arrival.ac_call || arrival.ac_reg || '';
- const aircraftDisplay = `${escapeHtml(aircraftId)}
(${escapeHtml(arrival.ac_type || '')}) `;
- const fromDisplay = await getAirportName(arrival.in_from || '');
+ // Build rows with metadata for sorting
+ const rowsWithData = await Promise.all(arrivals.map(async (arrival) => {
+ const isLocal = arrival.isLocalFlight;
+ const isBookedIn = arrival.isBookedIn;
+ const isLanded = arrival.status === 'LANDED' || (arrival.status === 'DEPARTED' && arrival.landed_dt);
- // Show landed time if available, otherwise ETA
- let timeDisplay;
- if ((arrival.status === 'LANDED' || arrival.status === 'DEPARTED') && arrival.landed_dt) {
- const time = convertToLocalTime(arrival.landed_dt);
- timeDisplay = `
${time} LANDED
`;
+ let html = '';
+ let sortKey = '';
+
+ if (isLocal) {
+ // Local flight
+ const aircraftId = arrival.ac_call || arrival.ac_reg || '';
+ const aircraftDisplay = `${escapeHtml(aircraftId)}
(${escapeHtml(arrival.ac_type || '')}) `;
+ const fromDisplay = `
${getFlightTypeDisplay(arrival.flight_type)} `;
+ const time = convertToLocalTime(arrival.eta);
+ const timeDisplay = `
${time} IN AIR
`;
+
+ html = `
${aircraftDisplay} ${fromDisplay} ${timeDisplay} `;
+ sortKey = `0-${arrival.eta}`; // Live flights, sort by ETA
+ } else if (isBookedIn) {
+ // Booked-in arrival
+ const aircraftId = arrival.callsign || arrival.registration || '';
+ const aircraftDisplay = `${escapeHtml(aircraftId)}
(${escapeHtml(arrival.type || '')}) `;
+ const fromDisplay = await getAirportName(arrival.in_from || '');
+
+ let timeDisplay, sortTime;
+ if (arrival.status === 'LANDED' && arrival.landed_dt) {
+ // Show landed time if LANDED
+ const time = convertToLocalTime(arrival.landed_dt);
+ timeDisplay = `
${time} LANDED
`;
+ sortTime = arrival.landed_dt;
+ } else {
+ // Show ETA if BOOKED_IN
+ const time = convertToLocalTime(arrival.eta);
+ timeDisplay = `
${time} IN AIR
`;
+ sortTime = arrival.eta;
+ }
+
+ html = `
${aircraftDisplay} ${escapeHtml(fromDisplay)} ${timeDisplay} `;
+ sortKey = isLanded ? `1-${sortTime}` : `0-${sortTime}`; // 0=live, 1=completed
} else {
- timeDisplay = convertToLocalTime(arrival.eta);
+ // PPR
+ const aircraftId = arrival.ac_call || arrival.ac_reg || '';
+ const aircraftDisplay = `${escapeHtml(aircraftId)}
(${escapeHtml(arrival.ac_type || '')}) `;
+ const fromDisplay = await getAirportName(arrival.in_from || '');
+
+ let timeDisplay, sortTime;
+ if ((arrival.status === 'LANDED' || arrival.status === 'DEPARTED') && arrival.landed_dt) {
+ const time = convertToLocalTime(arrival.landed_dt);
+ timeDisplay = `
${time} LANDED
`;
+ sortTime = arrival.landed_dt;
+ } else {
+ timeDisplay = convertToLocalTime(arrival.eta);
+ sortTime = arrival.eta;
+ }
+
+ html = `
${aircraftDisplay} ${escapeHtml(fromDisplay)} ${timeDisplay} `;
+ sortKey = isLanded ? `1-${sortTime}` : `0-${sortTime}`;
}
- return `
-
- ${aircraftDisplay}
- ${escapeHtml(fromDisplay)}
- ${timeDisplay}
-
- `;
+ return { html, sortKey, isLanded };
}));
- tbody.innerHTML = rows.join('');
+ // Sort: live flights first (0) by ETA ascending, then completed flights (1) by time descending
+ rowsWithData.sort((a, b) => {
+ const aParts = a.sortKey.split('-');
+ const bParts = b.sortKey.split('-');
+ const aType = parseInt(aParts[0]);
+ const bType = parseInt(bParts[0]);
+
+ if (aType !== bType) return aType - bType; // Live before completed
+
+ // Sort by time
+ if (aType === 0) {
+ // Live flights: ascending (earliest first)
+ return aParts[1].localeCompare(bParts[1]);
+ } else {
+ // Completed flights: descending (most recent first)
+ return bParts[1].localeCompare(aParts[1]);
+ }
+ });
+
+ tbody.innerHTML = rowsWithData.map(r => r.html).join('');
} catch (error) {
console.error('Error loading arrivals:', error);
@@ -685,32 +742,87 @@
return;
}
- // Build rows asynchronously to lookup airport names
- const rows = await Promise.all(departures.map(async (departure) => {
- // Show callsign if available, otherwise registration
- const aircraftId = departure.ac_call || departure.ac_reg || '';
- const aircraftDisplay = `${escapeHtml(aircraftId)}
(${escapeHtml(departure.ac_type || '')}) `;
- const toDisplay = await getAirportName(departure.out_to || '');
+ // Build rows with metadata for sorting
+ const rowsWithData = await Promise.all(departures.map(async (departure) => {
+ const isLocal = departure.isLocalFlight;
+ const isDeparture = departure.isDeparture;
+ const isDeparted = departure.status === 'DEPARTED';
- // Show departed time if available, otherwise ETD
- let timeDisplay;
- if (departure.status === 'DEPARTED' && departure.departed_dt) {
- const time = convertToLocalTime(departure.departed_dt);
- timeDisplay = `
${time} DEPARTED
`;
+ let html = '';
+ let sortKey = '';
+
+ if (isLocal) {
+ // Local flight
+ const aircraftId = departure.ac_call || departure.ac_reg || '';
+ const aircraftDisplay = `${escapeHtml(aircraftId)}
(${escapeHtml(departure.ac_type || '')}) `;
+ const toDisplay = `
${getFlightTypeDisplay(departure.flight_type)} `;
+ const time = convertToLocalTime(departure.etd);
+ const timeDisplay = `
${escapeHtml(time)}
`;
+
+ html = `
${aircraftDisplay} ${toDisplay} ${timeDisplay} `;
+ sortKey = `0-${departure.etd}`; // Live flights, sort by ETD
+ } else if (isDeparture) {
+ // Departure to other airport
+ const aircraftId = departure.ac_call || departure.ac_reg || '';
+ const aircraftDisplay = `${escapeHtml(aircraftId)}
(${escapeHtml(departure.ac_type || '')}) `;
+ const toDisplay = await getAirportName(departure.out_to || '');
+
+ let timeDisplay, sortTime;
+ if (departure.status === 'DEPARTED' && departure.departed_dt) {
+ const time = convertToLocalTime(departure.departed_dt);
+ timeDisplay = `
${time} DEPARTED
`;
+ sortTime = departure.departed_dt;
+ } else {
+ const time = convertToLocalTime(departure.etd);
+ timeDisplay = `
${escapeHtml(time)}
`;
+ sortTime = departure.etd;
+ }
+
+ html = `
${aircraftDisplay} ${toDisplay} ${timeDisplay} `;
+ sortKey = isDeparted ? `1-${sortTime}` : `0-${sortTime}`; // 0=live, 1=completed
} else {
- timeDisplay = convertToLocalTime(departure.etd);
+ // PPR
+ const aircraftId = departure.ac_call || departure.ac_reg || '';
+ const aircraftDisplay = `${escapeHtml(aircraftId)}
(${escapeHtml(departure.ac_type || '')}) `;
+ const toDisplay = await getAirportName(departure.out_to || '');
+
+ let timeDisplay, sortTime;
+ if (departure.status === 'DEPARTED' && departure.departed_dt) {
+ const time = convertToLocalTime(departure.departed_dt);
+ timeDisplay = `
${time} DEPARTED
`;
+ sortTime = departure.departed_dt;
+ } else {
+ timeDisplay = convertToLocalTime(departure.etd);
+ sortTime = departure.etd;
+ }
+
+ html = `
${aircraftDisplay} ${escapeHtml(toDisplay)} ${timeDisplay} `;
+ sortKey = isDeparted ? `1-${sortTime}` : `0-${sortTime}`;
}
- return `
-
- ${aircraftDisplay}
- ${escapeHtml(toDisplay)}
- ${timeDisplay}
-
- `;
+ return { html, sortKey, isDeparted };
}));
- tbody.innerHTML = rows.join('');
+ // Sort: live flights first (0) by ETD ascending, then completed flights (1) by time descending
+ rowsWithData.sort((a, b) => {
+ const aParts = a.sortKey.split('-');
+ const bParts = b.sortKey.split('-');
+ const aType = parseInt(aParts[0]);
+ const bType = parseInt(bParts[0]);
+
+ if (aType !== bType) return aType - bType; // Live before completed
+
+ // Sort by time
+ if (aType === 0) {
+ // Live flights: ascending (earliest first)
+ return aParts[1].localeCompare(bParts[1]);
+ } else {
+ // Completed flights: descending (most recent first)
+ return bParts[1].localeCompare(aParts[1]);
+ }
+ });
+
+ tbody.innerHTML = rowsWithData.map(r => r.html).join('');
} catch (error) {
console.error('Error loading departures:', error);
@@ -725,6 +837,16 @@
return div.innerHTML;
}
+ // Map flight type enum to friendly name
+ function getFlightTypeDisplay(flightType) {
+ const typeMap = {
+ 'CIRCUITS': 'Circuit Traffic',
+ 'LOCAL': 'Local Area',
+ 'DEPARTURE': 'Departure'
+ };
+ return typeMap[flightType] || flightType;
+ }
+
// Load data on page load
window.addEventListener('load', function() {
// Initialize Christmas mode
diff --git a/web/lookups.js b/web/lookups.js
new file mode 100644
index 0000000..56f1d8d
--- /dev/null
+++ b/web/lookups.js
@@ -0,0 +1,503 @@
+/**
+ * Lookup Utilities - Reusable functions for aircraft and airport lookups
+ */
+
+/**
+ * Format aircraft registration based on UK rules
+ * - 5 alphabetic chars: add hyphen after first char (GIVYY -> G-IVYY)
+ * - Otherwise: just uppercase (N123AD -> N123AD)
+ */
+function formatAircraftRegistration(input) {
+ if (!input) return '';
+
+ const cleaned = input.trim().toUpperCase();
+
+ // If exactly 5 characters and all alphabetic, add hyphen
+ if (cleaned.length === 5 && /^[A-Z]{5}$/.test(cleaned)) {
+ return cleaned[0] + '-' + cleaned.substring(1);
+ }
+
+ // Otherwise just return uppercase version
+ return cleaned;
+}
+
+/**
+ * Creates a reusable lookup handler
+ * @param {string} fieldId - ID of the input field
+ * @param {string} resultsId - ID of the results container
+ * @param {function} selectCallback - Function to call when item is selected
+ * @param {object} options - Additional options (minLength, debounceMs, etc.)
+ */
+function createLookup(fieldId, resultsId, selectCallback, options = {}) {
+ const defaults = {
+ minLength: 2,
+ debounceMs: 300,
+ isAirport: false,
+ isAircraft: false,
+ maxResults: 10
+ };
+ const config = { ...defaults, ...options };
+ let debounceTimeout;
+ let currentResults = [];
+ let selectedIndex = -1;
+ let keydownHandlerAttached = false;
+
+ const lookup = {
+ // Main handler called by oninput
+ handle: (value) => {
+ clearTimeout(debounceTimeout);
+ selectedIndex = -1; // Reset selection on new input
+
+ if (!value || value.trim().length < config.minLength) {
+ lookup.clear();
+ return;
+ }
+
+ lookup.showSearching();
+ debounceTimeout = setTimeout(() => {
+ lookup.perform(value);
+ }, config.debounceMs);
+ },
+
+ // Attach keyboard handler once (for airport lookups)
+ attachKeyboardHandler: () => {
+ if (config.isAirport && !keydownHandlerAttached) {
+ try {
+ const inputField = document.getElementById(fieldId);
+ if (inputField) {
+ inputField.addEventListener('keydown', (e) => lookup.handleKeydown(e));
+ keydownHandlerAttached = true;
+ }
+ } catch (error) {
+ console.error('Error attaching keyboard handler:', error);
+ }
+ }
+ },
+
+ // Handle keyboard events
+ handleKeydown: (event) => {
+ if (!currentResults || currentResults.length === 0) return;
+
+ if (event.key === 'ArrowDown') {
+ event.preventDefault();
+ selectedIndex = Math.min(selectedIndex + 1, currentResults.length - 1);
+ lookup.updateSelection();
+ } else if (event.key === 'ArrowUp') {
+ event.preventDefault();
+ selectedIndex = Math.max(selectedIndex - 1, -1);
+ lookup.updateSelection();
+ } else if (event.key === 'Enter') {
+ event.preventDefault();
+ if (selectedIndex >= 0 && currentResults[selectedIndex]) {
+ lookup.selectResult(currentResults[selectedIndex]);
+ } else if (currentResults.length === 1) {
+ // Auto-select if only one result and Enter pressed
+ lookup.selectResult(currentResults[0]);
+ }
+ } else if (event.key === 'Escape') {
+ lookup.clear();
+ selectedIndex = -1;
+ }
+ },
+
+ // Update visual selection
+ updateSelection: () => {
+ const resultsDiv = document.getElementById(resultsId);
+ if (!resultsDiv) return;
+
+ const options = resultsDiv.querySelectorAll('.lookup-option');
+ options.forEach((opt, idx) => {
+ if (idx === selectedIndex) {
+ opt.classList.add('lookup-option-selected');
+ opt.scrollIntoView({ block: 'nearest' });
+ } else {
+ opt.classList.remove('lookup-option-selected');
+ }
+ });
+ },
+
+ // Select a result item
+ selectResult: (item) => {
+ const field = document.getElementById(fieldId);
+ if (field) {
+ field.value = item.icao;
+ }
+ lookup.clear();
+ currentResults = [];
+ selectedIndex = -1;
+ if (selectCallback) selectCallback(item.icao);
+ },
+
+ // Perform the lookup
+ perform: async (searchTerm) => {
+ try {
+ const cleanInput = searchTerm.trim();
+ let endpoint;
+
+ if (config.isAircraft) {
+ const cleaned = cleanInput.replace(/[^a-zA-Z0-9]/g, '').toUpperCase();
+ if (cleaned.length < config.minLength) {
+ lookup.clear();
+ return;
+ }
+ endpoint = `/api/v1/aircraft/lookup/${cleaned}`;
+ } else if (config.isAirport) {
+ endpoint = `/api/v1/airport/lookup/${encodeURIComponent(cleanInput)}`;
+ }
+
+ if (!endpoint) throw new Error('Invalid lookup type');
+
+ const response = await authenticatedFetch(endpoint);
+ if (!response.ok) throw new Error('Lookup failed');
+
+ const results = await response.json();
+ lookup.display(results, cleanInput);
+ } catch (error) {
+ console.error('Lookup error:', error);
+ lookup.showError();
+ }
+ },
+
+ // Display results
+ display: (results, searchTerm) => {
+ const resultsDiv = document.getElementById(resultsId);
+
+ if (config.isAircraft) {
+ // Aircraft lookup: auto-populate on single match, format input on no match
+ if (!results || results.length === 0) {
+ // Format the aircraft registration and auto-populate
+ const formatted = formatAircraftRegistration(searchTerm);
+ const field = document.getElementById(fieldId);
+ if (field) {
+ field.value = formatted;
+ }
+ resultsDiv.innerHTML = ''; // Clear results, field is auto-populated
+ } else if (results.length === 1) {
+ // Single match - auto-populate
+ const aircraft = results[0];
+ resultsDiv.innerHTML = `
+
+ ✓ ${aircraft.manufacturer_name || ''} ${aircraft.model || aircraft.type_code || ''}
+
+ `;
+
+ // Auto-populate the form fields
+ const field = document.getElementById(fieldId);
+ if (field) field.value = aircraft.registration;
+
+ // Also populate type field
+ let typeFieldId;
+ if (fieldId === 'ac_reg') {
+ typeFieldId = 'ac_type';
+ } else if (fieldId === 'local_registration') {
+ typeFieldId = 'local_type';
+ } else if (fieldId === 'book_in_registration') {
+ typeFieldId = 'book_in_type';
+ } else if (fieldId === 'overflight_registration') {
+ typeFieldId = 'overflight_type';
+ }
+
+ if (typeFieldId) {
+ const typeField = document.getElementById(typeFieldId);
+ if (typeField) typeField.value = aircraft.type_code || '';
+ }
+ } else {
+ // Multiple matches
+ resultsDiv.innerHTML = `
+
+ Multiple matches found (${results.length}) - please be more specific
+
+ `;
+ }
+ } else {
+ // Airport lookup: show list of options with keyboard navigation
+ if (!results || results.length === 0) {
+ resultsDiv.innerHTML = '
No matches found - will use as entered
';
+ currentResults = [];
+ return;
+ }
+
+ currentResults = results.slice(0, config.maxResults);
+ selectedIndex = -1; // Reset selection when showing new results
+
+ const matchText = currentResults.length === 1 ? 'Match found - press ENTER or click to select:' : 'Multiple matches found - use arrow keys and ENTER to select:';
+
+ let html = `
${matchText}
`;
+
+ currentResults.forEach((item, idx) => {
+ html += `
+
+
${item.icao}
+
${item.name || '-'}
+ ${item.city ? `
${item.city}, ${item.country}
` : ''}
+
+ `;
+ });
+
+ html += '
';
+ resultsDiv.innerHTML = html;
+
+ // Attach keyboard handler (only once per lookup instance)
+ lookup.attachKeyboardHandler();
+ }
+ },
+
+ // Show searching state
+ showSearching: () => {
+ const resultsDiv = document.getElementById(resultsId);
+ if (resultsDiv) {
+ resultsDiv.innerHTML = '
Searching...
';
+ }
+ },
+
+ // Show error state
+ showError: () => {
+ const resultsDiv = document.getElementById(resultsId);
+ if (resultsDiv) {
+ resultsDiv.innerHTML = '
Lookup failed - will use as entered
';
+ }
+ },
+
+ // Clear results
+ clear: () => {
+ const resultsDiv = document.getElementById(resultsId);
+ if (resultsDiv) {
+ resultsDiv.innerHTML = '';
+ }
+ },
+
+ // Set the selected value
+ setValue: (value) => {
+ const field = document.getElementById(fieldId);
+ if (field) {
+ field.value = value;
+ }
+ lookup.clear();
+ if (selectCallback) selectCallback(value);
+ }
+ };
+
+ return lookup;
+}
+
+/**
+ * Global lookup manager for all lookups on the page
+ */
+const lookupManager = {
+ lookups: {},
+
+ // Register a lookup instance
+ register: (name, lookup) => {
+ lookupManager.lookups[name] = lookup;
+ },
+
+ // Generic item selection handler
+ selectItem: (resultsId, fieldId, itemCode) => {
+ const field = document.getElementById(fieldId);
+ if (field) {
+ field.value = itemCode;
+ }
+ const resultsDiv = document.getElementById(resultsId);
+ if (resultsDiv) {
+ resultsDiv.innerHTML = '';
+ }
+ }
+};
+
+// Initialize all lookups when page loads
+function initializeLookups() {
+ // Create reusable lookup instances
+ const arrivalAirportLookup = createLookup(
+ 'in_from',
+ 'arrival-airport-lookup-results',
+ null,
+ { isAirport: true, minLength: 2 }
+ );
+ lookupManager.register('arrival-airport', arrivalAirportLookup);
+
+ const departureAirportLookup = createLookup(
+ 'out_to',
+ 'departure-airport-lookup-results',
+ null,
+ { isAirport: true, minLength: 2 }
+ );
+ lookupManager.register('departure-airport', departureAirportLookup);
+
+ const localOutToLookup = createLookup(
+ 'local_out_to',
+ 'local-out-to-lookup-results',
+ null,
+ { isAirport: true, minLength: 2 }
+ );
+ lookupManager.register('local-out-to', localOutToLookup);
+
+ const aircraftLookup = createLookup(
+ 'ac_reg',
+ 'aircraft-lookup-results',
+ null,
+ { isAircraft: true, minLength: 4, debounceMs: 300 }
+ );
+ lookupManager.register('aircraft', aircraftLookup);
+
+ const localAircraftLookup = createLookup(
+ 'local_registration',
+ 'local-aircraft-lookup-results',
+ null,
+ { isAircraft: true, minLength: 4, debounceMs: 300 }
+ );
+ lookupManager.register('local-aircraft', localAircraftLookup);
+
+ const bookInAircraftLookup = createLookup(
+ 'book_in_registration',
+ 'book-in-aircraft-lookup-results',
+ null,
+ { isAircraft: true, minLength: 4, debounceMs: 300 }
+ );
+ lookupManager.register('book-in-aircraft', bookInAircraftLookup);
+
+ const bookInArrivalAirportLookup = createLookup(
+ 'book_in_from',
+ 'book-in-arrival-airport-lookup-results',
+ null,
+ { isAirport: true, minLength: 2 }
+ );
+ lookupManager.register('book-in-arrival-airport', bookInArrivalAirportLookup);
+
+ const overflightAircraftLookup = createLookup(
+ 'overflight_registration',
+ 'overflight-aircraft-lookup-results',
+ null,
+ { isAircraft: true, minLength: 4, debounceMs: 300 }
+ );
+ lookupManager.register('overflight-aircraft', overflightAircraftLookup);
+
+ const overflightDepartureLookup = createLookup(
+ 'overflight_departure_airfield',
+ 'overflight-departure-airport-lookup-results',
+ null,
+ { isAirport: true, minLength: 2 }
+ );
+ lookupManager.register('overflight-departure', overflightDepartureLookup);
+
+ const overflightDestinationLookup = createLookup(
+ 'overflight_destination_airfield',
+ 'overflight-destination-airport-lookup-results',
+ null,
+ { isAirport: true, minLength: 2 }
+ );
+ lookupManager.register('overflight-destination', overflightDestinationLookup);
+
+ // Attach keyboard handlers to airport input fields
+ setTimeout(() => {
+ if (arrivalAirportLookup.attachKeyboardHandler) arrivalAirportLookup.attachKeyboardHandler();
+ if (departureAirportLookup.attachKeyboardHandler) departureAirportLookup.attachKeyboardHandler();
+ if (localOutToLookup.attachKeyboardHandler) localOutToLookup.attachKeyboardHandler();
+ if (bookInArrivalAirportLookup.attachKeyboardHandler) bookInArrivalAirportLookup.attachKeyboardHandler();
+ if (overflightDepartureLookup.attachKeyboardHandler) overflightDepartureLookup.attachKeyboardHandler();
+ if (overflightDestinationLookup.attachKeyboardHandler) overflightDestinationLookup.attachKeyboardHandler();
+ }, 100);
+}
+
+// Initialize on DOM ready or immediately if already loaded
+if (document.readyState === 'loading') {
+ document.addEventListener('DOMContentLoaded', initializeLookups);
+} else {
+ initializeLookups();
+}
+
+/**
+ * Convenience wrapper functions for backward compatibility
+ */
+function handleArrivalAirportLookup(value) {
+ const lookup = lookupManager.lookups['arrival-airport'];
+ if (lookup) lookup.handle(value);
+}
+
+function handleDepartureAirportLookup(value) {
+ const lookup = lookupManager.lookups['departure-airport'];
+ if (lookup) lookup.handle(value);
+}
+
+function handleLocalOutToAirportLookup(value) {
+ const lookup = lookupManager.lookups['local-out-to'];
+ if (lookup) lookup.handle(value);
+}
+
+function handleAircraftLookup(value) {
+ const lookup = lookupManager.lookups['aircraft'];
+ if (lookup) lookup.handle(value);
+}
+
+function handleLocalAircraftLookup(value) {
+ const lookup = lookupManager.lookups['local-aircraft'];
+ if (lookup) lookup.handle(value);
+}
+
+function clearArrivalAirportLookup() {
+ const lookup = lookupManager.lookups['arrival-airport'];
+ if (lookup) lookup.clear();
+}
+
+function clearDepartureAirportLookup() {
+ const lookup = lookupManager.lookups['departure-airport'];
+ if (lookup) lookup.clear();
+}
+
+function clearLocalOutToAirportLookup() {
+ const lookup = lookupManager.lookups['local-out-to'];
+ if (lookup) lookup.clear();
+}
+
+function clearAircraftLookup() {
+ const lookup = lookupManager.lookups['aircraft'];
+ if (lookup) lookup.clear();
+}
+
+function clearLocalAircraftLookup() {
+ const lookup = lookupManager.lookups['local-aircraft'];
+ if (lookup) lookup.clear();
+}
+
+function selectArrivalAirport(icaoCode) {
+ lookupManager.selectItem('arrival-airport-lookup-results', 'in_from', icaoCode);
+}
+
+function selectDepartureAirport(icaoCode) {
+ lookupManager.selectItem('departure-airport-lookup-results', 'out_to', icaoCode);
+}
+
+function selectLocalOutToAirport(icaoCode) {
+ lookupManager.selectItem('local-out-to-lookup-results', 'local_out_to', icaoCode);
+}
+
+function selectLocalAircraft(registration) {
+ lookupManager.selectItem('local-aircraft-lookup-results', 'local_registration', registration);
+}
+
+function handleBookInAircraftLookup(value) {
+ const lookup = lookupManager.lookups['book-in-aircraft'];
+ if (lookup) lookup.handle(value);
+}
+
+function handleBookInArrivalAirportLookup(value) {
+ const lookup = lookupManager.lookups['book-in-arrival-airport'];
+ if (lookup) lookup.handle(value);
+}
+
+function clearBookInAircraftLookup() {
+ const lookup = lookupManager.lookups['book-in-aircraft'];
+ if (lookup) lookup.clear();
+}
+
+function clearBookInArrivalAirportLookup() {
+ const lookup = lookupManager.lookups['book-in-arrival-airport'];
+ if (lookup) lookup.clear();
+}
+
+function selectBookInAircraft(registration) {
+ lookupManager.selectItem('book-in-aircraft-lookup-results', 'book_in_registration', registration);
+}
+
+function selectBookInArrivalAirport(icaoCode) {
+ lookupManager.selectItem('book-in-arrival-airport-lookup-results', 'book_in_from', icaoCode);
+}
diff --git a/web/reports.html b/web/reports.html
index ab1ca5f..37bbca3 100644
--- a/web/reports.html
+++ b/web/reports.html
@@ -22,23 +22,32 @@
color: white;
padding: 0.5rem 2rem;
display: flex;
- justify-content: space-between;
+ justify-content: center;
align-items: center;
+ gap: 2rem;
box-shadow: 0 2px 10px rgba(0,0,0,0.1);
}
+ .title {
+ order: 2;
+ flex: 1;
+ text-align: center;
+ }
+
.title h1 {
margin: 0;
font-size: 1.5rem;
}
.menu-buttons {
+ order: 1;
display: flex;
gap: 1rem;
align-items: center;
}
.top-bar .user-info {
+ order: 3;
font-size: 0.9rem;
opacity: 0.9;
display: flex;
@@ -227,6 +236,45 @@
.status.canceled { background: #ffebee; color: #d32f2f; }
.status.deleted { background: #f3e5f5; color: #7b1fa2; }
+ .summary-box {
+ background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+ color: white;
+ border-radius: 8px;
+ padding: 2rem;
+ margin-bottom: 2rem;
+ box-shadow: 0 4px 15px rgba(0,0,0,0.2);
+ }
+
+ .summary-title {
+ font-size: 1.5rem;
+ font-weight: 600;
+ margin-bottom: 1.5rem;
+ }
+
+ .summary-grid {
+ display: grid;
+ grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+ gap: 1.5rem;
+ }
+
+ .summary-item {
+ background: rgba(255,255,255,0.1);
+ border-radius: 6px;
+ padding: 1rem;
+ border-left: 4px solid rgba(255,255,255,0.3);
+ }
+
+ .summary-item-label {
+ font-size: 0.85rem;
+ opacity: 0.9;
+ margin-bottom: 0.5rem;
+ }
+
+ .summary-item-value {
+ font-size: 2rem;
+ font-weight: 700;
+ }
+
.no-data {
text-align: center;
padding: 3rem;
@@ -313,14 +361,14 @@
-
-
📊 PPR Reports
-
+
+
📊 PPR Reports
+
Logged in as:
Loading... |
Logout
@@ -330,18 +378,26 @@
-
-
-
Date From:
-
+
+
+
+ 📅 Today
+ 📆 This Week
+ 📊 This Month
+ 📋 Custom Range
-
-
Date To:
-
+
+
+
+ to
+
-
-
Status:
-
+
+
+
+ Status:
+
All Statuses
New
Confirmed
@@ -351,23 +407,91 @@
Deleted
-
-
Search:
-
+
+
+
+ Search:
+
-
-
+
+
+
+
🔍 Search
-
+
🗑️ Clear
+
📊 Movements Summary
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Status
+ Type
+ Aircraft
+ Aircraft Type
+ Callsign
+ From
+ To
+ ETA / ETD / Called
+ Landed / Departed / QSY
+ Circuits
+
+
+
+
+
+
+
+
+
+
No other flights found
+
No flights match your current filters.
+
+
@@ -431,22 +603,156 @@
let currentUser = null;
let accessToken = null;
let currentPPRs = []; // Store current results for export
+ let currentOtherFlights = []; // Store other flights for export
+ let otherFlightsFilterType = null; // Track which non-PPR flight type is selected for filtering
+
+ // Load UI configuration from API
+ async function loadUIConfig() {
+ try {
+ const response = await fetch('/api/v1/public/config');
+ if (response.ok) {
+ const config = await response.json();
+
+ // Update tower title
+ const titleElement = document.getElementById('tower-title');
+ if (titleElement && config.tag) {
+ titleElement.innerHTML = `📊 Reports ${config.tag}`;
+ }
+
+ // Update top bar gradient
+ const topBar = document.querySelector('.top-bar');
+ if (topBar && config.top_bar_gradient_start && config.top_bar_gradient_end) {
+ topBar.style.background = `linear-gradient(135deg, ${config.top_bar_gradient_start}, ${config.top_bar_gradient_end})`;
+ }
+
+ // Update page title
+ if (config.tag) {
+ document.title = `PPR Reports - ${config.tag}`;
+ }
+
+ // Optionally indicate environment (e.g., add to title if not production)
+ if (config.environment && config.environment !== 'production') {
+ const envIndicator = ` (${config.environment.toUpperCase()})`;
+ if (titleElement) {
+ titleElement.innerHTML += envIndicator;
+ }
+ if (document.title) {
+ document.title += envIndicator;
+ }
+ }
+ }
+ } catch (error) {
+ console.warn('Failed to load UI config:', error);
+ }
+ }
// Initialize the page
async function initializePage() {
+ loadUIConfig(); // Load UI configuration first
await initializeAuth();
setupDefaultDateRange();
await loadReports();
}
- // Set default date range to current month
+ // Set default date range to today
function setupDefaultDateRange() {
+ setDateRangeToday();
+ }
+
+ // Toggle custom date range picker
+ function toggleCustomRange() {
+ const container = document.getElementById('custom-range-container');
+ const customBtn = document.getElementById('filter-custom');
+
+ const isVisible = container.style.display !== 'none';
+ container.style.display = isVisible ? 'none' : 'flex';
+
+ // Update button style
+ if (isVisible) {
+ customBtn.classList.remove('btn-primary');
+ customBtn.classList.add('btn-secondary');
+ } else {
+ customBtn.classList.remove('btn-secondary');
+ customBtn.classList.add('btn-primary');
+ // Focus on the first date input when opening
+ document.getElementById('date-from').focus();
+ }
+ }
+
+ // Set date range to today
+ function setDateRangeToday() {
+ const today = new Date().toISOString().split('T')[0];
+ document.getElementById('date-from').value = today;
+ document.getElementById('date-to').value = today;
+
+ // Hide custom range picker if it's open
+ document.getElementById('custom-range-container').style.display = 'none';
+
+ updateFilterButtonStyles('today');
+ loadReports();
+ }
+
+ // Set date range to this week (Monday to Sunday)
+ function setDateRangeThisWeek() {
+ const now = new Date();
+ const dayOfWeek = now.getDay();
+ const diff = now.getDate() - dayOfWeek + (dayOfWeek === 0 ? -6 : 1); // Adjust when day is Sunday
+ const monday = new Date(now.setDate(diff));
+ const sunday = new Date(now.setDate(diff + 6));
+
+ document.getElementById('date-from').value = monday.toISOString().split('T')[0];
+ document.getElementById('date-to').value = sunday.toISOString().split('T')[0];
+
+ // Hide custom range picker if it's open
+ document.getElementById('custom-range-container').style.display = 'none';
+
+ updateFilterButtonStyles('week');
+ loadReports();
+ }
+
+ // Set date range to this month
+ function setDateRangeThisMonth() {
const now = new Date();
const firstDay = new Date(now.getFullYear(), now.getMonth(), 1);
const lastDay = new Date(now.getFullYear(), now.getMonth() + 1, 0);
-
+
document.getElementById('date-from').value = firstDay.toISOString().split('T')[0];
document.getElementById('date-to').value = lastDay.toISOString().split('T')[0];
+
+ // Hide custom range picker if it's open
+ document.getElementById('custom-range-container').style.display = 'none';
+
+ updateFilterButtonStyles('month');
+ loadReports();
+ }
+
+ // Update button styles to show which filter is active
+ function updateFilterButtonStyles(activeFilter) {
+ const todayBtn = document.getElementById('filter-today');
+ const weekBtn = document.getElementById('filter-week');
+ const monthBtn = document.getElementById('filter-month');
+
+ // Reset all buttons
+ [todayBtn, weekBtn, monthBtn].forEach(btn => {
+ btn.classList.remove('btn-primary');
+ btn.classList.add('btn-secondary');
+ });
+
+ // Highlight active button
+ switch(activeFilter) {
+ case 'today':
+ todayBtn.classList.remove('btn-secondary');
+ todayBtn.classList.add('btn-primary');
+ break;
+ case 'week':
+ weekBtn.classList.remove('btn-secondary');
+ weekBtn.classList.add('btn-primary');
+ break;
+ case 'month':
+ monthBtn.classList.remove('btn-secondary');
+ monthBtn.classList.add('btn-primary');
+ break;
+ }
}
// Authentication management
@@ -466,7 +772,7 @@
}
// No valid cached token, redirect to admin
- window.location.href = 'admin.html';
+ window.location.href = 'admin';
}
function logout() {
@@ -475,13 +781,13 @@
localStorage.removeItem('ppr_token_expiry');
accessToken = null;
currentUser = null;
- window.location.href = 'admin.html';
+ window.location.href = 'admin';
}
// Enhanced fetch wrapper with token expiry handling
async function authenticatedFetch(url, options = {}) {
if (!accessToken) {
- window.location.href = 'admin.html';
+ window.location.href = 'admin';
throw new Error('No access token available');
}
@@ -508,6 +814,9 @@
document.getElementById('reports-loading').style.display = 'block';
document.getElementById('reports-table-content').style.display = 'none';
document.getElementById('reports-no-data').style.display = 'none';
+ document.getElementById('other-flights-loading').style.display = 'block';
+ document.getElementById('other-flights-table-content').style.display = 'none';
+ document.getElementById('other-flights-no-data').style.display = 'none';
try {
const dateFrom = document.getElementById('date-from').value;
@@ -521,13 +830,20 @@
if (dateTo) url += `&date_to=${dateTo}`;
if (status) url += `&status=${status}`;
- const response = await authenticatedFetch(url);
+ // Fetch all data in parallel
+ const [pprResponse, arrivalsResponse, departuresResponse, localFlightsResponse, overflightsResponse] = await Promise.all([
+ authenticatedFetch(url),
+ authenticatedFetch(`/api/v1/arrivals/?limit=10000${dateFrom ? `&date_from=${dateFrom}` : ''}${dateTo ? `&date_to=${dateTo}` : ''}`),
+ authenticatedFetch(`/api/v1/departures/?limit=10000${dateFrom ? `&date_from=${dateFrom}` : ''}${dateTo ? `&date_to=${dateTo}` : ''}`),
+ authenticatedFetch(`/api/v1/local-flights/?limit=10000${dateFrom ? `&date_from=${dateFrom}` : ''}${dateTo ? `&date_to=${dateTo}` : ''}`),
+ authenticatedFetch(`/api/v1/overflights/?limit=10000${dateFrom ? `&date_from=${dateFrom}` : ''}${dateTo ? `&date_to=${dateTo}` : ''}`)
+ ]);
- if (!response.ok) {
+ if (!pprResponse.ok) {
throw new Error('Failed to fetch PPR records');
}
- let pprs = await response.json();
+ let pprs = await pprResponse.json();
// Apply client-side search filtering
if (search) {
@@ -543,6 +859,78 @@
currentPPRs = pprs; // Store for export
displayReports(pprs);
+
+ // Process other flights
+ let otherFlights = [];
+
+ if (arrivalsResponse.ok) {
+ const arrivals = await arrivalsResponse.json();
+ otherFlights.push(...arrivals.map(f => ({
+ ...f,
+ flightType: 'ARRIVAL',
+ aircraft_type: f.type,
+ timeField: f.eta || f.landed_dt,
+ fromField: f.in_from,
+ toField: 'EGFH'
+ })));
+ }
+
+ if (departuresResponse.ok) {
+ const departures = await departuresResponse.json();
+ otherFlights.push(...departures.map(f => ({
+ ...f,
+ flightType: 'DEPARTURE',
+ aircraft_type: f.type,
+ timeField: f.etd || f.departed_dt,
+ fromField: 'EGFH',
+ toField: f.out_to
+ })));
+ }
+
+ if (localFlightsResponse.ok) {
+ const localFlights = await localFlightsResponse.json();
+ otherFlights.push(...localFlights.map(f => ({
+ ...f,
+ flightType: f.flight_type === 'CIRCUITS' ? 'CIRCUIT' : f.flight_type,
+ aircraft_type: f.type,
+ circuits: f.circuits,
+ timeField: f.departed_dt,
+ fromField: 'EGFH',
+ toField: 'EGFH'
+ })));
+ }
+
+ if (overflightsResponse.ok) {
+ const overflights = await overflightsResponse.json();
+ otherFlights.push(...overflights.map(f => ({
+ ...f,
+ flightType: 'OVERFLIGHT',
+ aircraft_type: f.type,
+ circuits: null,
+ timeField: f.call_dt,
+ fromField: f.departure_airfield,
+ toField: f.destination_airfield,
+ callsign: f.registration
+ })));
+ }
+
+ // Apply search filtering to other flights
+ if (search) {
+ const searchLower = search.toLowerCase();
+ otherFlights = otherFlights.filter(f =>
+ (f.registration && f.registration.toLowerCase().includes(searchLower)) ||
+ (f.callsign && f.callsign.toLowerCase().includes(searchLower)) ||
+ (f.fromField && f.fromField.toLowerCase().includes(searchLower)) ||
+ (f.toField && f.toField.toLowerCase().includes(searchLower))
+ );
+ }
+
+ currentOtherFlights = otherFlights;
+ displayOtherFlights(otherFlights);
+
+ // Calculate and display movements summary
+ calculateMovementsSummary(pprs, otherFlights, dateFrom, dateTo);
+
} catch (error) {
console.error('Error loading reports:', error);
if (error.message !== 'Session expired. Please log in again.') {
@@ -551,6 +939,94 @@
}
document.getElementById('reports-loading').style.display = 'none';
+ document.getElementById('other-flights-loading').style.display = 'none';
+ }
+
+ // Calculate and display movements summary
+ function calculateMovementsSummary(pprs, otherFlights, dateFrom, dateTo) {
+ let pprArrivals = 0; // PPR landings
+ let pprDepartures = 0; // PPR takeoffs
+ let localFlightsMovements = 0;
+ let circuitsMovements = 0;
+ let nonPprArrivals = 0;
+ let nonPprDepartures = 0;
+
+ // Format date range for display
+ let dateRangeText = '';
+ if (dateFrom && dateTo && dateFrom === dateTo) {
+ // Single day
+ const date = new Date(dateFrom + 'T00:00:00Z');
+ dateRangeText = `for ${date.toLocaleDateString('en-GB', { day: '2-digit', month: '2-digit', year: 'numeric' })}`;
+ } else if (dateFrom && dateTo) {
+ // Date range
+ const fromDate = new Date(dateFrom + 'T00:00:00Z');
+ const toDate = new Date(dateTo + 'T00:00:00Z');
+ const fromText = fromDate.toLocaleDateString('en-GB', { day: '2-digit', month: '2-digit', year: 'numeric' });
+ const toText = toDate.toLocaleDateString('en-GB', { day: '2-digit', month: '2-digit', year: 'numeric' });
+ dateRangeText = `for ${fromText} to ${toText}`;
+ } else if (dateFrom) {
+ const date = new Date(dateFrom + 'T00:00:00Z');
+ dateRangeText = `from ${date.toLocaleDateString('en-GB', { day: '2-digit', month: '2-digit', year: 'numeric' })}`;
+ } else if (dateTo) {
+ const date = new Date(dateTo + 'T00:00:00Z');
+ dateRangeText = `until ${date.toLocaleDateString('en-GB', { day: '2-digit', month: '2-digit', year: 'numeric' })}`;
+ }
+
+ // Update summary title with date range
+ const summaryTitle = document.querySelector('.summary-title');
+ if (summaryTitle) {
+ summaryTitle.textContent = `📊 Movements Summary ${dateRangeText}`;
+ }
+
+ // PPR movements (excluding CANCELED):
+ // - LANDED = 1 arrival (landing)
+ // - DEPARTED = 1 departure + 1 arrival (because departure implies a prior landing)
+ pprs.filter(ppr => ppr.status !== 'CANCELED').forEach(ppr => {
+ if (ppr.status === 'LANDED') {
+ pprArrivals += 1;
+ } else if (ppr.status === 'DEPARTED') {
+ pprDepartures += 1;
+ pprArrivals += 1; // Each departure implies a landing happened
+ }
+ });
+
+ // Other flights movements (excluding CANCELLED)
+ let overflightCount = 0;
+ otherFlights.filter(flight => flight.status !== 'CANCELLED').forEach(flight => {
+ if (flight.flightType === 'ARRIVAL') {
+ nonPprArrivals += 1;
+ } else if (flight.flightType === 'DEPARTURE') {
+ nonPprDepartures += 1;
+ } else if (flight.flightType === 'LOCAL') {
+ // 2 movements (takeoff + landing) for the flight itself
+ localFlightsMovements += 2;
+ } else if (flight.flightType === 'CIRCUIT') {
+ // 2 movements (takeoff + landing) plus the circuit count
+ const circuits = flight.circuits || 0;
+ circuitsMovements += 2 + circuits;
+ } else if (flight.flightType === 'OVERFLIGHT') {
+ // 1 movement for each overflight (they're just talking to tower)
+ overflightCount += 1;
+ }
+ });
+
+ const pprTotal = pprArrivals + pprDepartures;
+ const nonPprTotal = localFlightsMovements + circuitsMovements + nonPprArrivals + nonPprDepartures + overflightCount;
+ const grandTotal = pprTotal + nonPprTotal;
+
+ // Update the summary display
+ document.getElementById('ppr-arrivals').textContent = pprArrivals;
+ document.getElementById('ppr-departures').textContent = pprDepartures;
+ document.getElementById('ppr-total').textContent = pprTotal;
+ document.getElementById('overflights-count').textContent = overflightCount;
+
+ document.getElementById('local-flights-movements').textContent = localFlightsMovements;
+ document.getElementById('circuits-movements').textContent = circuitsMovements;
+ document.getElementById('non-ppr-arrivals').textContent = nonPprArrivals;
+ document.getElementById('non-ppr-departures').textContent = nonPprDepartures;
+ document.getElementById('non-ppr-total').textContent = nonPprTotal;
+
+ document.getElementById('grand-total-movements').textContent = grandTotal;
}
// Display reports in table
@@ -615,6 +1091,156 @@
}
}
+ // Filter other flights by type
+ function filterOtherFlights(flightType) {
+ // Toggle filter if clicking the same type
+ if (otherFlightsFilterType === flightType) {
+ otherFlightsFilterType = null;
+ } else {
+ otherFlightsFilterType = flightType;
+ }
+
+ // Show/hide PPR section based on filter
+ const pprSection = document.getElementById('ppr-reports-section');
+ if (pprSection) {
+ pprSection.style.display = otherFlightsFilterType ? 'none' : 'block';
+ }
+
+ // Update visual indication of active filter
+ updateFilterIndicators();
+
+ // Re-display flights with new filter
+ displayOtherFlights(currentOtherFlights);
+ }
+
+ // Update visual indicators for active filter
+ function updateFilterIndicators() {
+ // Select all clickable non-PPR summary items (those with onclick attribute)
+ const summaryItems = document.querySelectorAll('.summary-item[onclick*="filterOtherFlights"]');
+ summaryItems.forEach(item => {
+ item.style.opacity = '1';
+ item.style.borderLeftColor = '';
+ item.style.borderLeftWidth = '0';
+ });
+
+ if (otherFlightsFilterType) {
+ // Get the ID of the selected filter's summary item
+ let selectedId = '';
+ switch(otherFlightsFilterType) {
+ case 'LOCAL':
+ selectedId = 'local-flights-movements';
+ break;
+ case 'CIRCUIT':
+ selectedId = 'circuits-movements';
+ break;
+ case 'ARRIVAL':
+ selectedId = 'non-ppr-arrivals';
+ break;
+ case 'DEPARTURE':
+ selectedId = 'non-ppr-departures';
+ break;
+ case 'OVERFLIGHT':
+ selectedId = 'overflights-count';
+ break;
+ }
+
+ // Find and highlight the selected item
+ if (selectedId) {
+ const selectedElement = document.getElementById(selectedId);
+ if (selectedElement) {
+ const summaryItem = selectedElement.closest('.summary-item');
+ if (summaryItem) {
+ summaryItem.style.borderLeftColor = '#4CAF50';
+ summaryItem.style.borderLeftWidth = '4px';
+ summaryItem.style.opacity = '1';
+ }
+ }
+ }
+
+ // Dim other items that are clickable (non-PPR items)
+ const allSummaryItems = document.querySelectorAll('.summary-item[onclick]');
+ allSummaryItems.forEach(item => {
+ if (item.querySelector('#' + selectedId) === null) {
+ item.style.opacity = '0.5';
+ }
+ });
+ }
+ }
+
+ // Display other flights in table
+ function displayOtherFlights(flights) {
+ const tbody = document.getElementById('other-flights-table-body');
+ const tableInfo = document.getElementById('other-flights-info');
+
+ // Apply filter if one is selected
+ let filteredFlights = flights;
+ if (otherFlightsFilterType) {
+ filteredFlights = flights.filter(flight => flight.flightType === otherFlightsFilterType);
+ }
+
+ tableInfo.textContent = `${filteredFlights.length} flights found` + (otherFlightsFilterType ? ` (filtered by ${otherFlightsFilterType})` : '');
+
+ if (filteredFlights.length === 0) {
+ document.getElementById('other-flights-no-data').style.display = 'block';
+ document.getElementById('other-flights-table-content').style.display = 'none';
+ return;
+ }
+
+ // Sort by time field (ascending)
+ filteredFlights.sort((a, b) => {
+ const aTime = a.timeField;
+ const bTime = b.timeField;
+ if (!aTime) return 1;
+ if (!bTime) return -1;
+ return new Date(aTime) - new Date(bTime);
+ });
+
+ tbody.innerHTML = '';
+ document.getElementById('other-flights-table-content').style.display = 'block';
+ document.getElementById('other-flights-no-data').style.display = 'none';
+
+ for (const flight of filteredFlights) {
+ const row = document.createElement('tr');
+
+ const typeLabel = flight.flightType;
+ const registration = flight.registration || '-';
+ const aircraftType = flight.aircraft_type || '-';
+ const callsign = flight.callsign || '-';
+ const from = flight.fromField || '-';
+ const to = flight.toField || '-';
+ const timeDisplay = flight.timeField ? formatDateTime(flight.timeField) : '-';
+
+ // Different display for different flight types
+ let actualDisplay = '-';
+ if (flight.flightType === 'ARRIVAL') {
+ actualDisplay = flight.landed_dt ? formatDateTime(flight.landed_dt) : '-';
+ } else if (flight.flightType === 'OVERFLIGHT') {
+ // For overflights, show qsy_dt (frequency change time)
+ actualDisplay = flight.qsy_dt ? formatDateTime(flight.qsy_dt) : '-';
+ } else {
+ actualDisplay = flight.departed_dt ? formatDateTime(flight.departed_dt) : '-';
+ }
+
+ const status = flight.status || (flight.flightType === 'CIRCUIT' ? 'COMPLETED' : 'PENDING');
+ const circuits = (flight.flightType === 'CIRCUIT' || flight.flightType === 'LOCAL') ? (flight.circuits > 0 ? flight.circuits : '-') : '-';
+
+ row.innerHTML = `
+
${status}
+
${typeLabel}
+
${registration}
+
${aircraftType}
+
${callsign}
+
${from}
+
${to}
+
${timeDisplay}
+
${actualDisplay}
+
${circuits}
+ `;
+
+ tbody.appendChild(row);
+ }
+ }
+
function formatDateTime(dateStr) {
if (!dateStr) return '-';
let utcDateStr = dateStr;
@@ -683,6 +1309,35 @@
downloadCSV(headers, csvData, 'ppr_reports.csv');
}
+ function exportOtherFlightsToCSV() {
+ if (currentOtherFlights.length === 0) {
+ showNotification('No data to export', true);
+ return;
+ }
+
+ const headers = [
+ 'Flight Type', 'Aircraft Registration', 'Aircraft Type', 'Callsign', 'From', 'To',
+ 'ETA/ETD', 'Landed/Departed', 'Status', 'Circuits'
+ ];
+
+ const csvData = currentOtherFlights.map(flight => [
+ flight.flightType,
+ flight.registration || '',
+ flight.aircraft_type || '',
+ flight.callsign || '',
+ flight.fromField || '',
+ flight.toField || '',
+ flight.timeField ? formatDateTime(flight.timeField) : '',
+ flight.flightType === 'ARRIVAL'
+ ? (flight.landed_dt ? formatDateTime(flight.landed_dt) : '')
+ : (flight.departed_dt ? formatDateTime(flight.departed_dt) : ''),
+ flight.status || (flight.flightType === 'CIRCUIT' ? 'COMPLETED' : 'PENDING'),
+ (flight.flightType === 'CIRCUIT' || flight.flightType === 'LOCAL') ? (flight.circuits || '') : ''
+ ]);
+
+ downloadCSV(headers, csvData, 'other_flights_reports.csv');
+ }
+
function downloadCSV(headers, data, filename) {
const csvContent = [
headers.join(','),