"""

Airport Management System - Python Application

Required packages: pip install mysql-connector-python
"""

import mysql.connector
from mysql.connector import Error
import datetime
import random
import string
from typing import List, Dict, Optional, Tuple
from decimal import Decimal

class DatabaseConnection:
"""Handle MySQL database connections and operations"""

def __init__(self, host='localhost', database='airport_management',

user='root', password='wizard04'):
self.host = host
self.database = database
self.user = user
self.password = password
self.connection = None

def connect(self):
"""Establish database connection"""
try:
self.connection = mysql.connector.connect(
host=self.host,
database=self.database,
user=self.user,
password=self.password
)
if self.connection.is_connected():
print("Successfully connected to MySQL database")
return True
except Error as e:
print(f"Error connecting to MySQL database: {e}")
return False

def disconnect(self):
"""Close database connection"""
if self.connection and self.connection.is_connected():
self.connection.close()
print("MySQL connection closed")

def execute_query(self, query: str, params: tuple = None) -> Optional[List]:

"""Execute SELECT queries"""
try:
cursor = self.connection.cursor(dictionary=True)
cursor.execute(query, params)
result = cursor.fetchall()
cursor.close()
return result
except Error as e:
print(f"Error executing query: {e}")
return None
 def execute_update(self, query: str, params: tuple = None) -> bool:
"""Execute INSERT, UPDATE, DELETE queries"""
try:
cursor = self.connection.cursor()
cursor.execute(query, params)
self.connection.commit()
cursor.close()
return True
except Error as e:
print(f"Error executing update: {e}")
self.connection.rollback()
return False

class PassengerManager:
"""Manage passenger operations"""

def __init__(self, db: DatabaseConnection):

self.db = db

def add_passenger(self, first_name: str, last_name: str, email: str,

phone: str, passport_number: str, date_of_birth: str,
nationality: str, gender: str, address: str = None) -> bool:
query = """
INSERT INTO passengers (first_name, last_name, email, phone,
passport_number,
date_of_birth, nationality, gender, address)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s)
"""
params = (first_name, last_name, email, phone, passport_number,
date_of_birth, nationality, gender, address)

if self.db.execute_update(query, params):
print(f"Passenger {first_name} {last_name} added successfully!")
return True
else:
print("Failed to add passenger")
return False

def search_passenger(self, search_term: str, search_by: str = 'passport') ->

List[Dict]:
if search_by == 'passport':
query = "SELECT * FROM passengers WHERE passport_number = %s"
elif search_by == 'email':
query = "SELECT * FROM passengers WHERE email = %s"
elif search_by == 'name':
query = "SELECT * FROM passengers WHERE CONCAT(first_name, ' ',
last_name) LIKE %s"
search_term = f"%{search_term}%"
else:
print("Invalid search criteria")
return []

result = self.db.execute_query(query, (search_term,))

return result if result else []

def get_all_passengers(self) -> List[Dict]:

query = "SELECT * FROM passengers ORDER BY created_at DESC"
result = self.db.execute_query(query)
 return result if result else []

def update_passenger(self, passenger_id: int, **kwargs) -> bool:

if not kwargs:
print("No data to update")
return False

set_clause = ", ".join([f"{key} = %s" for key in kwargs.keys()])

query = f"UPDATE passengers SET {set_clause} WHERE passenger_id = %s"
params = tuple(kwargs.values()) + (passenger_id,)

if self.db.execute_update(query, params):
print("Passenger updated successfully!")
return True
else:
print("Failed to update passenger")
return False

class AirlineManager:
"""Manage airline operations"""

def __init__(self, db: DatabaseConnection):

self.db = db

def add_airline(self, code: str, name: str, country: str,

email: str = None, phone: str = None) -> bool:
query = """
INSERT INTO airlines (airline_code, airline_name, country, contact_email,
contact_phone)
VALUES (%s, %s, %s, %s, %s)
"""
params = (code.upper(), name, country, email, phone)

if self.db.execute_update(query, params):
print(f"Airline {name} ({code.upper()}) added successfully!")
return True
else:
print("Failed to add airline. Check for duplicate code.")
return False

