Design a Smart Public Building Maintenance Request System Using OOD Principles

Smart Public Building Maintenance Request System Using Object-Oriented Design Principles

Designing a Smart Public Building Maintenance Request System (SPBMRS) involves creating a scalable, efficient, and user-friendly platform for managing maintenance requests across multiple public buildings. This system can help streamline the process of reporting, tracking, and resolving maintenance issues, ensuring that public spaces remain safe and functional for the community.

Core Design Concepts:

1. Modularity: Different components of the system should be separated into distinct, independent classes, allowing for easy modifications, extensions, and maintenance.

2. Encapsulation: Internal workings of classes should be hidden from the user and only necessary information should be exposed.

3. Inheritance: Common functionality between different types of buildings, users, and maintenance requests should be generalized in base classes and extended where necessary.

4. Polymorphism: Allow different types of requests or responses to be handled using the same interface, making the system more flexible.

Key Components of the System:

1. User: Represents any individual interacting with the system, such as building managers, maintenance workers, or citizens.

2. Building: Represents a public building with various attributes (location, type, size, etc.).

3. Maintenance Request: Represents a specific maintenance task or issue that needs attention.

4. Maintenance Worker: A person who performs the maintenance task after the request is made.

5. Administrator: Oversees the system, ensuring that requests are processed in a timely and efficient manner.

6. Notifications: Alert system to notify the relevant individuals when certain actions occur (e.g., request submission, status updates).

1. Class Design

User Class (Base Class)

This class represents a generic user in the system.

python
CopyEdit
class User:
    def __init__(self, user_id, name, role):
        self.user_id = user_id
        self.name = name
        self.role = role  # role can be 'admin', 'manager', 'citizen', etc.

    def view_request(self, request_id):
        pass  # Users can view maintenance requests based on their role

    def create_request(self, building, issue):
        pass  # Citizens or managers can create maintenance requests

Building Class

Each building has a unique ID and various properties, including location and type.

python
CopyEdit
class Building:
    def __init__(self, building_id, name, location, building_type):
        self.building_id = building_id
        self.name = name
        self.location = location
        self.building_type = building_type  # e.g., "school", "library"
        self.maintenance_requests = []

    def add_request(self, request):
        self.maintenance_requests.append(request)  # Add request to the building’s list

MaintenanceRequest Class

Represents a maintenance issue raised for a building. Each request has a status (open, in-progress, resolved).

python
CopyEdit
class MaintenanceRequest:
    def __init__(self, request_id, building, issue, description, status='open'):
        self.request_id = request_id
        self.building = building
        self.issue = issue  # e.g., "leak", "lighting failure"
        self.description = description
        self.status = status  # 'open', 'in-progress', 'resolved'
        self.requester = None  # Can be a user who created the request
        self.assigned_worker = None  # Maintenance worker handling the request

    def update_status(self, new_status):
        self.status = new_status
        # Notify requester about status change
        self.send_notification()

    def send_notification(self):
        pass  # Send an alert to the user

MaintenanceWorker Class (Inherits User)

A maintenance worker inherits from the User class but has additional responsibilities, such as handling maintenance tasks.

python
CopyEdit
class MaintenanceWorker(User):
    def __init__(self, user_id, name, role, worker_id):
        super().__init__(user_id, name, role)
        self.worker_id = worker_id

    def assign_request(self, request):
        request.assigned_worker = self
        request.update_status('in-progress')

    def complete_request(self, request):
        request.update_status('resolved')

Administrator Class (Inherits User)

The administrator oversees the system, ensuring that requests are handled by the correct personnel.

python
CopyEdit
class Administrator(User):
    def __init__(self, user_id, name, role, admin_id):
        super().__init__(user_id, name, role)
        self.admin_id = admin_id

    def review_request(self, request):
        pass  # Administrator can review the request status

Notification Class

The notification system alerts users when certain actions occur (e.g., request status updates).

python
CopyEdit
class Notification:
    def __init__(self, notification_id, message, recipient):
        self.notification_id = notification_id
        self.message = message
        self.recipient = recipient

    def send(self):
        pass  # Logic to send notification to the recipient

2. System Flow

1. Request Creation: A user (e.g., a citizen or building manager) creates a maintenance request. This request is associated with a specific building and issue.

2. Request Assignment: Once a request is submitted, the administrator reviews the request and assigns a maintenance worker to handle the issue.

3. Status Update: The assigned maintenance worker updates the status of the request as the task progresses (e.g., from “open” to “in-progress” and then “resolved”).

4. Notifications: Users are notified whenever a request is created, assigned, or resolved. Notifications can be sent via email, SMS, or in-app.

3. Use Cases

1. Citizen Creates Maintenance Request: A citizen notices an issue in a public building and creates a maintenance request. The system assigns the request a unique ID and notifies the building manager.

2. Building Manager Reviews Request: The building manager reviews incoming maintenance requests and can either resolve minor issues or escalate them to the administrator.

3. Administrator Assigns Worker: The administrator can assign a maintenance worker to specific requests based on priority and skill.

4. Maintenance Worker Resolves Request: The maintenance worker updates the status of the request, which triggers a notification to the citizen who made the request, confirming the issue is resolved.

4. Benefits of This Design

• Scalability: New building types, request types, or user roles can be easily added by extending base classes without modifying existing code.

• Efficiency: The request workflow is automated, ensuring that maintenance issues are tracked, assigned, and resolved in a timely manner.

• Separation of Concerns: Different responsibilities (e.g., user management, building management, request handling) are separated into distinct classes, improving maintainability and reducing code duplication.

• Extensibility: New features such as analytics, performance tracking, or additional notification types can be added without disrupting the existing system.

5. Future Enhancements

1. Mobile App Integration: Provide mobile access for citizens and workers to submit and manage requests in real time.

2. AI for Prioritization: Use AI to analyze request severity and prioritize them based on building type, frequency of similar requests, or urgency.

3. Analytics Dashboard: Implement an analytics dashboard for administrators to view the performance of maintenance workers and overall request resolution times.

In conclusion, applying Object-Oriented Design principles to the Smart Public Building Maintenance Request System ensures a robust, extensible, and maintainable platform for managing public building maintenance. By organizing the system around clearly defined objects with specific responsibilities, the platform can grow over time while maintaining clarity and efficiency.