Merge pull request #3 from sebastiankrll/feature/pilot-panel

Feature/pilot panel

Author: sebastiankrll

apps/api/src/index.ts

@@ -56,12 +56,12 @@ app.get("/data/init", async (_req, res) => {
 	}
 });
 
-app.get("/data/pilot/:callsign", async (req, res) => {
+app.get("/api/data/pilot/:id", async (req, res) => {
 	try {
-		const { callsign } = req.params;
-		console.log("Requested pilot:", callsign);
+		const { id } = req.params;
+		console.log("Requested pilot:", id);
 
-		const pilot = await rdsGetSingle(`pilot:${callsign}`);
+		const pilot = await rdsGetSingle(`pilot:${id}`);
 		if (!pilot) return res.status(404).json({ error: "Pilot not found" });
 
 		res.json(pilot);
@@ -115,6 +115,21 @@ app.get("/data/track/:id", async (req, res) => {
 	}
 });
 
+app.get("/api/data/aircraft/:reg", async (req, res) => {
+	try {
+		const { reg } = req.params;
+		console.log("Requested aircraft:", reg);
+
+		const aircraft = await rdsGetSingle(`fleet:${reg}`);
+		if (!aircraft) return res.status(404).json({ error: "Aircraft not found" });
+
+		res.json(aircraft);
+	} catch (err) {
+		console.error(err);
+		res.status(500).json({ error: "Internal server error" });
+	}
+});
+
 const PORT = process.env.API_PORT || 3001;
 app.listen(PORT, () => {
 	console.log(`Express API listening on port ${PORT}`);

apps/ingestion/src/index.ts

@@ -49,7 +49,7 @@ async function fetchVatsimData(): Promise<void> {
 			rdsSetSingle("ws:all", all);
 
 			// Set pilots, controllers and airports data in redis
-			rdsSetMultiple(pilotsLong, "pilot", (p) => p.callsign, "pilots:live", 120);
+			rdsSetMultiple(pilotsLong, "pilot", (p) => p.id, "pilots:live", 120);
 			rdsSetMultiple(controllersLong, "controller", (c) => c.callsign, "controllers:live", 120);
 			rdsSetMultiple(airportsLong, "airport", (a) => a.icao, "airports:live", 120);
 

apps/ingestion/src/pilot.ts

@@ -1,4 +1,4 @@
-import { rdsGetMultiple } from "@sk/db/redis";
+import { rdsGetMultiple, rdsGetSingle } from "@sk/db/redis";
 import type { StaticAirport } from "@sk/types/db";
 import type {
 	PilotDelta,
@@ -13,6 +13,71 @@ import type {
 import { haversineDistance } from "./utils/helpers.js";
 
 const TAXI_TIME_MS = 5 * 60 * 1000;
+const PILOT_RATINGS = [
+	{
+		id: 0,
+		short_name: "NEW",
+		long_name: "Basic Member",
+	},
+	{
+		id: 1,
+		short_name: "PPL",
+		long_name: "Private Pilot License",
+	},
+	{
+		id: 3,
+		short_name: "IR",
+		long_name: "Instrument Rating",
+	},
+	{
+		id: 7,
+		short_name: "CMEL",
+		long_name: "Commercial Multi-Engine License",
+	},
+	{
+		id: 15,
+		short_name: "ATPL",
+		long_name: "Airline Transport Pilot License",
+	},
+	{
+		id: 31,
+		short_name: "FI",
+		long_name: "Flight Instructor",
+	},
+	{
+		id: 63,
+		short_name: "FE",
+		long_name: "Flight Examiner",
+	},
+];
+const MILITARY_RATINGS = [
+	{
+		id: 0,
+		short_name: "M0",
+		long_name: "No Military Rating",
+	},
+	{
+		id: 1,
+		short_name: "M1",
+		long_name: "Military Pilot License",
+	},
+	{
+		id: 3,
+		short_name: "M2",
+		long_name: "Military Instrument Rating",
+	},
+	{
+		id: 7,
+		short_name: "M3",
+		long_name: "Military Multi-Engine Rating",
+	},
+	{
+		id: 15,
+		short_name: "M4",
+		long_name: "Military Mission Ready Pilot",
+	},
+];
+
 let cached: PilotLong[] = [];
 let deleted: string[] = [];
 let updated: PilotShort[] = [];
@@ -23,7 +88,7 @@ export async function mapPilots(latestVatsimData: VatsimData): Promise<PilotLong
 	updated = [];
 	added = [];
 
-	const pilotsLong: PilotLong[] = latestVatsimData.pilots.map((pilot) => {
+	const pilotsLongPromises: Promise<PilotLong>[] = latestVatsimData.pilots.map(async (pilot) => {
 		const id = `${pilot.cid}_${pilot.callsign}_${pilot.logon_time}`;
 		const cachedPilot = cached.find((c) => c.id === id);
 
@@ -59,9 +124,9 @@ export async function mapPilots(latestVatsimData: VatsimData): Promise<PilotLong
 				aircraft: pilot.flight_plan?.aircraft_short || "A320",
 				name: pilot.name,
 				server: pilot.server,
-				pilot_rating: pilot.pilot_rating,
-				military_rating: pilot.military_rating,
-				flight_plan: mapPilotFlightPlan(pilot.flight_plan),
+				pilot_rating: PILOT_RATINGS.find((r) => r.id === pilot.pilot_rating)?.short_name || "NEW",
+				military_rating: MILITARY_RATINGS.find((r) => r.id === pilot.military_rating)?.short_name || "M0",
+				flight_plan: await mapPilotFlightPlan(pilot.flight_plan),
 				route: `${pilot.flight_plan?.departure || "N/A"} -- ${pilot.flight_plan?.arrival || "N/A"}`,
 				logon_time: new Date(pilot.logon_time),
 				times: null,
@@ -76,6 +141,8 @@ export async function mapPilots(latestVatsimData: VatsimData): Promise<PilotLong
 		return pilotLong;
 	});
 
+	const pilotsLong = await Promise.all(pilotsLongPromises);
+
 	// Fetch airport coordinates for flight time estimation and store in PilotLong to minimize DB access
 	const icaos = getUniqueAirports(pilotsLong);
 	const airports = (await rdsGetMultiple("static_airport", icaos)) as (StaticAirport | null)[];
@@ -149,11 +216,11 @@ function calculateVerticalSpeed(current: PilotLong, cache: PilotLong | undefined
 	return Math.round(vs);
 }
 
-function mapPilotFlightPlan(fp?: VatsimPilotFlightPlan): PilotFlightPlan | null {
+async function mapPilotFlightPlan(fp?: VatsimPilotFlightPlan): Promise<PilotFlightPlan | null> {
 	if (!fp) return null;
 	return {
 		flight_rules: fp.flight_rules === "I" ? "IFR" : "VFR",
-		ac_reg: extractAircraftRegistration(fp.remarks),
+		ac_reg: await extractAircraftRegistration(fp.remarks),
 		departure: { icao: fp.departure },
 		arrival: { icao: fp.arrival },
 		alternate: { icao: fp.alternate },
@@ -167,9 +234,27 @@ function mapPilotFlightPlan(fp?: VatsimPilotFlightPlan): PilotFlightPlan | null
 	};
 }
 
-function extractAircraftRegistration(remarks: string): string | null {
+async function extractAircraftRegistration(remarks: string): Promise<string | null> {
 	const match = remarks.match(/REG\/([A-Z0-9]+)/i);
-	return match?.[1] ?? null;
+	if (!match?.[1]) return null;
+	const reg = match[1].toUpperCase();
+
+	let aircraft = await rdsGetSingle(`fleet:${reg}`);
+	if (aircraft) return reg;
+
+	if (reg.length > 1) {
+		const format1 = `${reg[0]}-${reg.slice(1)}`;
+		aircraft = await rdsGetSingle(`fleet:${format1}`);
+		if (aircraft) return format1;
+	}
+
+	if (reg.length > 2) {
+		const format2 = `${reg.slice(0, 2)}-${reg.slice(2)}`;
+		aircraft = await rdsGetSingle(`fleet:${format2}`);
+		if (aircraft) return format2;
+	}
+
+	return reg;
 }
 
 function mapPilotTimes(current: PilotLong, cache: PilotLong | undefined, vatsimPilot: VatsimPilot): PilotTimes | null {

apps/updater/package.json

@@ -20,6 +20,8 @@
 		"axios": "^1.13.2",
 		"cron": "^4.3.4",
 		"csv-parser": "^3.2.0",
-		"dotenv": "^17.2.3"
+		"dotenv": "^17.2.3",
+		"stream-json": "^1.9.1",
+		"undici": "^7.16.0"
 	}
 }

apps/updater/src/airlines.ts

@@ -1,4 +1,4 @@
-import { rdsSetSingle } from "@sk/db/redis";
+import { rdsGetSingle, rdsSetSingle } from "@sk/db/redis";
 import axios from "axios";
 
 const RELEASE_URL = "https://api.github.com/repos/sebastiankrll/simradar24-data/releases/latest";
@@ -7,6 +7,9 @@ const BASE_DATA_URL = "https://github.com/sebastiankrll/simradar24-data/releases
 let version: string | null = null;
 
 export async function updateAirlines(): Promise<void> {
+	if (!version) {
+		await initVersion();
+	}
 	if (!(await isNewRelease())) return;
 
 	try {
@@ -17,12 +20,21 @@ export async function updateAirlines(): Promise<void> {
 		});
 
 		await rdsSetSingle("static_airlines:all", response.data);
-		await rdsSetSingle("static_airlines:version", version?.replace(/^v/, "") || "1.0.0");
+		await rdsSetSingle("static_airlines:version", version || "1.0.0");
+
+		console.log(`✅ Airlines data updated to version ${version}`);
 	} catch (error) {
 		console.error(`Error checking for new airlines data: ${error}`);
 	}
 }
 
+async function initVersion(): Promise<void> {
+	if (!version) {
+		const redisVersion = await rdsGetSingle("static_airlines:version");
+		version = redisVersion || "0.0.0";
+	}
+}
+
 async function isNewRelease(): Promise<boolean> {
 	try {
 		const response = await axios.get(RELEASE_URL);

apps/updater/src/airports.ts

@@ -1,11 +1,19 @@
-import { rdsSetMultiple, rdsSetSingle } from "@sk/db/redis";
+import { rdsGetSingle, rdsSetMultiple, rdsSetSingle } from "@sk/db/redis";
 import type { OurAirportsCsv, StaticAirport } from "@sk/types/db";
 import axios from "axios";
 import csvParser from "csv-parser";
 
 const CSV_URL = "https://ourairports.com/data/airports.csv";
 
+let version: string | null = null;
+
 export async function updateAirports(): Promise<void> {
+	if (!version) {
+		await initVersion();
+	}
+	if (version === "1.0.0") {
+		return;
+	}
 	const response = await axios.get(CSV_URL, { responseType: "stream" });
 	const airports: OurAirportsCsv[] = [];
 
@@ -32,4 +40,13 @@ export async function updateAirports(): Promise<void> {
 	await rdsSetMultiple(filteredAirports, "static_airport", (a) => a.id, "airports:static");
 	await rdsSetSingle("static_airports:all", filteredAirports);
 	await rdsSetSingle("static_airports:version", "1.0.0");
+
+	console.log(`✅ Airports data updated to version ${version}`);
+}
+
+async function initVersion(): Promise<void> {
+	if (!version) {
+		const redisVersion = await rdsGetSingle("static_airports:version");
+		version = redisVersion || "0.0.0";
+	}
 }

apps/updater/src/fir.ts

@@ -1,4 +1,4 @@
-import { rdsSetSingle } from "@sk/db/redis";
+import { rdsGetSingle, rdsSetSingle } from "@sk/db/redis";
 import type { FIRFeature, FIRProperties, VatSpyDat, VatSpyFIRFeatureCollection } from "@sk/types/db";
 import axios from "axios";
 
@@ -8,6 +8,9 @@ const BASE_DATA_URL = "https://github.com/vatsimnetwork/vatspy-data-project/rele
 let version: string | null = null;
 
 export async function updateFirs(): Promise<void> {
+	if (!version) {
+		await initVersion();
+	}
 	if (!(await isNewRelease())) return;
 
 	try {
@@ -43,12 +46,21 @@ export async function updateFirs(): Promise<void> {
 		});
 
 		await rdsSetSingle("static_firs:all", newFeatures);
-		await rdsSetSingle("static_firs:version", version?.replace(/^v/, "") || "1.0.0");
+		await rdsSetSingle("static_firs:version", version || "1.0.0");
+
+		console.log(`✅ FIR data updated to version ${version}`);
 	} catch (error) {
 		console.error(`Error checking for new FIR data: ${error}`);
 	}
 }
 
+async function initVersion(): Promise<void> {
+	if (!version) {
+		const redisVersion = await rdsGetSingle("static_firs:version");
+		version = redisVersion || "0.0.0";
+	}
+}
+
 async function isNewRelease(): Promise<boolean> {
 	try {
 		const response = await axios.get(RELEASE_URL);

apps/updater/src/fleet.ts

@@ -0,0 +1,75 @@
+import { pipeline } from "node:stream/promises";
+import { rdsGetSingle, rdsSetMultiple, rdsSetSingle } from "@sk/db/redis";
+import type { StaticAircraft } from "@sk/types/db";
+import axios from "axios";
+import { parser } from "stream-json";
+import { streamArray } from "stream-json/streamers/StreamArray";
+import { fetch } from "undici";
+
+const RELEASE_URL = "https://api.github.com/repos/sebastiankrll/simradar24-data/releases/latest";
+const BASE_DATA_URL = "https://github.com/sebastiankrll/simradar24-data/releases/download/";
+
+let version: string | null = null;
+
+export async function updateFleets(): Promise<void> {
+	if (!version) {
+		await initVersion();
+	}
+	if (!(await isNewRelease())) return;
+
+	try {
+		const fleetsJsonUrl = `${BASE_DATA_URL}${version}/fleets.json`;
+		const response = await fetch(fleetsJsonUrl);
+
+		if (!response.body) {
+			throw new Error("No response body from GitHub");
+		}
+
+		const itemsBuffer: StaticAircraft[] = [];
+		const CHUNK = 10_000;
+
+		await pipeline(response.body, parser(), streamArray(), async (stream) => {
+			for await (const { value } of stream) {
+				itemsBuffer.push(value);
+
+				if (itemsBuffer.length >= CHUNK) {
+					await rdsSetMultiple(itemsBuffer, "fleet", (a) => a.registration);
+					itemsBuffer.length = 0;
+				}
+			}
+		});
+
+		if (itemsBuffer.length > 0) {
+			await rdsSetMultiple(itemsBuffer, "fleet", (a) => a.registration);
+		}
+
+		await rdsSetSingle("static_fleets:version", version || "1.0.0");
+
+		console.log(`✅ Fleets data updated to version ${version}`);
+	} catch (error) {
+		console.error(`Error checking for new fleets data: ${error}`);
+	}
+}
+
+async function initVersion(): Promise<void> {
+	if (!version) {
+		const redisVersion = await rdsGetSingle("static_fleets:version");
+		version = redisVersion || "0.0.0";
+	}
+}
+
+async function isNewRelease(): Promise<boolean> {
+	try {
+		const response = await axios.get(RELEASE_URL);
+		const release = response.data.tag_name;
+
+		if (release !== version) {
+			version = release;
+			return true;
+		}
+	} catch (error) {
+		console.error(`Error checking for updates: ${error}`);
+	}
+
+	return false;
+}