Design a Campus Lost and Found Tracking Platform Using OOD Concepts

Designing a Campus Lost and Found Tracking Platform Using Object-Oriented Design (OOD)

1. Introduction

The design of a Campus Lost and Found Tracking Platform using Object-Oriented Design (OOD) principles aims to create a system where students, faculty, and staff can report lost and found items and track the status of those items in a user-friendly, efficient way. The platform must be able to handle diverse items, various types of users, and provide the capability to search, claim, or report lost items.

This system can be used on a web or mobile platform and will need to have distinct user roles (e.g., student, faculty, staff, and admin) to ensure the proper flow of actions.

2. Key Use Cases

• Report a Lost Item: Users can report a lost item with a description, image, and location where the item was last seen.

• Report a Found Item: Users can report an item they have found, providing a description, location, and any additional details.

• Search for Items: Users can search the lost and found items based on filters like item type, date, location, or keywords.

• Claim an Item: Once a user finds their lost item, they can claim it through the platform.

• Admin Dashboard: Admins have access to a dashboard where they can review items, verify claims, and manage user reports.

3. Object-Oriented Design Concepts

3.1 Classes and Objects

Using Object-Oriented Design, the system will be broken down into various classes, each encapsulating data and behavior associated with specific components of the platform.

Here are the major classes that will be part of the system:

1. User Class

   • Attributes:

     • userID: unique identifier for each user

     • name: name of the user

     • email: contact information

     • role: (student, faculty, staff, admin)

   • Methods:

     • reportLostItem(): Method to report a lost item

     • reportFoundItem(): Method to report a found item

     • searchItems(): Method to search for lost or found items

     • claimItem(): Method to claim an item

     • viewItemDetails(): View detailed information of an item

2. Item Class

   • Attributes:

     • itemID: unique identifier for the item

     • description: description of the item

     • itemType: category of item (e.g., bag, wallet, laptop)

     • location: location where the item was found or lost

     • dateReported: date the item was reported

     • status: (Lost, Found, Claimed, Archived)

     • image: image of the item (optional)

     • user: reference to the user who reported the item

   • Methods:

     • updateStatus(): Method to update the status of the item (from Lost to Found or Claimed)

     • updateLocation(): Method to update the location of the item

     • getItemDetails(): Retrieve item details such as description, status, and location

3. Admin Class (Inherits from User)

   • Attributes:

     • adminID: unique identifier for each admin

   • Methods:

     • verifyClaim(): Admin verifies the claim of an item

     • manageReports(): Admin can review and delete reports

     • viewAllItems(): Admin can see all items reported, regardless of status

     • archiveItem(): Move items to the archive once claimed or if found after a certain period

4. Search Class

   • Attributes:

     • searchCriteria: criteria for searching (item type, location, status)

   • Methods:

     • filterByLocation(): Filters items based on location

     • filterByStatus(): Filters items by their status (Lost, Found)

     • filterByItemType(): Filters items by category (e.g., bag, electronics)

     • sortItems(): Sort items by date, relevance, or proximity

3.2 Relationships Between Classes

• User ↔ Item: A user can report multiple items (lost or found). Each item is linked to a user who reported it.

• Admin ↔ Item: Admins have special privileges to manage and verify the status of items.

• Item ↔ Search: The search functionality can filter and sort items, allowing users to find lost or found items easily.

4. System Workflow

1. User Registration/Login: Users (students, faculty, staff) can register and log in. This can be handled through an authentication system where their credentials are verified.

2. Reporting Lost or Found Items:

   • Users will have an option to report an item as lost or found.

   • They will be asked to provide a description, item category, location, and an optional photo of the item.

   • Once the item is reported, it will be placed in the system with the status “Lost” or “Found.”

3. Searching and Claiming Items:

   • Users can search for items by using various filters (location, item type, date).

   • Once a matching item is found, the user can claim it if it belongs to them.

   • After a claim is made, an admin will verify the details before updating the status of the item to “Claimed.”

4. Admin Verification:

   • Admins can view all reported items. They have the ability to mark items as “Claimed,” “Found,” or “Archived” (in case the item is never claimed).

5. Notifications:

   • Notifications will be sent to users when their claimed item is verified or when a matching lost item is reported.

5. System Design Using OOD

Here’s a simplified class diagram for the system:

pgsql
CopyEdit
+--------------------------------------+
|               User                   |
+--------------------------------------+
| - userID: int                        |
| - name: String                       |
| - email: String                      |
| - role: String (student/faculty)     |
+--------------------------------------+
| + reportLostItem()                  |
| + reportFoundItem()                 |
| + searchItems()                     |
| + claimItem()                       |
| + viewItemDetails()                 |
+--------------------------------------+
          ^
          |
          |
+--------------------------------------+
|               Admin                  |
+--------------------------------------+
| - adminID: int                       |
+--------------------------------------+
| + verifyClaim()                      |
| + manageReports()                    |
| + viewAllItems()                     |
| + archiveItem()                      |
+--------------------------------------+

+--------------------------------------+
|               Item                   |
+--------------------------------------+
| - itemID: int                        |
| - description: String                |
| - itemType: String                   |
| - location: String                   |
| - dateReported: Date                 |
| - status: String (Lost/Found)        |
| - image: String                      |
| - user: User                         |
+--------------------------------------+
| + updateStatus()                     |
| + updateLocation()                   |
| + getItemDetails()                   |
+--------------------------------------+

+--------------------------------------+
|               Search                 |
+--------------------------------------+
| - searchCriteria: Map                |
+--------------------------------------+
| + filterByLocation()                 |
| + filterByStatus()                   |
| + filterByItemType()                 |
| + sortItems()                        |
+--------------------------------------+

6. Potential Extensions

• Geolocation Feature: Integrate a geolocation feature to automatically detect the location of lost or found items using GPS.

• User Feedback/Rating: Allow users to rate their experience with the platform, helping improve user interactions.

• Mobile App Integration: Develop a mobile app to make it easier for users to report and track items on the go.

7. Conclusion

The Campus Lost and Found Tracking Platform, using Object-Oriented Design principles, ensures that the system is modular, scalable, and flexible. The user-centered design improves the user experience, and roles-based management ensures the proper flow of operations. This system can easily scale to other campuses or integrate with campus-wide services, providing an efficient solution for managing lost and found items.