import mysql.

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

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

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

user='root', password='KhA4002!'):
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:
"""Add a new passenger to the database"""
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]:
"""Search for passengers by passport number, email, or name"""
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]:

"""Get all passengers"""
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:

 """Update passenger information"""
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 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:
"""Add a new flight"""
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]:
"""Search for flights"""
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]:

"""Get flight details by ID"""
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:

"""Update flight status"""
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:

"""Generate unique booking reference"""
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]:
"""Create a new booking"""
# Check if flight exists and has available seats
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']

# Calculate price based on class

price_multiplier = {'Economy': 1.0, 'Business': 2.0, 'First': 3.0}
total_amount = base_price * price_multiplier.get(class_type, 1.0)

# Create booking
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):
# Update available seats
update_query = "UPDATE flights SET available_seats = available_seats -
1 WHERE flight_id = %s"
self.db.execute_update(update_query, (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]:

"""Get booking details by reference"""
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:

"""Cancel a booking"""
# Get booking info first
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 booking status

update_query = "UPDATE bookings SET booking_status = 'Cancelled' WHERE
booking_reference = %s"
if self.db.execute_update(update_query, (booking_reference,)):
# Increase available seats
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

def initialize(self) -> bool:

"""Initialize the system"""
if self.db.connect():
self.passenger_manager = PassengerManager(self.db)
self.flight_manager = FlightManager(self.db)
self.booking_manager = BookingManager(self.db)
return True
return False

def cleanup(self):
"""Cleanup resources"""
self.db.disconnect()

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

def passenger_menu(self):
"""Handle passenger management operations"""
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 add_passenger_interactive(self):
"""Interactive passenger addition"""
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):
"""Interactive passenger search"""
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):
"""View all passengers"""
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):
"""Interactive flight search"""
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):
"""Interactive booking creation"""
print("\n--- CREATE BOOKING ---")

# Search passenger
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']}")

# Search flights
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):
"""Main application loop"""
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-5): ")

if choice == '1':
self.passenger_menu()
elif choice == '2':
print("\n--- FLIGHT MANAGEMENT ---")
print("1. Search Flights")
print("2. Back to Main Menu")
sub_choice = input("Enter choice: ")
if sub_choice == '1':
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']}")
else:
print("Booking not found!")
elif sub_choice == '3':
ref = input("Enter booking reference to cancel: ")
self.booking_manager.cancel_booking(ref)
elif choice == '4':
print("Reports feature - Coming soon!")
elif choice == '5':
print("Thank you for using Airport Management System!")
break
else:
print("Invalid choice! Please try again.")

except KeyboardInterrupt:
print("\nSystem interrupted by user")
finally:
self.cleanup()

if __name__ == "__main__":
# Create and run the airport management system
system = AirportManagementSystem()
system.run()