Design a Digital Lost Pet Alert System Using Object-Oriented Design

Digital Lost Pet Alert System Design Using Object-Oriented Design (OOD)

The goal of this system is to provide a platform for pet owners to report and search for lost pets, improving the chances of recovering them. By utilizing Object-Oriented Design (OOD) principles, the system will be modular, scalable, and maintainable. Here’s a breakdown of the system:

1. Requirements Analysis

The system needs to have the following core functionalities:

• Pet Registration: Owners can register lost pets.

• Alert System: Notifications for lost pets are sent to nearby users.

• Search Functionality: Users can search for lost pets based on location, type, and breed.

• User Profiles: Both pet owners and community users can create profiles.

• Pet Found Alerts: Users can report found pets to help in the search.

• Admin Panel: For managing reported lost pets and user interactions.

2. Key Objects & Classes

The main objects that will be used in the system are as follows:

2.1 Pet Class

The Pet class represents a lost pet. It contains details about the pet and the status of the alert.

python
CopyEdit
class Pet:
    def __init__(self, pet_id, name, species, breed, color, age, last_seen_location, description, owner_id):
        self.pet_id = pet_id
        self.name = name
        self.species = species
        self.breed = breed
        self.color = color
        self.age = age
        self.last_seen_location = last_seen_location
        self.description = description
        self.owner_id = owner_id
        self.status = "Lost"  # Can be "Lost", "Found", "Recovered"
        self.date_reported = None
        self.date_last_seen = None
        self.alert_sent = False

• Attributes:

  • pet_id: Unique identifier for the pet.

  • name: Pet’s name.

  • species: Dog, cat, bird, etc.

  • breed: Breed of the pet.

  • color: Color description of the pet.

  • age: Age of the pet.

  • last_seen_location: Where the pet was last seen.

  • description: Any other details that can help identify the pet.

  • owner_id: ID linking to the owner’s profile.

2.2 User Class

The User class represents the users (both pet owners and community members) who interact with the platform.

python
CopyEdit
class User:
    def __init__(self, user_id, name, contact_info, role):
        self.user_id = user_id
        self.name = name
        self.contact_info = contact_info
        self.role = role  # Can be "Owner" or "Community"
        self.profile_picture = None
        self.reports = []

• Attributes:

  • user_id: Unique identifier for the user.

  • name: Name of the user.

  • contact_info: Contact details like phone number or email.

  • role: Defines if the user is a pet owner or a community helper.

  • profile_picture: Optional profile image.

2.3 Alert Class

The Alert class is responsible for managing lost pet notifications sent to nearby users.

python
CopyEdit
class Alert:
    def __init__(self, alert_id, pet_id, location, distance_range):
        self.alert_id = alert_id
        self.pet_id = pet_id
        self.location = location
        self.distance_range = distance_range
        self.alert_sent_time = None
        self.alert_status = "Active"  # Can be "Active", "Expired", "Resolved"

• Attributes:

  • alert_id: Unique identifier for the alert.

  • pet_id: Links the alert to a specific pet.

  • location: Geographic coordinates of where the pet was last seen.

  • distance_range: Range around the pet’s last seen location to send alerts to users.

  • alert_status: Status of the alert.

2.4 FoundPet Class

The FoundPet class tracks found pets reported by the community.

python
CopyEdit
class FoundPet:
    def __init__(self, found_pet_id, pet_id, location_found, finder_id):
        self.found_pet_id = found_pet_id
        self.pet_id = pet_id
        self.location_found = location_found
        self.finder_id = finder_id
        self.status = "Reported"  # Can be "Reported", "Verified"
        self.date_found = None

• Attributes:

  • found_pet_id: Unique identifier for the found pet report.

  • pet_id: Links the found pet to a lost pet alert.

  • location_found: The location where the pet was found.

  • finder_id: ID of the person who reported finding the pet.

3. System Functionality and Flow

3.1 Pet Registration

A pet owner can register a lost pet by entering its details into the system. The system will then create an alert and notify the community.

python
CopyEdit
def register_lost_pet(owner, pet_details):
    pet = Pet(**pet_details)
    pet.owner_id = owner.user_id
    pet.date_reported = get_current_time()
    create_alert_for_pet(pet)
    return pet

3.2 Alert System

Once a pet is reported as lost, an alert will be created, and notifications will be sent to all users within a specific distance of the last seen location.

python
CopyEdit
def create_alert_for_pet(pet):
    alert = Alert(pet.pet_id, pet.last_seen_location, distance_range=10)  # 10 km radius
    send_alert_to_nearby_users(alert)

The send_alert_to_nearby_users function will be responsible for sending notifications to users in the proximity based on the pet’s last known location.

3.3 Search Functionality

Users can search for lost pets based on certain criteria (species, breed, location, etc.). A search query will return relevant pets matching the filters.

python
CopyEdit
def search_lost_pets(search_criteria):
    results = []
    for pet in all_pets:
        if matches_search_criteria(pet, search_criteria):
            results.append(pet)
    return results

3.4 Pet Found Alerts

If a community member finds a lost pet, they can report it through the FoundPet class. The system will then notify the pet owner.

python
CopyEdit
def report_found_pet(finder, found_pet_details):
    found_pet = FoundPet(**found_pet_details)
    found_pet.finder_id = finder.user_id
    pet = find_lost_pet(found_pet.pet_id)
    notify_owner_of_found_pet(pet.owner_id, found_pet)
    return found_pet

3.5 Admin Panel

Admins can manage pet reports, view alert statuses, and remove expired or resolved reports.

python
CopyEdit
class Admin(User):
    def __init__(self, user_id, name, contact_info):
        super().__init__(user_id, name, contact_info, role="Admin")
    
    def resolve_alert(self, alert_id):
        alert = get_alert_by_id(alert_id)
        alert.alert_status = "Resolved"

4. Key Design Principles

• Encapsulation: Each class has its own responsibility, and the internal workings are hidden from other classes. For example, the Pet class handles pet details, while the Alert class handles alert management.

• Inheritance: The Admin class inherits from the User class, allowing for role-specific behavior.

• Polymorphism: The report_found_pet function can handle multiple types of found pets (e.g., dog, cat, etc.), providing flexibility in reporting.

• Modularity: Each feature, like pet registration, alerts, or search, is encapsulated in a separate class or function, making the system easy to extend or maintain.

5. Database Schema (Optional)

If you want to store the data persistently, a relational database schema might look like:

• Users Table: Stores user information (id, name, contact, role).

• Pets Table: Stores pet details (id, name, breed, species, description, owner_id).

• Alerts Table: Stores alert details (id, pet_id, status, location, sent_time).

• Found Pets Table: Stores found pet information (id, pet_id, location, finder_id).

6. Conclusion

The Digital Lost Pet Alert System is designed to be modular and scalable, following Object-Oriented Design principles. By breaking down the system into well-defined objects (Pet, User, Alert, etc.), the system ensures high cohesion and low coupling, which are key for maintainability and future enhancements. The combination of user-friendly functionality (pet registration, search, alerts) and a robust backend structure creates a highly effective lost pet recovery system.