Movie Ticket Booking System

An online movie ticket booking system facilitates the purchasing of movie tickets to its customers. E-ticketing systems allow customers to browse through movies currently playing and book seats, anywhere and anytime.

Features

Our ticket booking service should meet the following requirements:

It should be able to list the cities where affiliate cinemas are located.
Each cinema can have multiple halls and each hall can run one movie show at a time.
Each Movie will have multiple shows.
Customers should be able to search movies by their title, language, genre, release date, and city name.
Once the customer selects a movie, the service should display the cinemas running that movie and its available shows.
The customer should be able to select a show at a particular cinema and book their tickets.
The service should show the customer the seating arrangement of the cinema hall.
The customer should be able to select multiple seats according to their preference.
The customer should be able to distinguish between available seats and booked ones.
The system should send notifications whenever there is a new movie, as well as when a booking is made or canceled.
Customers of our system should be able to pay with credit cards or cash.
The system should ensure that no two customers can reserve the same seat.
Customers should be able to add a discount coupon to their payment.

Rough Solution (LLD-Machine Coding)

// Enum classes remain the same
public enum BookingStatus {
    REQUESTED, PENDING, CONFIRMED, CHECKED_IN, CANCELED, ABANDONED
}

public enum SeatType {
    REGULAR, PREMIUM, ACCESSIBLE, SHIPPED, EMERGENCY_EXIT, OTHER
}

public enum AccountStatus {
    ACTIVE, BLOCKED, BANNED, COMPROMISED, ARCHIVED, UNKNOWN
}

public enum PaymentStatus {
    UNPAID, PENDING, COMPLETED, FILLED, DECLINED, CANCELLED, ABANDONED, SETTLING, SETTLED, REFUNDED
}

// Supporting classes for address and account
public class Address {
    private String streetAddress;
    private String city;
    private String state;
    private String zipCode;
    private String country;
}

public class Account {
    private String id;
    private String password;
    private AccountStatus status;

    public boolean resetPassword() {
        System.out.println("Password reset.");
        return true;
    }
}

// Abstract Person class
public abstract class Person {
    private String name;
    private Address address;
    private String email;
    private String phone;
    private Account account;

    public Person(String name, Account account) {
        this.name = name;
        this.account = account;
    }

    public String getName() {
        return name;
    }
}

// Observer Pattern for Notifications
interface Observer {
    void update(String message);
}

class Customer extends Person implements Observer {
    private List<Booking> bookings;

    public Customer(String name, Account account) {
        super(name, account);
        bookings = new ArrayList<>();
    }

    @Override
    public void update(String message) {
        System.out.println("Notification for " + getName() + ": " + message);
    }

    public boolean makeBooking(Booking booking) {
        bookings.add(booking);
        System.out.println("Booking made successfully.");
        return true;
    }

    public List<Booking> getBookings() {
        return bookings;
    }
}

class SystemNotifier {
    private List<Observer> observers = new ArrayList<>();

    public void addObserver(Observer observer) {
        observers.add(observer);
    }

    public void removeObserver(Observer observer) {
        observers.remove(observer);
    }

    public void notifyObservers(String message) {
        for (Observer observer : observers) {
            observer.update(message);
        }
    }
}

// Factory Method Pattern for creating Movies, Shows, and Bookings
abstract class BookingFactory {
    public abstract Booking createBooking(Show show, List<ShowSeat> seats);
}

class RegularBookingFactory extends BookingFactory {
    @Override
    public Booking createBooking(Show show, List<ShowSeat> seats) {
        return new Booking(show, seats);
    }
}

class AdminFactory {
    public Admin createAdmin(String name, Account account) {
        return new Admin(name, account);
    }

    public Movie createMovie(String title, String description, Admin admin) {
        return new Movie(title, description, admin);
    }

    public Show createShow(Movie movie, Date startTime, CinemaHall hall) {
        return new Show(movie, startTime, hall);
    }
}

// Command Pattern for booking and payment operations
interface Command {
    void execute();
}

class CreateBookingCommand implements Command {
    private FrontDeskOfficer officer;
    private Booking booking;

    public CreateBookingCommand(FrontDeskOfficer officer, Booking booking) {
        this.officer = officer;
        this.booking = booking;
    }

    @Override
    public void execute() {
        officer.createBooking(booking);
    }
}

class CancelBookingCommand implements Command {
    private Booking booking;

    public CancelBookingCommand(Booking booking) {
        this.booking = booking;
    }

    @Override
    public void execute() {
        booking.cancel();
    }
}

class MakePaymentCommand implements Command {
    private Payment payment;
    private Booking booking;

    public MakePaymentCommand(Payment payment, Booking booking) {
        this.payment = payment;
        this.booking = booking;
    }

    @Override
    public void execute() {
        booking.makePayment(payment);
    }
}

// Strategy Pattern for searching movies
interface SearchStrategy {
    List<Movie> search(Catalog catalog, String query);
}

class TitleSearchStrategy implements SearchStrategy {
    @Override
    public List<Movie> search(Catalog catalog, String title) {
        return catalog.searchByTitle(title);
    }
}

class GenreSearchStrategy implements SearchStrategy {
    @Override
    public List<Movie> search(Catalog catalog, String genre) {
        return catalog.searchByGenre(genre);
    }
}

class LanguageSearchStrategy implements SearchStrategy {
    @Override
    public List<Movie> search(Catalog catalog, String language) {
        return catalog.searchByLanguage(language);
    }
}

