KEY FEATURES

1. MySQL Database Interaction:

 The program uses the mysql.connector package to interact with a MySQL database.
 It creates a connection (obj) to the MySQL server and uses a cursor (mycursor) to execute SQL
queries.

2. Database and Table Creation:

 The program checks if a database named “airlines” exists; if not, it creates one.
 It creates tables for food items, luggage, customer details, and flight details.

3. Data Insertion:
 Inserts sample data into the “food_items” table with various food items and prices.

4. User and Admin Interfaces:

 The program has distinct interfaces for users and administrators.
 The user interface allows users to view flight details, food details, book tickets, view their
details, and exit.
 The admin interface requires a password and offers options to update details, show details, and
approve jobs.

5. Dynamic Queries and Input Handling:

 The program dynamically constructs SQL queries based on user input for adding, updating, and
deleting records.
 It handles user inputs for choices, names, prices, and other details during interactions.

6. Conditional Logic and Loops:

 The program uses conditional statements and loops for decision-making and repeated tasks,
enhancing user interaction.

7. Date and Time Handling:

 It includes the use of the curdate() function to capture the current date when inserting customer
details.

8. Error Handling:
 The program prompts users to enter valid options and handles incorrect inputs, providing a user-
friendly experience.

9. Modular Structure:
 The code is organized into functions (luggage(), food(), classtype(), etc.), promoting code
modularity and maintainability.

10.Flight Details Display:

 The program displays available flights with details such as ID, name, departure, destination,
day, time, and class types.
 USAGE

The given code is an implementation of an Airline Management System with features for
handling food orders, luggage, customer details, and flight information. Below are some
example usages based on the functions defined

1. Admin Tasks:

Update Class Type:

 Admin selects to change class type name or price.

Add Luggage:

 Admin chooses to add luggage.

2. User Tasks:

Book Ticket:

 User books a ticket with their details.

View Available Flights:

 User checks available flights.

 ADVANTAGES

Here are some advantages related to FMS:-

1. Modularity: The program is organized into functions like luggage(), food(),

classtype(), etc., which enhances modularity. Each function handles a specific task,
making the code more readable and maintainable.

2. Database Integration: The program uses MySQL to manage airline-related data,

providing a robust and scalable solution for storing and retrieving information
about flights, food items, luggage, and customer details.

3. User Interface: The program has separate interfaces for administrators and
users, improving the user experience by tailoring interactions based on the user’s
role. This enhances usability and ensures that users only see relevant options.

4. Password Protection: The program includes a password-protected admin

interface, enhancing security by restricting access to certain functionalities. This
helps prevent unauthorized access and manipulation of critical data.

5. Dynamic Data Handling: The program allows dynamic handling of data, such as
adding new food items, updating prices, and deleting records. This flexibility is
valuable for adapting to changes in the airline’s offerings or modifying existing
information.

6. Record Retrieval: The program allows administrators to view records from

different tables, such as classtype and customer_details . This feature is useful for
obtaining insights into the system’s data, helping administrators make informed
decisions.

7. User-Friendly Prompts: The program provides clear prompts for user input,
improving user interaction and minimizing errors. Well-designed prompts enhance
the overall user experience.
 8. Error Handling: The program includes error handling mechanisms, such as
prompting users to enter valid options and displaying messages for incorrect
passwords. This helps prevent unexpected crashes and provides a smoother user
experience.

9. Real-Time Date Entry: The program captures the date of booking tickets using
“curdate()”, ensuring that the date is recorded accurately and automatically at the
time of ticket booking.

10. Database Commit: The program commits changes to the database using
obj.commit(), ensuring that modifications to the database are persistent. This
maintains data consistency and durability.

It’s important to note that while the program has certain advantages, it’s also crucial to
handle edge cases, ensure data integrity, and conduct thorough testing to identify and
address any potential issues.

LIMITATIONS

1. Security Concerns: The program does not implement strong security practices, such as
encryption for sensitive data or user authentication beyond a simple password check. This could
pose a security risk in a real-world scenario.

2. Data Validation: The program lacks robust input validation. For example, it doesn’t check if the
user provides valid numerical inputs or handle cases where the input is incorrect, potentially
leading to runtime errors or incorrect data in the database.

3. Error Handling: While the program includes some error handling, it may not cover all potential
errors that could occur during execution. Proper error handling is essential for a more stable and
user-friendly application.

4. Database Design: The structure of the database tables might be oversimplified for a real-world
airline management system. Additional fields and relationships may be required to accurately
represent the complexity of flight, customer, and booking data

5. Redundant Code: The program has redundant code, such as the food() function being called
before the user input for its execution. This may lead to unnecessary function calls and confusion in
the program flow.

6. Incomplete Functionality: Some functions are outlined in comments but not fully implemented or
called. For instance, the record() function is mentioned but not invoked in the user interface. This
suggests incomplete or unused functionality.
 7. User Experience: The user interfaces lack proper feedback and prompts. Users may not receive
