Design a Cinema Booking System for Interviews

Cinema Booking System Design

The Cinema Booking System is a software application that allows users to book movie tickets in advance. The system should facilitate searching for movies, selecting showtimes, booking tickets, and managing user preferences, all while adhering to the principles of Object-Oriented Design (OOD). In an interview scenario, you’ll need to design this system by considering its core components, use cases, and interaction between objects.

Key Features

1. Movie Search: Users can search for movies by genre, rating, or release date.

2. Seat Selection: Users can view seat availability and select seats.

3. Booking Confirmation: Users confirm their bookings and proceed with payment.

4. Payment Integration: Integration with a payment gateway to complete transactions.

5. Booking History: Users can view and manage their booking history.

6. User Management: Users can register, log in, and manage their accounts.

Step 1: Identify the Core Classes

The first step in designing a cinema booking system is identifying the primary objects or classes. Based on the system’s requirements, the following classes can be defined:

1. Movie: Represents the movie being shown.

   • Attributes: title, genre, duration, rating, synopsis, showtimes[]

   • Methods: getDetails(), getAvailableShowtimes()

2. Showtime: Represents a specific screening of a movie.

   • Attributes: movie, time, availableSeats

   • Methods: getAvailableSeats(), bookSeats(seats), cancelBooking(seats)

3. Seat: Represents a seat in the cinema hall.

   • Attributes: seatNumber, status (Available/Booked)

   • Methods: book(), release()

4. Booking: Represents a user’s booking.

   • Attributes: user, showtime, seats[], paymentStatus, bookingDate

   • Methods: confirmBooking(), cancelBooking(), getBookingDetails()

5. User: Represents a user in the system.

   • Attributes: userID, name, email, password, bookingHistory[]

   • Methods: register(), login(), viewBookingHistory()

6. Payment: Handles the payment for bookings.

   • Attributes: amount, paymentMethod, paymentStatus

   • Methods: processPayment(), refund()

7. CinemaHall: Represents a cinema hall with multiple showtimes.

   • Attributes: hallID, showtimes[]

   • Methods: getAvailableShowtimes(), getCinemaHallDetails()

Step 2: Class Relationships

• A Movie has many Showtimes, and each Showtime is associated with a specific Movie.

• A Showtime contains many Seats, and a Seat can either be booked or available.

• A Booking contains multiple Seats and is linked to a specific Showtime.

• A User can make multiple Bookings and has a BookingHistory.

• Payment is associated with a Booking and is required to confirm the booking.

Step 3: Use Case Scenarios

1. Search for Movies:

   • A user searches for a movie by genre, rating, or title.

   • The system returns a list of available movies along with their showtimes.

2. Select Showtime and Seats:

   • A user selects a movie and a showtime.

   • The system displays available seats for that showtime.

   • The user selects their desired seats.

3. Confirm Booking:

   • The user proceeds to book the selected seats.

   • A Booking object is created, associating the user, showtime, and selected seats.

   • The Payment object processes the payment and updates the booking status.

4. View Booking History:

   • The user can view their previous bookings.

   • The system retrieves booking details from the user’s BookingHistory.

5. Cancel Booking:

   • A user can cancel an existing booking, which frees up the seats.

   • The system updates the seat status and refunds the payment if applicable.

Step 4: OOD Principles

Encapsulation:

• Each class encapsulates its own data and methods.

• The Seat class manages its status (available or booked) internally, and only methods like book() or release() are exposed to the outside world.

Abstraction:

• Users interact with higher-level objects such as Movie, Showtime, and Booking, but they don’t need to know about the low-level details of seat management or payment processing.

Inheritance:

• In a more advanced system, we might define subclasses like PremiumSeat or VIPSeat, inheriting from the Seat class. These subclasses could have different pricing or additional features.

Polymorphism:

• For example, the Seat class could have a getPrice() method, and subclasses like VIPSeat or StandardSeat could override this method to return different prices based on seat type.

Step 5: Sequence Diagram (Booking Process)

1. User logs in or registers.

2. User searches for a movie.

3. System returns movie list with showtimes.

4. User selects a movie and showtime.

5. System displays available seats for that showtime.

6. User selects seats.

7. System creates a Booking and associates it with the selected seats.

8. User proceeds to payment.

9. System processes the payment via the Payment object.

10. System confirms the booking and updates seat status.

Step 6: Database Schema (Simplified)

The underlying database for this system might have the following simplified tables:

• Movies: movieID, title, genre, duration, rating, synopsis

• Showtimes: showtimeID, movieID, time, availableSeats

• Seats: seatID, showtimeID, seatNumber, status

• Users: userID, name, email, password

• Bookings: bookingID, userID, showtimeID, seats[], paymentStatus, bookingDate

• Payments: paymentID, bookingID, amount, paymentMethod, paymentStatus

Step 7: System Considerations

• Scalability: The system should be designed to handle many users, movies, and bookings concurrently.

• Concurrency: When multiple users are booking seats for the same showtime, the system must ensure that no two users can book the same seat simultaneously.

• Security: User data, especially payment information, should be securely handled. Encryption should be used for sensitive information.

• Extensibility: The system should be extensible to support new features like loyalty programs, promotions, or cinema branches.

Conclusion

The cinema booking system can be effectively modeled using Object-Oriented Design principles, ensuring a maintainable, scalable, and extensible application. By focusing on encapsulation, abstraction, and class relationships, the system will be capable of handling complex tasks like seat selection, booking, and payment while providing a smooth user experience.