// Template Method Pattern for Payment Processing
abstract class Payment {
    protected double amount;
    protected PaymentStatus status;

    public final void processPayment() {
        initiatePayment();
        confirmPayment();
        updatePaymentStatus();
    }

    protected abstract void initiatePayment();

    private void confirmPayment() {
        System.out.println("Payment confirmed.");
    }

    private void updatePaymentStatus() {
        this.status = PaymentStatus.COMPLETED;
        System.out.println("Payment status updated to COMPLETED.");
    }
}

class CreditCardPayment extends Payment {
    @Override
    protected void initiatePayment() {
        System.out.println("Processing credit card payment of amount: " + amount);
    }
}

class DebitCardPayment extends Payment {
    @Override
    protected void initiatePayment() {
        System.out.println("Processing debit card payment of amount: " + amount);
    }
}

// Supporting classes and interfaces

public class Booking {
    private String bookingNumber;
    private int numberOfSeats;
    private Date createdOn;
    private BookingStatus status;
    private Show show;
    private List<ShowSeat> seats;
    private Payment payment;

    public Booking(Show show, List<ShowSeat> seats) {
        this.show = show;
        this.seats = seats;
        this.status = BookingStatus.REQUESTED;
    }

    public Show getShow() {
        return show;
    }

    public boolean makePayment(Payment payment) {
        this.payment = payment;
        payment.processPayment();
        this.status = BookingStatus.CONFIRMED;
        return true;
    }

    public boolean cancel() {
        this.status = BookingStatus.CANCELED;
        System.out.println("Booking has been canceled.");
        return true;
    }

    public boolean assignSeats(List<ShowSeat> seats) {
        this.seats = seats;
        System.out.println("Seats assigned.");
        return true;
    }
}

public class Show {
    private Movie movie;
    private Date startTime;
    private CinemaHall hall;

    public Show(Movie movie, Date startTime, CinemaHall hall) {
        this.movie = movie;
        this.startTime = startTime;
        this.hall = hall;
    }

    public Movie getMovie() {
        return movie;
    }
}

public class Movie {
    private String title;
    private String description;
    private Admin movieAddedBy;

    public Movie(String title, String description, Admin movieAddedBy) {
        this.title = title;
        this.description = description;
        this.movieAddedBy = movieAddedBy;
    }

    public String getTitle() {
        return title;
    }
}

public class FrontDeskOfficer extends Person {
    public FrontDeskOfficer(String name, Account account) {
        super(name, account);
    }

    public boolean createBooking(Booking booking) {
        System.out.println("Booking created for show: " + booking.getShow().getMovie().getTitle());
        return true;
    }
}

public class Admin extends Person {
    public Admin(String name, Account account) {
        super(name, account);
    }

    public boolean addMovie(Movie movie) {
        System.out.println("Movie " + movie.getTitle() + " added.");
        return true;
    }

    public boolean addShow(Show show) {
        System.out.println("Show added for movie: " + show.getMovie().getTitle());
        return true;
    }

    public boolean blockUser(Customer customer) {
        System.out.println("Customer " + customer.getName() + " blocked.");
        return true;
    }
}

/

// Main class for demonstrating the design
public class Main {
    public static void main(String[] args) {
        // Create an Admin using Factory Method
        AdminFactory adminFactory = new AdminFactory();
        Account adminAccount = new Account();
        Admin admin = adminFactory.createAdmin("John Doe", adminAccount);

        // Create a movie and show
        Movie movie = adminFactory.createMovie("Inception", "Sci-fi Thriller", admin);
        CinemaHall hall = new CinemaHall();
        Show show = adminFactory.createShow(movie, new Date(), hall);

        // Create a booking using Command Pattern
        BookingFactory bookingFactory = new RegularBookingFactory();
        List<ShowSeat> seats = new ArrayList<>();
        Booking booking = bookingFactory.createBooking(show, seats);

        FrontDeskOfficer officer = new FrontDeskOfficer("Jane Doe", new Account());
        Command createBookingCommand = new CreateBookingCommand(officer, booking);
        createBookingCommand.execute();

        // Process payment using Template Method Pattern
        Payment payment = new CreditCardPayment();
        payment.processPayment();

        // Notify customers using Observer Pattern
        SystemNotifier notifier = new SystemNotifier();
        Customer customer = new Customer("Alice", new Account());
        notifier.addObserver(customer);
        notifier.notifyObservers("New movie added: " + movie.getTitle());
    }
}

Drawbacks and Issues

⚠️ 1️⃣ Concurrency Issue in Seat Booking

❌ Problem:

The current design does not ensure seat booking consistency when multiple users try to book the same seat simultaneously.
This could lead to overbooking and inconsistent states.

✅ Solution: Will be covered in our course.

⚠️ 2️⃣ Payment and Discount Handling Issues

❌ Problem:

Discount handling is not integrated into the payment workflow.
Payment options are hardcoded, making it difficult to add new payment methods.

✅ Solution: Will be covered in our course.

⚠️ 3️⃣ Lack of Real-Time Notification and Event Handling

❌ Problem:

The system lacks a robust notification system.
Using a single SystemNotifier is not scalable for real-time notifications.

✅ Solution: Will be covered in our course.

⚠️ 4️⃣ Unclear Responsibilities in Command Pattern Usage

❌ Problem:

The Command Pattern is being used for booking and payment, but FrontDeskOfficer lacks clear responsibility.
There is no clear distinction between command execution and command creation.

✅ Solution: Will be covered in our course.

Design (LLD) a Movie Ticket Booking System - Machine Coding