AeroElite Private Jet Manager

AeroElite is a comprehensive, full-stack application for managing luxury private jet charter operations. It features a modern, high-performance React frontend and a robust Java/MongoDB backend, designed to handle fleet tracking, VIP client management, and flight dispatching.

🏗️ Deep Dive: What's Inside & Why It's Used

This project relies on a carefully curated, modern technology stack. Here is a detailed breakdown of every major component and directory used in the system, and its specific purpose.

🌐 Frontend (React + Vite)

The user interface is built for speed, immediate interactivity, and a premium aesthetic using the following tools:

• React 19: The core library for building the UI components. State is heavily managed here (e.g., active flights, selected views).
• Vite: An ultra-fast build tool and development server. Chosen over Webpack/CRA for near-instant hot module replacement (HMR).
• TypeScript: Adds strict static typing to JavaScript. Ensures data fetched from Java (like Flight or Passenger objects) precisely matches the expected structure, preventing runtime crash errors.
• Tailwind CSS (v4): A utility-first CSS framework. Used extensively throughout the app to style components directly in the JSX (e.g., bg-[#0a0a0a]) without needing external CSS files, ensuring consistent design tokens.
• Lucide React: A beautiful, consistent open-source icon library. Supplies all the UI icons (planes, users, settings cogs) keeping SVG assets perfectly scalable.
• Three.js & React Globe GL: The engines powering the breathtaking interactive 3D Dashboard globe. React Globe GL handles the data-binding of mapping coordinates and flight arcs onto a Three.js WebGL canvas wrapped around a night-time Earth texture.

☕ Backend (Java 17 + Maven)

The server architecture is deliberately lean, relying on core Java APIs combined with a NoSQL database, ensuring high processing speed and stability.

• Java 17: The backend engine. Handles routing, threading, and data manipulation.
• Maven: Project management and comprehension tool. Resolves all Java dependencies (like MongoDB driver and Gson) listed in the pom.xml.
• Java com.sun.net.httpserver: Native lightweight HTTP server. We intentionally avoided heavy frameworks like Spring Boot to keep compiling fast and demonstrate raw socket/handler architecture (ServerManager.java).
• Google Gson: A Java library that converts JSON strings to equivalent Java objects and vice versa. Critical for safely receiving React requests and packaging MongoDB data to send back across the API, inherently protecting against injection attacks or syntax breaks from special characters (like apostrophes in names).
• MongoDB Atlas & Native Java Driver: A cloud-based NoSQL database. Chosen over SQL because aviation data is inherently nested (e.g., a Flight contains lists of irregular Passengers and Crew documents). The native Java driver interacts directly with collections.
• Java Multithreading (Thread): Used in FlightTrackerThread.java to create a concurrent background worker that pings the database every 30 seconds for live updates, independently of the API HTTP listeners.

---

📂 Project Structure & Core Features

1. AeroElite/ (The Frontend Application)

• src/components/App.tsx: The heart of the routing. Uses a master state (currentView) to switch between the Dashboard, Booking, Fleet, Clients, and Settings pages while keeping the Sidebar persistent.
• src/components/Globe.tsx: The 3D Engine. Contains a massive dictionary of 60+ global airport coordinates (AIRPORT_COORDS). It takes flight data from the API, calculates great-circle arcs, and renders glowing SVG planes moving across the globe.
• src/components/ClientManager.tsx & FleetManager.tsx: Data tables fetching and rendering MongoDB collections in real-time, complete with async DELETE operations.

2. JetManagerProject/ (The Backend Server)

• src/main/java/com/jetmanager/Main.java: The primary entry point. Initializes the database connection pool, starts the HTTP server threads, and spawns the background tracker.
• src/main/java/com/jetmanager/api/ServerManager.java: The router. Contains HttpHandler implementations that listen on specific endpoints (/api/auth, /api/flights, /api/fleet, /api/clients, /api/flights/detail) to handle GET, POST, and DELETE requests, parse query parameters, and enable CORS.
• src/main/java/com/jetmanager/dao/DatabaseManager.java: The Data Access Object layer. Maintains a singleton MongoClient connection pool. Contains all the logic for insert(), find(), delete(), and auth validation against the MongoDB PrivatejetManager cluster.
• src/main/java/com/jetmanager/utils/ManifestGenerator.java: A physical file handler. Pulls deeply nested Passenger data and physically writes an official .txt flight manifest to the local server disk when requested by Dispatch.

---

🚀 Getting Started

Prerequisites

• Node.js (v18+)
• Java Development Kit (JDK 17+)
• Maven
• MongoDB Atlas Account

1. Database Setup

1. Create a free cluster on MongoDB Atlas.
2. Create a database named PrivatejetManager.
3. Create the collections: Flights, Clients, Fleet, Bookings, Staff.
4. Important: To enable login, add at least one document to the Staff collection:

   {
     "agentId": "your_username",
     "password": "your_password",
     "role": "agent"
   }

   (Note: The system contains hardcoded fallback demo credentials: demo / aeroelite if the database is unconfigured).

2. Backend Configuration

1. Navigate to the backend directory:

   cd JetManagerProject

2. Open config.properties and add your MongoDB connection URI:

   db.uri=mongodb+srv://<username>:<password>@<cluster-url>/

3. Start the Java server:

   mvn compile exec:java

   The server will start on http://localhost:8081.

3. Frontend Configuration

1. Navigate to the frontend directory:

   cd AeroElite

2. Install dependencies:

   npm install

3. Start the Vite development server:

   npm run dev

   The application will open on http://localhost:3000 (or 5173).

---

🔒 Security Posture

• Ignored Secrets: Both config.properties (Database credentials) and .env (API Keys) are explicitly omitted via root and child .gitignore configurations.
• Session Management: The frontend utilizes sessionStorage over localStorage (except for UI themes) to ensure agent authentication tokens auto-terminate when the browser tab is closed.

---

Built for the elite echelons of private aviation.