Designing a Gym Membership Management System with Object-Oriented Design

A Gym Membership Management System (GMMS) is a software solution designed to manage various aspects of gym operations, including member registration, membership plans, attendance tracking, and payment processing. To implement this system using Object-Oriented Design (OOD), we need to identify the key objects and their relationships within the system.

1. Identify Key Entities and Their Relationships

In any gym management system, several entities play crucial roles. These include:

• Member

• Membership Plan

• Trainer

• Workout Session

• Attendance

• Payment

• Equipment

• Admin

Each entity interacts with others in various ways. For instance, a Member subscribes to a Membership Plan, a Trainer is assigned to Workout Sessions, and Payments are linked to Membership Plans.

2. Define Classes and Their Attributes

Member Class

The Member class represents the individuals who are registered in the gym. The member’s data includes personal information and membership details.

python
CopyEdit
class Member:
    def __init__(self, member_id, name, date_of_birth, email, phone_number):
        self.member_id = member_id
        self.name = name
        self.date_of_birth = date_of_birth
        self.email = email
        self.phone_number = phone_number
        self.membership_plan = None
        self.attendance = []
        self.payments = []
    
    def update_profile(self, name=None, email=None, phone_number=None):
        if name: self.name = name
        if email: self.email = email
        if phone_number: self.phone_number = phone_number
    
    def subscribe_plan(self, membership_plan):
        self.membership_plan = membership_plan
    
    def make_payment(self, payment):
        self.payments.append(payment)
    
    def mark_attendance(self, session):
        self.attendance.append(session)

Membership Plan Class

The MembershipPlan class contains different types of membership offered by the gym, such as monthly, yearly, or special plans.

python
CopyEdit
class MembershipPlan:
    def __init__(self, plan_id, name, duration_months, price):
        self.plan_id = plan_id
        self.name = name
        self.duration_months = duration_months
        self.price = price
    
    def display_plan_details(self):
        return f"{self.name} Plan: {self.duration_months} months, Price: ${self.price}"

Trainer Class

The Trainer class represents the gym’s trainers who are assigned to different workout sessions. It includes details such as trainer name, expertise, and the sessions they lead.

python
CopyEdit
class Trainer:
    def __init__(self, trainer_id, name, expertise):
        self.trainer_id = trainer_id
        self.name = name
        self.expertise = expertise
        self.sessions = []
    
    def assign_session(self, session):
        self.sessions.append(session)

Workout Session Class

The WorkoutSession class represents individual workout sessions that members attend. It includes the trainer, session date, and participants.

python
CopyEdit
class WorkoutSession:
    def __init__(self, session_id, date, time, trainer):
        self.session_id = session_id
        self.date = date
        self.time = time
        self.trainer = trainer
        self.participants = []
    
    def add_participant(self, member):
        self.participants.append(member)
    
    def get_session_details(self):
        return f"Session on {self.date} at {self.time} with Trainer: {self.trainer.name}"

Attendance Class

The Attendance class tracks the attendance of each member for the workout sessions.

python
CopyEdit
class Attendance:
    def __init__(self, session, member, status):
        self.session = session
        self.member = member
        self.status = status  # Present, Absent, etc.
    
    def mark_attendance(self):
        if self.status == "Present":
            self.member.mark_attendance(self.session)

Payment Class

The Payment class handles transactions made by members for their membership subscriptions.

python
CopyEdit
class Payment:
    def __init__(self, payment_id, amount, date, member):
        self.payment_id = payment_id
        self.amount = amount
        self.date = date
        self.member = member
    
    def process_payment(self):
        self.member.make_payment(self)

Admin Class

The Admin class has the authority to manage all aspects of the system, such as adding new trainers, membership plans, and managing payments.

python
CopyEdit
class Admin:
    def __init__(self, admin_id, name):
        self.admin_id = admin_id
        self.name = name
    
    def add_member(self, member):
        # Add member logic
        pass
    
    def create_plan(self, plan):
        # Add new membership plan
        pass
    
    def assign_trainer(self, trainer, session):
        # Assign trainer to a session
        pass
    
    def process_payment(self, payment):
        # Process payment
        pass

3. Define Relationships Between Classes

• A Member subscribes to a MembershipPlan and can attend multiple WorkoutSessions. They make Payments for the membership.

• A Trainer conducts one or more WorkoutSessions.

• Attendance tracks which Member attended which WorkoutSession.

• An Admin manages the system, adds members, trainers, plans, and processes payments.

4. System Operations and Use Cases

Member Registration

1. A new member registers and provides personal information.

2. They are assigned a membership plan and make an initial payment.

Subscription to Membership Plans

1. Members select a plan (e.g., monthly or yearly).

2. The system calculates the total price and tracks the payment.

Session Scheduling and Attendance

1. Trainers schedule workout sessions.

2. Members can mark their attendance for each session.

Payment Processing

1. Payments for membership are tracked.

2. An Admin ensures payments are processed correctly.

5. Example Usage

python
CopyEdit
# Creating Membership Plans
basic_plan = MembershipPlan(1, "Basic", 1, 30)
premium_plan = MembershipPlan(2, "Premium", 12, 300)

# Creating a Member
john = Member(101, "John Doe", "1990-05-12", "john@example.com", "555-1234")

# Subscribing to a Plan
john.subscribe_plan(premium_plan)

# Creating a Trainer
trainer_jane = Trainer(201, "Jane Smith", "Strength Training")

# Creating a Workout Session
session1 = WorkoutSession(301, "2025-08-01", "10:00 AM", trainer_jane)
session1.add_participant(john)

# Marking Attendance
attendance = Attendance(session1, john, "Present")
attendance.mark_attendance()

# Making a Payment
payment1 = Payment(401, 300, "2025-07-15", john)
payment1.process_payment()

6. Scalability and Extensibility

To scale and extend the system, consider the following:

• Extending Membership Plans: Add more membership types or discounts (e.g., student discount).

• Enhancing Payment Processing: Integrate with third-party payment gateways (Stripe, PayPal).

• Session Features: Add features for group classes, personal training, and online workouts.

• Notifications: Send reminders for upcoming sessions or membership renewal.

By using Object-Oriented Design principles, we can easily scale, maintain, and enhance the system to accommodate growing gym operations and improve user experience.