sufficient guidance or feedback about their actions, leading to potential confusion or frustration.

8. Limited Documentation: The program lacks comprehensive comments or documentation,

making it challenging for other developers or maintainers to understand the code’s purpose,
especially in a collaborative environment.

9. Hardcoded Database Credentials: Database connection credentials (host, user, password) are
hardcoded in the program, which is not a good practice for security. Reasons. In a production
environment, these should be stored securely and accessed through configuration files or
Environment variables.

10. No Transaction Management: The program does not implement transaction management for
database operations. In a real-world scenario, this could result in inconsistent data states if an error
occurs during a series of database operations.

Addressing these limitations would involve enhancing security measures, improving input
validation, refining error handling, optimizing database design, removing redundant code,
completing functionality, providing better user feedback, documenting the code, and adopting best
practices for credential management and transaction handling.

FUNCTION AND MODULE USED

This Python program uses the following functions and modules:

1. Modules:
 Mysql.connector: This module is imported to interact with MySQL
databases.

2. Functions:
 luggage (): Manages luggage-related operations, such as adding or
deleting luggage items.
  Food(): Handles operations related to food items, including adding
new items, updating prices, and deleting items.
 classtype(): Manages operations related to class types, such as
changing class type names or prices.
 fooditems(): Displays available food items.
 admin1(): Admin interface for updating details, showing details,
and job approval.
 admin(): Accepts a password for accessing the admin interface.
 record(): Displays customer details based on the provided
customer ID.
 ticketbooking(): Facilitates the process of booking tickets by
taking user inputs.
 flightavailable(): Displays available flight details.
 user(): User interface for interacting with different features like
flight details, food details, ticket booking, and user details.
 Menu1(): Main menu to choose between admin, user, or exit
options.

3. Variable usage:
Various variables like obj, mycursor, Iname, fid, fcl, cname, etc., are
used to store and manipulate data within the program.

Future Scope of Project

The provided airline management system has a foundation for basic functionalities. Here
are some potential future scope areas to enhance and expand the program:

1. Enhanced Security Features:

 Implement secure user authentication mechanisms to ensure secure access to
the system.
 Integrate encryption for sensitive data, especially user credentials and personal
information.
2. User Interface Improvements:
 Enhance user interfaces to provide a more intuitive and user-friendly
experience.
 Implement proper error handling and informative prompts to guide users in case
of incorrect inputs.

3. Database Optimization:
 Refine the database schema to establish better relationships between tables.
 Normalize the database structure to minimize redundancy and improve data
integrity.
 Implement foreign key constraints to maintain referential integrity.

4. Transaction Management:
 Implement transaction management to ensure the consistency and reliability of
database operations.
 Use transactions to group related operations and ensure that they either all
succeed or fail together.

5. Comprehensive Data Validation:

 Strengthen input validation mechanisms to handle a broader range of scenarios
and prevent potential vulnerabilities.
 Validate user inputs rigorously to avoid issues such as SQL injection.

6. Logging and Auditing:

 Implement logging mechanisms to record system activities and user
interactions.
 Establish an audit trail to track changes to critical data and user actions within
the System.

7. Advanced Functionalities:
 Expand the system to include more advanced features such as seat selection,
online check-in, and real-time flight status updates.
 Integrate a payment gateway for ticket booking transactions.

8. Reporting and Analytics:

 Develop reporting functionalities to generate insights into sales, customer
preferences, and operational performance.
 Implement analytical tools to help administrators make informed decisions
based on data

9. Multi-User Support:
  Enable support for multiple users with role-based access control.
 Define roles such as admin, customer support, and regular users with varying
levels of access.

10. Mobile Application Development:

 Extend the system by developing a mobile application to allow users to interact
with the airline management system using smartphones and tablets.

11. Integration with External Services:

 Integrate with external services for features like weather updates, real-time
flight tracking, or partnering with third-party food vendors for in-flight catering.

12. Scalability Considerations:

 Design the system architecture to be scalable, accommodating future growth in
data and user volume.

13. Documentation and Code Refactoring:

 Enhance code documentation to make the program more understandable for
future developers.
 Consider refactoring the code for better modularity and maintainability.

14. Automated Testing:

 Implement automated testing to ensure the reliability of the system and catch
potential issues during development.

15. Internationalization and Localization:

 Design the system to support multiple languages and regions to cater to a
diverse user base.

By focusing on these future scope areas, the airline management system can evolve into
a more robust, feature-rich, and user-friendly application, meeting the growing demands
of the airline industry and user expectations.
 Conclusion

The provided Python script establishes a connection with a MySQL

database, creating tables for managing an airline system,
including food items, luggage, customer details, and flight
information. It features functionalities like adding/deleting
luggage, updating food details, and booking tickets. While
demonstrating the basics of database operations, user and admin
interfaces, the script would benefit from improvements such as
error handling and input validation for a more robust and user-
friendly application. Future enhancements could focus on security
measures and additional features to enhance the overall airline
management system.