Designing an Online Public Transport Card System with Object-Oriented Principles

Designing an Online Public Transport Card System with Object-Oriented Principles

Public transportation systems are crucial to the smooth functioning of cities, providing affordable and convenient mobility. An essential feature of many modern transport systems is the use of electronic payment methods, such as transport cards. A digital version of these cards, integrated into a comprehensive online platform, can streamline the user experience, improve system efficiency, and enhance security. Designing an Online Public Transport Card System using Object-Oriented Design (OOD) principles enables the creation of a scalable, maintainable, and user-friendly system.

In this article, we’ll break down the components of a public transport card system using object-oriented design principles, focusing on core concepts like classes, objects, inheritance, polymorphism, and encapsulation.

1. Identifying Key Requirements

Before diving into the design, we need to identify the key features and functionalities that the system should provide:

• Card Management: Ability to create, update, deactivate, and manage transport cards.

• Payment Integration: Users can add funds to their cards or link external payment methods (e.g., credit/debit cards).

• Trip Tracking: Ability to track card usage, including trips, charges, and balances.

• Authentication and Security: Ensuring the privacy of user data and preventing fraudulent activities.

• Ticketing and Pass System: The system should allow users to purchase tickets or monthly passes using their transport cards.

• Reports and Notifications: Sending alerts about low balances, upcoming expiration dates, or discounts.

2. Core Classes and Objects

TransportCard Class

The central entity in the system will be the TransportCard. This class represents an individual user’s card and encapsulates all the information and behaviors associated with the card.

python
CopyEdit
class TransportCard:
    def __init__(self, card_id, user_id, balance=0.0, status='Active'):
        self.card_id = card_id
        self.user_id = user_id
        self.balance = balance
        self.status = status

    def add_funds(self, amount):
        if amount > 0:
            self.balance += amount
        else:
            raise ValueError("Amount must be positive.")
    
    def deduct_fare(self, fare):
        if self.balance >= fare:
            self.balance -= fare
        else:
            raise ValueError("Insufficient funds.")
    
    def deactivate(self):
        self.status = 'Inactive'

    def activate(self):
        self.status = 'Active'

    def get_balance(self):
        return self.balance

    def __str__(self):
        return f"Card ID: {self.card_id}, User ID: {self.user_id}, Balance: {self.balance}, Status: {self.status}"

Key Properties and Methods:

• card_id: Unique identifier for the transport card.

• user_id: The ID of the user associated with the card.

• balance: The current balance on the card.

• status: Indicates if the card is active or inactive.

• add_funds(): Method to add money to the card.

• deduct_fare(): Deducts the fare when a user completes a journey.

• deactivate()/activate(): Methods to manage the card’s status.

User Class

The User class represents the person who owns the transport card. It can be associated with multiple transport cards.

python
CopyEdit
class User:
    def __init__(self, user_id, name, email, phone_number):
        self.user_id = user_id
        self.name = name
        self.email = email
        self.phone_number = phone_number
        self.cards = []

    def add_card(self, card):
        self.cards.append(card)

    def remove_card(self, card):
        if card in self.cards:
            self.cards.remove(card)
        else:
            raise ValueError("Card not found.")

    def get_card_details(self):
        return [str(card) for card in self.cards]

Key Properties and Methods:

• user_id: A unique identifier for the user.

• name, email, phone_number: User’s contact information.

• cards: A list that holds all the transport cards associated with the user.

• add_card()/remove_card(): Methods to manage the user’s cards.

PaymentGateway Class

The PaymentGateway class facilitates integration with external payment systems to top-up the transport card.

python
CopyEdit
class PaymentGateway:
    def process_payment(self, card, amount):
        # Simulate the payment process (this would be integrated with a real payment API)
        card.add_funds(amount)
        print(f"Payment of {amount} processed. New balance: {card.get_balance()}")

Key Methods:

• process_payment(): Simulates the transaction process, adding funds to the user’s transport card.

Transaction Class

The Transaction class tracks individual payments and fare deductions. This class could be used for audit purposes, generating reports, or for user transaction history.

python
CopyEdit
class Transaction:
    def __init__(self, transaction_id, card_id, amount, transaction_type, timestamp):
        self.transaction_id = transaction_id
        self.card_id = card_id
        self.amount = amount
        self.transaction_type = transaction_type  # 'Top-Up' or 'Fare Deduction'
        self.timestamp = timestamp

    def __str__(self):
        return f"Transaction ID: {self.transaction_id}, Card ID: {self.card_id}, Amount: {self.amount}, Type: {self.transaction_type}, Date: {self.timestamp}"

Key Properties and Methods:

• transaction_id: Unique identifier for each transaction.

• card_id: The ID of the transport card involved in the transaction.

• amount: The amount involved in the transaction (either a top-up or a fare deduction).

• transaction_type: Identifies whether the transaction was a “Top-Up” or a “Fare Deduction.”

• timestamp: When the transaction took place.

Ticket Class

The Ticket class represents individual tickets or passes that can be purchased using the transport card.

python
CopyEdit
class Ticket:
    def __init__(self, ticket_id, fare, expiry_date, ticket_type):
        self.ticket_id = ticket_id
        self.fare = fare
        self.expiry_date = expiry_date
        self.ticket_type = ticket_type  # 'Single', 'Monthly', etc.

    def __str__(self):
        return f"Ticket ID: {self.ticket_id}, Fare: {self.fare}, Expiry: {self.expiry_date}, Type: {self.ticket_type}"

Key Properties and Methods:

• ticket_id: Unique identifier for the ticket.

• fare: The fare associated with the ticket.

• expiry_date: When the ticket expires (only for time-based tickets).

• ticket_type: Type of the ticket (e.g., single, monthly).

3. System Design Overview

Relationships Between Classes

• User and TransportCard: A user can own multiple transport cards, but each card is associated with only one user.

• TransportCard and PaymentGateway: The TransportCard interacts with PaymentGateway for adding funds, enabling secure online payments.

• Transaction and TransportCard: Every top-up or fare deduction is recorded as a Transaction.

• Ticket and TransportCard: Users can purchase tickets or passes linked to their transport cards.

Inheritance and Polymorphism

We could create subclasses to extend the functionality of certain classes. For example:

• The Ticket class can have subclasses like MonthlyTicket and SingleTicket, which can override methods to handle specific behavior like expiry validation or fare calculations.

python
CopyEdit
class MonthlyTicket(Ticket):
    def __init__(self, ticket_id, fare, expiry_date, user_id):
        super().__init__(ticket_id, fare, expiry_date, 'Monthly')
        self.user_id = user_id

    def validate_ticket(self):
        # Custom validation for monthly tickets
        pass

4. Conclusion

By applying object-oriented principles, we can design a robust and maintainable online public transport card system. This system includes classes to manage users, transport cards, payments, transactions, and tickets. Through encapsulation, inheritance, and polymorphism, the system can easily adapt to changes, such as adding new card types, integrating with different payment gateways, or supporting additional ticketing features.