Designing a Digital Public Notice Board Using OOD Principles

Designing a Digital Public Notice Board using Object-Oriented Design (OOD) principles involves identifying the key objects, their attributes, and their interactions within the system. The goal is to create an interactive and user-friendly digital notice board that can display various notices, manage user interactions, and support administrative tasks. Here’s a breakdown of the design:

1. Identifying the Key Objects (Classes)

1. Notice

   • Attributes:

     • Title: The title of the notice (String)

     • Description: The content or details of the notice (String)

     • Date: The date the notice was created (DateTime)

     • ExpiryDate: The date the notice expires (DateTime)

     • Category: The type of notice (e.g., public, official, event) (String)

     • Priority: Determines whether the notice is urgent or standard (Integer)

   • Methods:

     • displayNotice(): Display the notice details on the board

     • editNotice(): Edit the notice content

     • deleteNotice(): Remove the notice after it expires or is no longer relevant

     • isExpired(): Check if the notice is expired (returns Boolean)

2. User

   • Attributes:

     • UserID: Unique identifier for the user (Integer)

     • Name: Name of the user (String)

     • Role: Defines the user’s role (Admin, User) (String)

   • Methods:

     • createNotice(): Allow the user to create a new notice (Admin only)

     • viewNotices(): View all notices available on the board

     • editNotice(): Edit notices (Admin only)

     • deleteNotice(): Delete notices (Admin only)

3. NoticeBoard

   • Attributes:

     • Notices: A collection of Notice objects (ArrayList or LinkedList)

     • Categories: Categories of notices displayed on the board (e.g., “Events,” “Announcements,” “Urgent”) (ArrayList)

     • Users: A list of registered users (ArrayList)

   • Methods:

     • addNotice(): Add a new notice to the board (called by admin)

     • removeNotice(): Remove an expired or deleted notice from the board

     • filterNoticesByCategory(): Display notices filtered by a specific category

     • searchNotices(): Search for notices by keywords or titles

     • displayBoard(): Display all notices on the public board

4. Admin (Subclass of User)

   • Methods:

     • approveNotice(): Approve a notice before publishing (if required)

     • banUser(): Block users who violate terms of service or misuse the platform

5. Notification

   • Attributes:

     • UserID: The ID of the user receiving the notification (Integer)

     • Message: The notification content (String)

     • Date: The date and time the notification was sent (DateTime)

   • Methods:

     • sendNotification(): Notify a user about a new notice or an action taken on their submitted notice

2. Defining Relationships and Interactions

• User-NoticeBoard Interaction:

  • A User can view the notices on the NoticeBoard using the viewNotices() method.

  • Admin users can create, edit, and delete notices using their special methods, such as createNotice() or deleteNotice().

  • Regular users can only view notices and may search or filter by category.

• Notice-NoticeBoard Interaction:

  • The NoticeBoard contains an array of Notice objects, which can be added or removed using methods like addNotice() and removeNotice().

  • The notices may have categories that help users filter the content for easier access.

• Notification-User Interaction:

  • Users receive notifications regarding their notices’ status (e.g., approval, expiration) through the Notification object, which uses the sendNotification() method.

3. System Use Cases

1. View Notices: Users access the notice board to view the available notices.

   • Regular users can see public notices and search through them.

   • Admins can view all notices, including private or pending notices.

2. Create a Notice: Admins or authorized users can create a new notice with a title, description, and category.

   • They can set an expiry date and priority level for the notice.

3. Edit or Delete a Notice: Admins can modify or remove notices based on the urgency, relevancy, or expiration date.

4. Filter/Search Notices: Users can search or filter notices by category or keywords for easy navigation.

5. Send Notifications: Users receive notifications if there are updates to notices or any action required on their submitted notices.

4. Data Flow and Interaction Diagrams

• Activity Diagram for Viewing Notices:

  1. User logs in to the system.

  2. User navigates to the notice board.

  3. The system retrieves the list of notices from the database.

  4. The user can filter/search notices or view them based on category.

  5. The system displays the filtered notices.

• Activity Diagram for Creating a Notice:

  1. Admin logs in to the system.

  2. Admin clicks “Create Notice”.

  3. Admin enters the notice details (title, description, expiry date, etc.).

  4. The system validates the information.

  5. The system adds the notice to the notice board.

5. Considerations for Future Enhancements

• Access Control: More roles can be introduced, such as a Moderator role for users who need limited admin access.

• Real-Time Updates: Implement WebSockets or push notifications for real-time updates when new notices are posted or updated.

• User Feedback: Allow users to comment or like notices to increase engagement.

6. Example Code (in Java)

java
CopyEdit
// Notice Class
public class Notice {
    private String title;
    private String description;
    private Date date;
    private Date expiryDate;
    private String category;
    private int priority;

    public void displayNotice() {
        // Logic to display notice
    }

    public boolean isExpired() {
        return expiryDate.before(new Date());
    }
}

// User Class
public class User {
    private int userId;
    private String name;
    private String role;

    public void viewNotices() {
        // Logic for viewing notices
    }
}

// Admin Class
public class Admin extends User {
    public void createNotice(Notice notice) {
        // Logic to create a notice
    }
}

This design follows the principles of encapsulation, inheritance, and polymorphism. It ensures that the system is modular and easy to maintain.