Designing a Charity Donation Platform with Object-Oriented Design

Designing a Charity Donation Platform with Object-Oriented Design (OOD)

A charity donation platform connects donors with causes, enabling users to donate money, track donations, and manage campaigns. In this design, Object-Oriented Design (OOD) principles will be applied to ensure scalability, maintainability, and efficiency.

1. Identifying the Key Entities and Classes

In OOD, the first step is to identify the primary entities (or objects) in the system. These objects will be represented as classes. For a charity donation platform, we might identify the following entities:

Donor: Represents the user who makes the donation.
Charity Organization: Represents the non-profit or charity receiving donations.
Donation: Represents a transaction where a donor contributes to a charity.
Campaign: Represents specific fundraising campaigns run by charity organizations.
Payment Method: Represents different methods donors can use to donate (e.g., credit card, PayPal).
Receipt: Represents the acknowledgment sent to the donor after a successful donation.

2. Class Design and Relationships

With the entities in mind, we can now define the relationships and responsibilities for each class. Let’s break down the design:

2.1 Donor Class

The Donor class encapsulates information about a donor. Its responsibilities might include managing donor details and making donations.

python
class Donor:
    def __init__(self, donor_id, name, email, phone_number, address):
        self.donor_id = donor_id
        self.name = name
        self.email = email
        self.phone_number = phone_number
        self.address = address
        self.donations = []  # List of Donation objects

    def make_donation(self, amount, charity, payment_method):
        donation = Donation(self, amount, charity, payment_method)
        self.donations.append(donation)
        charity.receive_donation(donation)
        return donation

Key Attributes:

donor_id, name, email, phone_number, address: Donor’s personal information.
donations: A list of donations made by the donor.

Key Methods:

make_donation(): A method for making donations to a charity.

2.2 Charity Organization Class

The Charity class manages charity information and receives donations.

python
class Charity:
    def __init__(self, charity_id, name, cause, address):
        self.charity_id = charity_id
        self.name = name
        self.cause = cause
        self.address = address
        self.donations_received = []  # List of Donation objects
        self.campaigns = []  # List of Campaign objects

    def receive_donation(self, donation):
        self.donations_received.append(donation)

    def create_campaign(self, campaign_name, target_amount):
        campaign = Campaign(self, campaign_name, target_amount)
        self.campaigns.append(campaign)
        return campaign

Key Attributes:

charity_id, name, cause, address: Charity’s information.
donations_received: A list of donations received by the charity.
campaigns: A list of campaigns the charity is running.

Key Methods:

receive_donation(): Records a donation received by the charity.
create_campaign(): Creates a new fundraising campaign for the charity.

2.3 Donation Class

The Donation class tracks individual donation transactions.

python
class Donation:
    def __init__(self, donor, amount, charity, payment_method):
        self.donor = donor
        self.amount = amount
        self.charity = charity
        self.payment_method = payment_method
        self.timestamp = datetime.now()

    def generate_receipt(self):
        return Receipt(self.donor, self.amount, self.charity, self.timestamp)

Key Attributes:

donor: The donor making the donation.
amount: The amount donated.
charity: The charity receiving the donation.
payment_method: The method used for payment (Credit Card, PayPal, etc.).
timestamp: The date and time when the donation was made.

Key Methods:

generate_receipt(): Generates a receipt for the donation.

2.4 Campaign Class

The Campaign class represents a fundraising campaign initiated by a charity.

python
class Campaign:
    def __init__(self, charity, campaign_name, target_amount):
        self.charity = charity
        self.campaign_name = campaign_name
        self.target_amount = target_amount
        self.total_donations = 0  # Total donations for this campaign
        self.donations = []  # List of Donation objects

    def add_donation(self, donation):
        self.donations.append(donation)
        self.total_donations += donation.amount

Key Attributes:

charity: The charity running the campaign.
campaign_name: The name of the campaign.
target_amount: The goal for the fundraising campaign.
total_donations: The total amount donated to this campaign.
donations: A list of donations made to the campaign.

Key Methods:

add_donation(): Adds a donation to the campaign and updates the total donations.

2.5 Payment Method Class

The Payment Method class represents a donation method.

python
class PaymentMethod:
    def __init__(self, method_type, details):
        self.method_type = method_type  # E.g., 'Credit Card', 'PayPal'
        self.details = details  # Additional info like card number, PayPal account

    def process_payment(self, amount):
        # Simulate payment processing logic
        print(f"Processing {self.method_type} payment of ${amount}.")
        return True  # Return True for successful payment

Key Attributes:

method_type: The type of payment method (e.g., Credit Card, PayPal).
details: Details of the payment method, such as card number or PayPal account.

Key Methods:

process_payment(): Simulates processing the payment.

2.6 Receipt Class

The Receipt class is used to generate a donation receipt.

python
class Receipt:
    def __init__(self, donor, amount, charity, timestamp):
        self.donor = donor
        self.amount = amount
        self.charity = charity
        self.timestamp = timestamp

    def display_receipt(self):
        print(f"Receipt: nDonor: {self.donor.name} nAmount: ${self.amount} nCharity: {self.charity.name} nDate: {self.timestamp}")

Key Attributes:

donor: The donor’s information.
amount: The donation amount.
charity: The charity receiving the donation.
timestamp: The timestamp of the donation.

Key Methods:

display_receipt(): Displays the receipt details.

3. Design Principles and Practices

Encapsulation: Each class encapsulates its own data and methods. For example, the Donor class manages donor details, while the Campaign class manages donations related to a particular campaign.
Abstraction: The system abstracts away complex operations like payment processing (PaymentMethod), while presenting a simplified interface for making donations.
Inheritance: You could introduce inheritance for payment methods if needed. For example, you might have a CreditCardPayment subclass and a PayPalPayment subclass, both inheriting from PaymentMethod.
Polymorphism: You could define a process_payment() method in each subclass of PaymentMethod, allowing the platform to handle different types of payments in the same way.

4. User Interaction Flow

Donors can sign up and choose a charity to donate to.
They can browse ongoing Campaigns and choose one they want to contribute to.
Payment Methods are used to process donations.
Once a donation is made, a Receipt is generated and sent to the donor.
Charity Organizations can create new fundraising campaigns and track donations.

5. Conclusion

This design utilizes core OOD principles such as encapsulation, abstraction, and modularity. The system can be easily expanded to include additional features like recurring donations, user reviews of charities, and integration with external payment gateways. This object-oriented approach ensures scalability, flexibility, and ease of maintenance for the charity donation platform.

Share this Page your favorite way: Click any app below to share.

See all the ways to share this page

Designing a Charity Donation Platform with Object-Oriented Design