def view_airlines(self):
query = "SELECT * FROM airlines ORDER BY airline_code"
airlines = self.db.execute_query(query)
if airlines:
print("\n--- Airline List ---")
for a in airlines:
print(f"{a['airline_code']} - {a['airline_name']}
({a['country']})")
else:
print("No airlines found.")

class FlightManager:
"""Manage flight operations"""

def __init__(self, db: DatabaseConnection):

self.db = db
 def add_flight(self, flight_number: str, airline_id: int, departure_airport:
str,
arrival_airport: str, departure_date: str, departure_time: str,
arrival_date: str, arrival_time: str, base_price: float,
available_seats: int, aircraft_id: int = None,
gate_number: str = None, terminal: str = None) -> bool:
query = """
INSERT INTO flights (flight_number, airline_id, aircraft_id,
departure_airport,
arrival_airport, departure_date, departure_time,
arrival_date,
arrival_time, base_price, available_seats, gate_number,
terminal)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
"""
params = (flight_number, airline_id, aircraft_id, departure_airport,
arrival_airport, departure_date, departure_time, arrival_date,
arrival_time, base_price, available_seats, gate_number, terminal)

if self.db.execute_update(query, params):
print(f"Flight {flight_number} added successfully!")
return True
else:
print("Failed to add flight")
return False

def search_flights(self, departure_airport: str = None, arrival_airport: str =

None,
departure_date: str = None) -> List[Dict]:
conditions = []
params = []

if departure_airport:
conditions.append("departure_airport = %s")
params.append(departure_airport)

if arrival_airport:
conditions.append("arrival_airport = %s")
params.append(arrival_airport)

if departure_date:
conditions.append("departure_date = %s")
params.append(departure_date)

where_clause = " AND ".join(conditions) if conditions else "1=1"

query = f"""
SELECT f.*, a.airline_name
FROM flights f
JOIN airlines a ON f.airline_id = a.airline_id
WHERE {where_clause}
ORDER BY f.departure_date, f.departure_time
"""

result = self.db.execute_query(query, tuple(params))

return result if result else []

def get_flight_by_id(self, flight_id: int) -> Optional[Dict]:

query = """
 SELECT f.*, a.airline_name, ac.aircraft_model
FROM flights f
JOIN airlines a ON f.airline_id = a.airline_id
LEFT JOIN aircraft ac ON f.aircraft_id = ac.aircraft_id
WHERE f.flight_id = %s
"""
result = self.db.execute_query(query, (flight_id,))
return result[0] if result else None

def update_flight_status(self, flight_id: int, status: str) -> bool:

query = "UPDATE flights SET status = %s WHERE flight_id = %s"
if self.db.execute_update(query, (status, flight_id)):
print(f"Flight status updated to {status}")
return True
return False

class BookingManager:
"""Manage booking operations"""

def __init__(self, db: DatabaseConnection):

self.db = db

def generate_booking_reference(self) -> str:

return ''.join(random.choices(string.ascii_uppercase + string.digits, k=6))

def create_booking(self, passenger_id: int, flight_id: int, seat_number: str =

None,
class_type: str = 'Economy') -> Optional[str]:
flight_query = "SELECT available_seats, base_price FROM flights WHERE
flight_id = %s"
flight_info = self.db.execute_query(flight_query, (flight_id,))

if not flight_info or flight_info[0]['available_seats'] <= 0:

print("Flight not available or no seats remaining")
return None

booking_reference = self.generate_booking_reference()

base_price = flight_info[0]['base_price']

price_multiplier = {
'Economy': Decimal('1.0'),
'Business': Decimal('2.0'),
'First': Decimal('3.0')
}

class_type = (class_type or 'Economy').title()

total_amount = (base_price * price_multiplier.get(class_type,
Decimal('1.0'))).quantize(Decimal('0.01'))

query = """
INSERT INTO bookings (booking_reference, passenger_id, flight_id,
seat_number,
class, total_amount, booking_status)
VALUES (%s, %s, %s, %s, %s, %s, 'Confirmed')
"""
params = (booking_reference, passenger_id, flight_id, seat_number,
class_type, total_amount)
 if self.db.execute_update(query, params):
self.db.execute_update(
"UPDATE flights SET available_seats = available_seats - 1 WHERE
flight_id = %s",
(flight_id,)
)
print(f"Booking created successfully! Reference: {booking_reference}")
return booking_reference
else:
print("Failed to create booking")
return None

def get_booking_details(self, booking_reference: str) -> Optional[Dict]:

query = """
SELECT b.*, p.first_name, p.last_name, p.email, p.phone,
f.flight_number, f.departure_airport, f.arrival_airport,
f.departure_date, f.departure_time, a.airline_name
FROM bookings b
JOIN passengers p ON b.passenger_id = p.passenger_id
JOIN flights f ON b.flight_id = f.flight_id
JOIN airlines a ON f.airline_id = a.airline_id
WHERE b.booking_reference = %s
"""
result = self.db.execute_query(query, (booking_reference,))
return result[0] if result else None

def cancel_booking(self, booking_reference: str) -> bool:

booking_query = "SELECT flight_id, booking_status FROM bookings WHERE
booking_reference = %s"
booking_info = self.db.execute_query(booking_query, (booking_reference,))

if not booking_info or booking_info[0]['booking_status'] == 'Cancelled':

print("Booking not found or already cancelled")
return False

update_query = "UPDATE bookings SET booking_status = 'Cancelled' WHERE

booking_reference = %s"
if self.db.execute_update(update_query, (booking_reference,)):
flight_id = booking_info[0]['flight_id']
seat_query = "UPDATE flights SET available_seats = available_seats + 1
WHERE flight_id = %s"
self.db.execute_update(seat_query, (flight_id,))
print(f"Booking {booking_reference} cancelled successfully")
return True
return False

class AirportManagementSystem:
"""Main airport management system"""

def __init__(self):
self.db = DatabaseConnection()
self.passenger_manager = None
self.flight_manager = None
self.booking_manager = None
self.airline_manager = None
def initialize(self) -> bool:
if self.db.connect():
self.passenger_manager = PassengerManager(self.db)
self.flight_manager = FlightManager(self.db)
self.booking_manager = BookingManager(self.db)
self.airline_manager = AirlineManager(self.db)
return True
return False

def cleanup(self):
self.db.disconnect()

def display_menu(self):
print("\n" + "=" * 50)
print(" AIRPORT MANAGEMENT SYSTEM")
print("=" * 50)
print("1. Passenger Management")
print("2. Flight Management")
print("3. Booking Management")
print("4. Airline Management")
print("5. Reports")
print("6. Exit")
print("=" * 50)

def passenger_menu(self):
while True:
print("\n--- PASSENGER MANAGEMENT ---")
print("1. Add New Passenger")
print("2. Search Passenger")
print("3. View All Passengers")
print("4. Update Passenger")
print("5. Back to Main Menu")

choice = input("\nEnter your choice (1-5): ")

if choice == '1':
self.add_passenger_interactive()
elif choice == '2':
self.search_passenger_interactive()
elif choice == '3':
self.view_all_passengers()
elif choice == '4':
self.update_passenger_interactive()
elif choice == '5':
break
else:
print("Invalid choice! Please try again.")

def airline_menu(self):
while True:
print("\n--- AIRLINE MANAGEMENT ---")
print("1. Add New Airline")
print("2. View All Airlines")
print("3. Back to Main Menu")

choice = input("Enter your choice (1-3): ")

if choice == '1':
self.add_airline_interactive()
 elif choice == '2':
self.airline_manager.view_airlines()
elif choice == '3':
break
else:
print("Invalid choice. Please try again.")

def add_airline_interactive(self):
code = input("Airline code (e.g., 6E): ").strip().upper()
name = input("Airline name: ").strip()
country = input("Country: ").strip()
email = input("Contact email (optional): ").strip() or None
phone = input("Contact phone (optional): ").strip() or None

self.airline_manager.add_airline(code, name, country, email, phone)

def add_passenger_interactive(self):
print("\n--- ADD NEW PASSENGER ---")
first_name = input("First Name: ")
last_name = input("Last Name: ")
email = input("Email: ")
phone = input("Phone: ")
passport = input("Passport Number: ")
dob = input("Date of Birth (YYYY-MM-DD): ")
nationality = input("Nationality: ")
gender = input("Gender (Male/Female/Other): ")
address = input("Address (optional): ")

self.passenger_manager.add_passenger(
first_name, last_name, email, phone, passport,
dob, nationality, gender, address if address else None
)

def search_passenger_interactive(self):
print("\n--- SEARCH PASSENGER ---")
print("1. By Passport Number")
print("2. By Email")
print("3. By Name")

choice = input("Search by (1-3): ")

search_term = input("Enter search term: ")

search_by_map = {'1': 'passport', '2': 'email', '3': 'name'}

search_by = search_by_map.get(choice, 'passport')

passengers = self.passenger_manager.search_passenger(search_term,
search_by)

if passengers:
print(f"\nFound {len(passengers)} passenger(s):")
for p in passengers:
print(f"ID: {p['passenger_id']}, Name: {p['first_name']}
{p['last_name']}, "
f"Passport: {p['passport_number']}, Email: {p['email']}")
else:
print("No passengers found")

def view_all_passengers(self):
passengers = self.passenger_manager.get_all_passengers()
 if passengers:
print(f"\nTotal Passengers: {len(passengers)}")
print("-" * 80)
for p in passengers:
print(f"ID: {p['passenger_id']:3d} | {p['first_name']}
{p['last_name']:20s} | "
f"{p['passport_number']:12s} | {p['email']:25s}")
else:
print("No passengers found")

def flight_search_interactive(self):
print("\n--- SEARCH FLIGHTS ---")
departure = input("Departure Airport (3-letter code, optional): ").upper()
arrival = input("Arrival Airport (3-letter code, optional): ").upper()
date = input("Departure Date (YYYY-MM-DD, optional): ")

flights = self.flight_manager.search_flights(
departure if departure else None,
arrival if arrival else None,
date if date else None
)

if flights:
print(f"\nFound {len(flights)} flight(s):")
print("-" * 100)
for f in flights:
print(f"Flight: {f['flight_number']:8s} | {f['airline_name']:15s} |
"
f"{f['departure_airport']}->{f['arrival_airport']} | "
f"{f['departure_date']} {f['departure_time']} | "
f"₹{f['base_price']:8.2f} | Seats: {f['available_seats']}")
else:
print("No flights found")

def create_booking_interactive(self):
print("\n--- CREATE BOOKING ---")

passport = input("Enter passenger passport number: ")

passengers = self.passenger_manager.search_passenger(passport, 'passport')

if not passengers:
print("Passenger not found!")
return

passenger = passengers[0]
print(f"Passenger: {passenger['first_name']} {passenger['last_name']}")

print("\nAvailable flights:")
departure = input("Departure airport: ").upper()
arrival = input("Arrival airport: ").upper()
date = input("Departure date (YYYY-MM-DD): ")

flights = self.flight_manager.search_flights(departure, arrival, date)

if not flights:
print("No flights found!")
return

for i, f in enumerate(flights, 1):

 print(f"{i}. {f['flight_number']} - {f['airline_name']} - "
f"₹{f['base_price']} - {f['available_seats']} seats available")

try:
flight_choice = int(input("Select flight (number): ")) - 1
selected_flight = flights[flight_choice]

class_type = input("Class (Economy/Business/First) [Economy]: ") or

"Economy"
seat_number = input("Seat number (optional): ") or None

booking_ref = self.booking_manager.create_booking(
passenger['passenger_id'],
selected_flight['flight_id'],
seat_number,
class_type
)

if booking_ref:
print(f"\nBooking created successfully!")
print(f"Booking Reference: {booking_ref}")

except (ValueError, IndexError):

print("Invalid selection!")

def run(self):
if not self.initialize():
print("Failed to initialize the system!")
return

print("Airport Management System initialized successfully!")

try:
while True:
self.display_menu()
choice = input("\nEnter your choice (1-6): ")

if choice == '1':
self.passenger_menu()
elif choice == '2':
self.flight_search_interactive()
elif choice == '3':
print("\n--- BOOKING MANAGEMENT ---")
print("1. Create Booking")
print("2. View Booking Details")
print("3. Cancel Booking")
print("4. Back to Main Menu")
sub_choice = input("Enter choice: ")
if sub_choice == '1':
self.create_booking_interactive()
elif sub_choice == '2':
ref = input("Enter booking reference: ")
booking = self.booking_manager.get_booking_details(ref)
if booking:
print(f"\nBooking Details:")
print(f"Reference: {booking['booking_reference']}")
print(f"Passenger: {booking['first_name']}
{booking['last_name']}")
print(f"Flight: {booking['flight_number']}
({booking['airline_name']})")
print(f"Route: {booking['departure_airport']} ->
{booking['arrival_airport']}")
print(f"Date: {booking['departure_date']} at
{booking['departure_time']}")
print(f"Class: {booking['class']}")
print(f"Amount: ₹{booking['total_amount']}")
print(f"Status: {booking['booking_status']}")
elif sub_choice == '3':
ref = input("Enter booking reference to cancel: ")
self.booking_manager.cancel_booking(ref)
elif choice == '4':
self.airline_menu()
elif choice == '5':
print("Reports feature - Coming soon!")
elif choice == '6':
print("Thank you for using Airport Management System!")
break
except KeyboardInterrupt:
print("\nSystem interrupted by user")
finally:
self.cleanup()

if __name__ == "__main__":
system = AirportManagementSystem()
system.run()