Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2024 - E2483. Reimplement Notification Controller and Model

2024-11-18T03:11:48Z

Ssomang: /* Design Pattern */

__TOC__

==Details about the Notification Model and Controller==

The Notification model in Expertiza serves a critical role in enhancing communication and user engagement on the platform. It is essential because it automates the process of alerting users to significant events, such as receiving feedback, team changes, or assignment updates, without requiring users to actively seek out this information. By streamlining these updates, the model reduces the risk of missed information, helping users stay on top of their responsibilities, collaborate more effectively, and respond in a timely manner. This function is particularly valuable in a platform like Expertiza, where users juggle multiple assignments, peer reviews, and team interactions, and would otherwise need to manually monitor changes and updates or rely on external tools for reminders.

The Notification model also improves the overall user experience by organizing and presenting notifications in a way that makes them easy to access and track. It stores notification details (like type, content, and timestamp) and associates them with specific users, ensuring each user receives personalized, relevant updates. Users can view notifications sorted by date or filtered by read/unread status, making it easier to prioritize tasks and responses. Ultimately, the Notification model supports Expertiza’s usability by helping users stay informed and accountable, contributing to an environment that encourages active participation and smooth collaboration across assignments.

==Objective==
The objective was to create a Notification model in the backend to handle notifications for the Expertiza system.

This model will manage notifications for different courses and be accessible to students and instructors based on their association with a course.
Notifications can have attributes such as subject, description, expiration date, and status (active/inactive).

The main objective is to create the Notification controller and model to handle sending and receiving notifications on the Expertiza platform.

==Requirements==
* Create a new Notification model with appropriate attributes and relationships:
* Define associations with User and Course models
* Implement scopes for filtering notifications based on roles
* Add validation rules for notification data
* Include timestamp fields for proper notification tracking
* Develop a NotificationsController with:
* Standard CRUD operations (create, read, update, delete)
* Role-based access control logic
* Course enrollment verification
* Proper error handling and response formatting
* RESTful API endpoints
* Implement authorization logic: Add policies to ensure students only see relevant notifications
* Write comprehensive test cases:
* Unit tests for the Notification model
* Controller tests covering all CRUD operations
* Integration tests for role-based access
* Test cases for error scenarios and edge cases

==Design Goals==
Implement the Notification backend: Implement the Notification in Ruby on Rails.

1. Model Creation:

Create a Notification model with the following key attributes:
* id: Primary key (auto-generated).
* subject: Brief title of the notification.
* description: Detailed message of the notification.
* expiration_date: The date when the notification should expire.
* is_active: Boolean flag to mark if the notification is active or inactive.
* is_unread: Boolean to mark if a notification is unread (default to true for new notifications).

2. Associations:

* Define associations between Notification, User, and Course models.
* User Association: Each notification should have a creator (e.g., a teaching assistant or instructor).
* Course Association: Each notification should be linked to a course, and the enrolled students should be able to view relevant notifications.

3. Relationships:

* One-to-Many: Course to Notification, as each course can have multiple notifications.
* One-to-Many: User (creator) to Notification, as a user can create multiple notifications.
* Many-to-Many (indirect): User to Notification via course enrollment, as multiple students can view a notification if they are enrolled in the course associated with the notification.

==Schema==
[[File:Schema2.PNG| center]]

===Associations===

'''Notification'''

* belongs_to :user - Links the notification to its creator (TA, instructor).

* belongs_to :course - Links the notification to a course.

'''User'''

* has_many :notifications - Users (instructors, TAs) can create multiple notifications.

* has_many :viewable_notifications, through: :courses - Students can view notifications for courses they are enrolled in.

'''Course'''

* has_many :notifications - Each course can have multiple notifications.

* has_many :students, through: :enrollments - Defines which students are associated with the course.

==UML Diagram==
[[File:UML notification2.PNG| center]]

''' Relationship Explanation'''

* User to Notification: A User (e.g., TA, instructor) can create multiple notifications.
* Course to Notification: Each Course can have multiple notifications associated with it.
* User (Student) to Notification (Viewer): Through Course enrollment, students can access notifications related to their courses.

==Implementation==
NotificationController Implementation: Following are the controller methods:

1. create:

* Description: This method is responsible for creating a new notification. It validates the incoming data to ensure that all required fields are present and correctly formatted. Only authorized users (instructors or TAs) can create notifications. Upon successful creation, the method associates the notification with the specified course and user (creator).
* API Endpoint: POST /notifications
* Parameters:
** subject (required): The title of the notification that briefly describes its purpose (limited to 255 characters).
** description (optional): Detailed content of the notification.
** expiration_date (optional): The date until which the notification remains valid. Defaults to no expiration.
** is_active (optional): A boolean flag indicating if the notification is active (default is true).
** course_id (required): The course associated with the notification.
* Authorization: Ensures that only users with roles of TA or instructor can create a notification.
* Response:
** Success: Returns the newly created notification with a 201 status.
** Error: Returns validation errors (e.g., missing fields, invalid data) with a 422 status.

2. index:

* Description: The index method retrieves a list of notifications based on specific filters, such as active status, unread status, or course association. This endpoint ensures that students only see notifications related to the courses they are enrolled in. It supports querying with multiple optional parameters for flexibility.
* API Endpoint: GET /notifications
* Parameters: Query parameters (optional):
** is_active: Filter notifications by their active status.
** is_unread: Retrieve only unread notifications for the current user.
** course_id: Fetch notifications specific to a course.
* Authorization: Students can only access notifications for courses they are enrolled in. Instructors and TAs can view all notifications they have created.
* Response:
** Success: Returns an array of filtered notifications with a 200 status.
** Error: Returns a 403 status if unauthorized.

3. show:

* Description: This method retrieves the details of a specific notification identified by its unique ID. It ensures that the current user is authorized to view the notification (e.g., enrolled in the course or the creator of the notification).
* API Endpoint: GET /notifications/:id
* Parameters:
** id: The unique identifier of the notification to be retrieved.
* Authorization: Students can view notifications for courses they are enrolled in. Instructors and TAs can view notifications they have created.
* Response:
** Success: Returns the notification details with a 200 status.
** Error: Returns a 404 status if the notification is not found or the user is unauthorized.

4. update:

* Description: This method allows the creator of a notification (TA or instructor) to update its details. It validates the incoming data and ensures that the user is authorized to make changes.
* API Endpoint: PUT /notifications/:id
* Parameters: Fields that can be updated include subject, description, expiration_date, and is_active.
* Authorization: Only the creator of the notification can update it.
* Response:
** Success: Returns the updated notification with a 200 status.
** Error: Returns a 403 status if the user does not have the required permissions.

5. destroy:

* Description: This method deletes a specific notification. Only the user who created the notification can perform this action. The method ensures that no unauthorized users can delete notifications.
* API Endpoint: DELETE /notifications/:id
* Parameters:
** id: The unique identifier of the notification to be deleted.
* Authorization: Only the creator of the notification can delete it.
* Response:
** Success: Returns a 204 status with no content upon successful deletion.
** Error: Returns a 403 status if the user is unauthorized.

6. toggle_notification_visibility:

* Description: This method toggles the is_active status of a notification. For example, a TA or instructor can deactivate a notification that is no longer relevant. The method ensures that only the creator of the notification can perform this action.
* API Endpoint: PATCH /notifications/:id/toggle
* Parameters:
** id: The unique identifier of the notification to be toggled.
* Authorization: Only the creator of the notification can toggle its visibility.
* Response:
** Success: Returns the updated notification status with a 200 status.
** Error: Returns a 403 status if unauthorized.

Model Implementation:

1. Notification model:

* Description: The Notification model represents a single notification. It includes all attributes, validations, and associations necessary for managing notifications.
* Attributes:
** subject: The title of the notification (required, max length: 255).
** description: The detailed content of the notification.
** expiration_date: The date when the notification should expire (validated to be in the future).
** is_active: Indicates whether the notification is active (default: true).
** is_unread: Marks if a notification is unread (default: true).
** course_id: Links the notification to a course.
** user_id: Links the notification to its creator.
* Associations:
** belongs_to :course
** belongs_to :user
* Validations:
** Ensures the presence of subject, course_id, and user_id.
** Validates expiration_date to ensure it is not in the past.
* Scopes:
** active: Filters notifications that are active.
** unread: Filters unread notifications for a user.

2. User Model:

* Associations:
** has_many :notifications (creator role).
** has_many :viewable_notifications, through: :courses (student role).

3. Course Model:

* Associations:
** has_many :notifications.
** has_many :students, through: :enrollments.

== Endpoints for Notification Management ==

Endpoints for Creating, Reading, Updating, and Deleting (CRUD) Notifications

1. POST /notifications - Create a new notification. The create method in the NotificationController implementation aligns with this endpoint, allowing authorized users to create notifications for specific courses.

2. GET /notifications - Get a list of notifications (with optional filters, such as is_active or is_unread). The index method aligns with this endpoint, allowing filtered retrieval of notifications.

3. GET /notifications/:id - View details of a specific notification. The show method aligns with this endpoint, retrieving specific notification details.

4. PUT /notifications/:id - Update a specific notification. The update method allows modification of existing notifications, respecting role-based access.

5. DELETE /notifications/:id - Delete a specific notification. The destroy method aligns with this endpoint, enabling notification deletion by authorized users.

6. PATCH /notifications/:id/toggle - Toggle active state of a notification. The toggle_notification_visibility method handles this functionality, toggling the is_active flag.

=Design Pattern=

1. Strategy Pattern

* Use Case:
** Dynamically applying different filtering criteria for notifications (e.g., active notifications, unread notifications, notifications for a specific course).
** This modularizes the filtering logic, making it easier to extend or change in the future.
* Explanation:
** The Strategy Pattern separates filtering logic into individual strategy classes, making it easy to add new filters without modifying existing code.
** It also enhances the maintainability and testability of the system.

2. Decorator Pattern

* Use Case:
** Dynamically modifying the presentation of notifications based on user roles or other conditions.
** For example, students might see a simplified view of notifications, while instructors see a detailed view.
* Explanation:
** The Decorator Pattern adds additional functionality (like role-based formatting) without modifying the original Notification model.
** It keeps the model clean and focused on core functionality.

3. Singleton Pattern

* Use Case:
** Managing a global notification scheduler or manager, ensuring that only one instance exists.
* Explanation:
** The Singleton Pattern ensures that there is only one centralized manager for handling notification-related tasks, such as scheduling or batch operations.

4. Chain of Responsibility Pattern

* Use Case:
** Modularizing the validation logic for notifications (e.g., checking permissions, validating expiration dates, ensuring uniqueness).
* Explanation:
** The Chain of Responsibility Pattern allows you to break down validation or processing logic into discrete steps, improving code readability and maintainability.

Following are the some of the SOLID principles with how they will be applied to the back-end development:
* Single Responsibility : Controllers handle HTTP requests, models handle data, and service objects handle business logic (e.g., sending notifications).
* Open/Closed : Extend functionality (e.g., new notification types or filters) by adding new classes or methods without modifying existing code.
* Interface Segregation : Create small, role-specific interfaces (e.g., policies for TAs, students, instructors) and separate service objects for different types of notifications.

=Testing=

1. Model Tests:

* Validate presence and format of subject and description.
* Test is_active and is_unread default values.

2. Controller Tests:

* Ensure proper creation, update, and deletion of notifications.
* Test that only authorized users can manage notifications.

3. Integration Tests:

* Test access control to verify that only eligible users can view or manage notifications based on role and course association.

=Team=
Mentor Jay Patel : jhpatel9@ncsu.edu

* '''Vaibhavi Shetty:''' vshetty2@ncsu.edu
* '''Soubarnica Suresh''' ssomang@ncsu.edu
* '''Aditi Killedar''' akilled@ncsu.edu

=Relevant Links=
* '''Github Repository:''' [https://github.com/SoubarnicaSuresh/reimplementation-back-end reimplementation back-end]

CSC/ECE 517 Fall 2024 - E2483. Reimplement Notification Controller and Model

2024-11-13T02:37:52Z

Ssomang:

__TOC__

==Objective==
To create a Notification model in the backend to handle notifications for the Expertiza system. This model will manage notifications for different courses and be accessible to students and instructors based on their association with a course. Notifications can have attributes such as subject, description, expiration date, and status (active/inactive).

==Requirements==
* Create a new Notification model with appropriate attributes and relationships:
* Define associations with User and Course models
* Implement scopes for filtering notifications based on roles
* Add validation rules for notification data
* Include timestamp fields for proper notification tracking
* Develop a NotificationsController with:
* Standard CRUD operations (create, read, update, delete)
* Role-based access control logic
* Course enrollment verification
* Proper error handling and response formatting
* RESTful API endpoints
* Implement authorization logic: Add policies to ensure students only see relevant notifications
* Write comprehensive test cases:
* Unit tests for the Notification model
* Controller tests covering all CRUD operations
* Integration tests for role-based access
* Test cases for error scenarios and edge cases

==Design Goals==
Implement the Notification backend: Implement the Notification in Ruby on Rails.

1. Model Creation:

Create a Notification model with the following key attributes:
* id: Primary key (auto-generated).
* subject: Brief title of the notification.
* description: Detailed message of the notification.
* expiration_date: The date when the notification should expire.
* is_active: Boolean flag to mark if the notification is active or inactive.
* is_unread: Boolean to mark if a notification is unread (default to true for new notifications).

2. Associations:

* Define associations between Notification, User, and Course models.
* User Association: Each notification should have a creator (e.g., a teaching assistant or instructor).
* Course Association: Each notification should be linked to a course, and the enrolled students should be able to view relevant notifications.

3. Relationships:

* One-to-Many: Course to Notification, as each course can have multiple notifications.
* One-to-Many: User (creator) to Notification, as a user can create multiple notifications.
* Many-to-Many (indirect): User to Notification via course enrollment, as multiple students can view a notification if they are enrolled in the course associated with the notification.

==Schema==
[[File:Schema2.PNG| center]]

===Associations===

'''Notification'''

* belongs_to :user - Links the notification to its creator (TA, instructor).

* belongs_to :course - Links the notification to a course.

'''User'''

* has_many :notifications - Users (instructors, TAs) can create multiple notifications.

* has_many :viewable_notifications, through: :courses - Students can view notifications for courses they are enrolled in.

'''Course'''

* has_many :notifications - Each course can have multiple notifications.

* has_many :students, through: :enrollments - Defines which students are associated with the course.

==UML Diagram==
[[File:UML notification2.PNG| center]]

''' Relationship Explanation'''

* User to Notification: A User (e.g., TA, instructor) can create multiple notifications.
* Course to Notification: Each Course can have multiple notifications associated with it.
* User (Student) to Notification (Viewer): Through Course enrollment, students can access notifications related to their courses.

==Implementation==
NotificationController Implementation: Following are the controller methods:

1. create:

* Description: This method is responsible for creating a new notification. It validates the incoming data to ensure that all required fields are present and correctly formatted. Only authorized users (instructors or TAs) can create notifications. Upon successful creation, the method associates the notification with the specified course and user (creator).
* API Endpoint: POST /notifications
* Parameters:
** subject (required): The title of the notification that briefly describes its purpose (limited to 255 characters).
** description (optional): Detailed content of the notification.
** expiration_date (optional): The date until which the notification remains valid. Defaults to no expiration.
** is_active (optional): A boolean flag indicating if the notification is active (default is true).
** course_id (required): The course associated with the notification.
* Authorization: Ensures that only users with roles of TA or instructor can create a notification.
* Response:
** Success: Returns the newly created notification with a 201 status.
** Error: Returns validation errors (e.g., missing fields, invalid data) with a 422 status.

2. index:

* Description: The index method retrieves a list of notifications based on specific filters, such as active status, unread status, or course association. This endpoint ensures that students only see notifications related to the courses they are enrolled in. It supports querying with multiple optional parameters for flexibility.
* API Endpoint: GET /notifications
* Parameters: Query parameters (optional):
** is_active: Filter notifications by their active status.
** is_unread: Retrieve only unread notifications for the current user.
** course_id: Fetch notifications specific to a course.
* Authorization: Students can only access notifications for courses they are enrolled in. Instructors and TAs can view all notifications they have created.
* Response:
** Success: Returns an array of filtered notifications with a 200 status.
** Error: Returns a 403 status if unauthorized.

3. show:

* Description: This method retrieves the details of a specific notification identified by its unique ID. It ensures that the current user is authorized to view the notification (e.g., enrolled in the course or the creator of the notification).
* API Endpoint: GET /notifications/:id
* Parameters:
** id: The unique identifier of the notification to be retrieved.
* Authorization: Students can view notifications for courses they are enrolled in. Instructors and TAs can view notifications they have created.
* Response:
** Success: Returns the notification details with a 200 status.
** Error: Returns a 404 status if the notification is not found or the user is unauthorized.

4. update:

* Description: This method allows the creator of a notification (TA or instructor) to update its details. It validates the incoming data and ensures that the user is authorized to make changes.
* API Endpoint: PUT /notifications/:id
* Parameters: Fields that can be updated include subject, description, expiration_date, and is_active.
* Authorization: Only the creator of the notification can update it.
* Response:
** Success: Returns the updated notification with a 200 status.
** Error: Returns a 403 status if the user does not have the required permissions.

5. destroy:

* Description: This method deletes a specific notification. Only the user who created the notification can perform this action. The method ensures that no unauthorized users can delete notifications.
* API Endpoint: DELETE /notifications/:id
* Parameters:
** id: The unique identifier of the notification to be deleted.
* Authorization: Only the creator of the notification can delete it.
* Response:
** Success: Returns a 204 status with no content upon successful deletion.
** Error: Returns a 403 status if the user is unauthorized.

6. toggle_notification_visibility:

* Description: This method toggles the is_active status of a notification. For example, a TA or instructor can deactivate a notification that is no longer relevant. The method ensures that only the creator of the notification can perform this action.
* API Endpoint: PATCH /notifications/:id/toggle
* Parameters:
** id: The unique identifier of the notification to be toggled.
* Authorization: Only the creator of the notification can toggle its visibility.
* Response:
** Success: Returns the updated notification status with a 200 status.
** Error: Returns a 403 status if unauthorized.

Model Implementation:

1. Notification model:

* Description: The Notification model represents a single notification. It includes all attributes, validations, and associations necessary for managing notifications.
* Attributes:
** subject: The title of the notification (required, max length: 255).
** description: The detailed content of the notification.
** expiration_date: The date when the notification should expire (validated to be in the future).
** is_active: Indicates whether the notification is active (default: true).
** is_unread: Marks if a notification is unread (default: true).
** course_id: Links the notification to a course.
** user_id: Links the notification to its creator.
* Associations:
** belongs_to :course
** belongs_to :user
* Validations:
** Ensures the presence of subject, course_id, and user_id.
** Validates expiration_date to ensure it is not in the past.
* Scopes:
** active: Filters notifications that are active.
** unread: Filters unread notifications for a user.

2. User Model:

* Associations:
** has_many :notifications (creator role).
** has_many :viewable_notifications, through: :courses (student role).

3. Course Model:

* Associations:
** has_many :notifications.
** has_many :students, through: :enrollments.

== Endpoints for Notification Management ==

Endpoints for Creating, Reading, Updating, and Deleting (CRUD) Notifications

1. POST /notifications - Create a new notification. The create method in the NotificationController implementation aligns with this endpoint, allowing authorized users to create notifications for specific courses.

2. GET /notifications - Get a list of notifications (with optional filters, such as is_active or is_unread). The index method aligns with this endpoint, allowing filtered retrieval of notifications.

3. GET /notifications/:id - View details of a specific notification. The show method aligns with this endpoint, retrieving specific notification details.

4. PUT /notifications/:id - Update a specific notification. The update method allows modification of existing notifications, respecting role-based access.

5. DELETE /notifications/:id - Delete a specific notification. The destroy method aligns with this endpoint, enabling notification deletion by authorized users.

6. PATCH /notifications/:id/toggle - Toggle active state of a notification. The toggle_notification_visibility method handles this functionality, toggling the is_active flag.

=Design Pattern=

1. Observer Pattern

* Use Case:
** Automatically notify users (e.g., students enrolled in a course) whenever a new notification is created or updated.
** This ensures users are always informed about important updates without requiring manual intervention.
* Explanation:
** The Notification model acts as the subject, and the students (or their respective notification systems) are observers.
** When a notification is created or updated, all observers are automatically notified through an after_commit callback.
** This pattern decouples the logic for creating notifications from the logic for notifying users, making the system easier to maintain and extend.

2. Factory Pattern

* Use Case:
** Creating different types of notifications (e.g., course notifications, system notifications, global announcements) with varying attributes or behaviors.
** This centralizes the creation logic and ensures consistency in object instantiation.
* Explanation:
** The factory centralizes the creation logic, making it easy to add new notification types in the future.
** It also reduces clutter in the controller by abstracting the instantiation process.

3. Strategy Pattern

* Use Case:
** Dynamically applying different filtering criteria for notifications (e.g., active notifications, unread notifications, notifications for a specific course).
** This modularizes the filtering logic, making it easier to extend or change in the future.
* Explanation:
** The Strategy Pattern separates filtering logic into individual strategy classes, making it easy to add new filters without modifying existing code.
** It also enhances the maintainability and testability of the system.

4. Decorator Pattern

* Use Case:
** Dynamically modifying the presentation of notifications based on user roles or other conditions.
** For example, students might see a simplified view of notifications, while instructors see a detailed view.
* Explanation:
** The Decorator Pattern adds additional functionality (like role-based formatting) without modifying the original Notification model.
** It keeps the model clean and focused on core functionality.

5. Command Pattern

* Use Case:
** Encapsulating the logic for sending notifications (e.g., emails, in-app alerts) into discrete, reusable objects.
** Useful for task queuing or asynchronous operations.
* Explanation:
** The Command Pattern encapsulates the logic for sending notifications, making it easier to queue or log these operations.
** It improves code reusability and separation of concerns.

6. Template Method Pattern

* Use Case:
** Defining a common process for creating notifications while allowing specific steps to be overridden for different types of notifications (e.g., course notifications vs. global announcements).
* Explanation:
** The Template Method Pattern enforces a consistent process for creating notifications while allowing flexibility for specific steps.
** This ensures uniformity across different notification types.

7. Singleton Pattern

* Use Case:
** Managing a global notification scheduler or manager, ensuring that only one instance exists.
* Explanation:
** The Singleton Pattern ensures that there is only one centralized manager for handling notification-related tasks, such as scheduling or batch operations.

8. Chain of Responsibility Pattern

* Use Case:
** Modularizing the validation logic for notifications (e.g., checking permissions, validating expiration dates, ensuring uniqueness).
* Explanation:
** The Chain of Responsibility Pattern allows you to break down validation or processing logic into discrete steps, improving code readability and maintainability.

=Testing=

1. Model Tests:

* Validate presence and format of subject and description.
* Test is_active and is_unread default values.

2. Controller Tests:

* Ensure proper creation, update, and deletion of notifications.
* Test that only authorized users can manage notifications.

3. Integration Tests:

* Test access control to verify that only eligible users can view or manage notifications based on role and course association.

=Team=
Mentor Jay Patel : jhpatel9@ncsu.edu

* '''Vaibhavi Shetty:''' vshetty2@ncsu.edu
* '''Soubarnica Suresh''' ssomang@ncsu.edu
* '''Aditi Killedar''' akilled@ncsu.edu

=Relevant Links=
* '''Github Repository:''' [https://github.com/SoubarnicaSuresh/reimplementation-back-end reimplementation back-end]

CSC/ECE 517 Fall 2024 - E2483. Reimplement Notification Controller and Model

2024-11-13T02:36:48Z

Ssomang:

CSC/ECE 517 Fall 2024 - E2483. Reimplement Notification Controller and Model

2024-11-13T01:16:45Z

Ssomang:

CSC/ECE 517 Fall 2024 - E2483. Reimplement Notification Controller and Model

2024-11-13T01:10:06Z

Ssomang:

__TOC__

==Objective==
To create a Notification model in the backend to handle notifications for the Expertiza system. This model will manage notifications for different courses and be accessible to students and instructors based on their association with a course. Notifications can have attributes such as subject, description, expiration date, and status (active/inactive).

==Requirements==
* Create a new Notification model with appropriate attributes and relationships:
* Define associations with User and Course models
* Implement scopes for filtering notifications based on roles
* Add validation rules for notification data
* Include timestamp fields for proper notification tracking
* Develop a NotificationsController with:
* Standard CRUD operations (create, read, update, delete)
* Role-based access control logic
* Course enrollment verification
* Proper error handling and response formatting
* RESTful API endpoints
* Implement authorization logic: Add policies to ensure students only see relevant notifications
* Write comprehensive test cases:
* Unit tests for the Notification model
* Controller tests covering all CRUD operations
* Integration tests for role-based access
* Test cases for error scenarios and edge cases

==Design Goals==
Implement the Notification backend: Implement the Notification in Ruby on Rails.

1. Model Creation:

Create a Notification model with the following key attributes:
* id: Primary key (auto-generated).
* subject: Brief title of the notification.
* description: Detailed message of the notification.
* expiration_date: The date when the notification should expire.
* is_active: Boolean flag to mark if the notification is active or inactive.
* is_unread: Boolean to mark if a notification is unread (default to true for new notifications).

2. Associations:

* Define associations between Notification, User, and Course models.
* User Association: Each notification should have a creator (e.g., a teaching assistant or instructor).
* Course Association: Each notification should be linked to a course, and the enrolled students should be able to view relevant notifications.

3. Relationships:

* One-to-Many: Course to Notification, as each course can have multiple notifications.
* One-to-Many: User (creator) to Notification, as a user can create multiple notifications.
* Many-to-Many (indirect): User to Notification via course enrollment, as multiple students can view a notification if they are enrolled in the course associated with the notification.

==Schema==
[[File:Schema2.PNG| center]]

===Associations===

'''Notification'''

* belongs_to :user - Links the notification to its creator (TA, instructor).

* belongs_to :course - Links the notification to a course.

'''User'''

* has_many :notifications - Users (instructors, TAs) can create multiple notifications.

* has_many :viewable_notifications, through: :courses - Students can view notifications for courses they are enrolled in.

'''Course'''

* has_many :notifications - Each course can have multiple notifications.

* has_many :students, through: :enrollments - Defines which students are associated with the course.

==UML Diagram==
[[File:UML notification2.PNG| center]]

''' Relationship Explanation'''

* User to Notification: A User (e.g., TA, instructor) can create multiple notifications.
* Course to Notification: Each Course can have multiple notifications associated with it.
* User (Student) to Notification (Viewer): Through Course enrollment, students can access notifications related to their courses.

==Implementation==
NotificationController Implementation: Following are the controller methods:

1. create:

* Description: This method is responsible for creating a new notification. It validates the incoming data to ensure that all required fields are present and correctly formatted. Only authorized users (instructors or TAs) can create notifications. Upon successful creation, the method associates the notification with the specified course and user (creator).
* API Endpoint: POST /notifications
* Parameters:
** subject (required): The title of the notification that briefly describes its purpose (limited to 255 characters).
** description (optional): Detailed content of the notification.
** expiration_date (optional): The date until which the notification remains valid. Defaults to no expiration.
** is_active (optional): A boolean flag indicating if the notification is active (default is true).
** course_id (required): The course associated with the notification.
* Authorization: Ensures that only users with roles of TA or instructor can create a notification.
* Response:
** Success: Returns the newly created notification with a 201 status.
** Error: Returns validation errors (e.g., missing fields, invalid data) with a 422 status.

2. index:

* Description: The index method retrieves a list of notifications based on specific filters, such as active status, unread status, or course association. This endpoint ensures that students only see notifications related to the courses they are enrolled in. It supports querying with multiple optional parameters for flexibility.
* API Endpoint: GET /notifications
* Parameters: Query parameters (optional):
** is_active: Filter notifications by their active status.
** is_unread: Retrieve only unread notifications for the current user.
** course_id: Fetch notifications specific to a course.
* Authorization: Students can only access notifications for courses they are enrolled in. Instructors and TAs can view all notifications they have created.
* Response:
** Success: Returns an array of filtered notifications with a 200 status.
** Error: Returns a 403 status if unauthorized.

3. show:

* Description: This method retrieves the details of a specific notification identified by its unique ID. It ensures that the current user is authorized to view the notification (e.g., enrolled in the course or the creator of the notification).
* API Endpoint: GET /notifications/:id
* Parameters:
** id: The unique identifier of the notification to be retrieved.
* Authorization: Students can view notifications for courses they are enrolled in. Instructors and TAs can view notifications they have created.
* Response:
** Success: Returns the notification details with a 200 status.
** Error: Returns a 404 status if the notification is not found or the user is unauthorized.

4. update:

* Description: This method allows the creator of a notification (TA or instructor) to update its details. It validates the incoming data and ensures that the user is authorized to make changes.
* API Endpoint: PUT /notifications/:id
* Parameters: Fields that can be updated include subject, description, expiration_date, and is_active.
* Authorization: Only the creator of the notification can update it.
* Response:
** Success: Returns the updated notification with a 200 status.
** Error: Returns a 403 status if the user does not have the required permissions.

5. destroy:

* Description: This method deletes a specific notification. Only the user who created the notification can perform this action. The method ensures that no unauthorized users can delete notifications.
* API Endpoint: DELETE /notifications/:id
* Parameters:
** id: The unique identifier of the notification to be deleted.
* Authorization: Only the creator of the notification can delete it.
* Response:
** Success: Returns a 204 status with no content upon successful deletion.
** Error: Returns a 403 status if the user is unauthorized.

6. toggle_notification_visibility:

* Description: This method toggles the is_active status of a notification. For example, a TA or instructor can deactivate a notification that is no longer relevant. The method ensures that only the creator of the notification can perform this action.
* API Endpoint: PATCH /notifications/:id/toggle
* Parameters:
** id: The unique identifier of the notification to be toggled.
* Authorization: Only the creator of the notification can toggle its visibility.
* Response:
** Success: Returns the updated notification status with a 200 status.
** Error: Returns a 403 status if unauthorized.

Model Implementation:

1. Notification model:

* Description: The Notification model represents a single notification. It includes all attributes, validations, and associations necessary for managing notifications.
* Attributes:
** subject: The title of the notification (required, max length: 255).
** description: The detailed content of the notification.
** expiration_date: The date when the notification should expire (validated to be in the future).
** is_active: Indicates whether the notification is active (default: true).
** is_unread: Marks if a notification is unread (default: true).
** course_id: Links the notification to a course.
** user_id: Links the notification to its creator.
* Associations:
** belongs_to :course
** belongs_to :user
* Validations:
** Ensures the presence of subject, course_id, and user_id.
** Validates expiration_date to ensure it is not in the past.
* Scopes:
** active: Filters notifications that are active.
** unread: Filters unread notifications for a user.

2. User Model:

* Associations:
** has_many :notifications (creator role).
** has_many :viewable_notifications, through: :courses (student role).

3. Course Model:

* Associations:
** has_many :notifications.
** has_many :students, through: :enrollments.

== Endpoints for Notification Management ==

Endpoints for Creating, Reading, Updating, and Deleting (CRUD) Notifications

1. POST /notifications - Create a new notification. The create method in the NotificationController implementation aligns with this endpoint, allowing authorized users to create notifications for specific courses.

2. GET /notifications - Get a list of notifications (with optional filters, such as is_active or is_unread). The index method aligns with this endpoint, allowing filtered retrieval of notifications.

3. GET /notifications/:id - View details of a specific notification. The show method aligns with this endpoint, retrieving specific notification details.

4. PUT /notifications/:id - Update a specific notification. The update method allows modification of existing notifications, respecting role-based access.

5. DELETE /notifications/:id - Delete a specific notification. The destroy method aligns with this endpoint, enabling notification deletion by authorized users.

6. PATCH /notifications/:id/toggle - Toggle active state of a notification. The toggle_notification_visibility method handles this functionality, toggling the is_active flag.

=Design Pattern=

1. Observer Pattern

* Use Case:
** Automatically notify users (e.g., students enrolled in a course) whenever a new notification is created or updated.
** This ensures users are always informed about important updates without requiring manual intervention.
* Implementation:
<code>
class Notification < ApplicationRecord
after_commit :notify_users, on: [:create]
private
def notify_users
course.students.each do |student|
NotificationMailer.new_notification(student, self).deliver_later
end
end
end
</code>
* Explanation:
** The Notification model acts as the subject, and the students (or their respective notification systems) are observers.
** When a notification is created or updated, all observers are automatically notified through an after_commit callback.
** This pattern decouples the logic for creating notifications from the logic for notifying users, making the system easier to maintain and extend.

2. Factory Pattern

* Use Case:
** Creating different types of notifications (e.g., course notifications, system notifications, global announcements) with varying attributes or behaviors.
** This centralizes the creation logic and ensures consistency in object instantiation.
* Implementation:
<code>
class NotificationFactory
def self.create_notification(type, attributes)
case type
when 'course'
CourseNotification.new(attributes)
when 'system'
SystemNotification.new(attributes)
else
raise ArgumentError, "Unknown notification type: #{type}"
end
end
end

# Usage Example
notification = NotificationFactory.create_notification('course', {
subject: 'New Assignment',
description: 'Assignment 3 is due next week.',
course_id: 1,
user_id: current_user.id
})
notification.save
</code>
* Explanation:
** The factory centralizes the creation logic, making it easy to add new notification types in the future.
** It also reduces clutter in the controller by abstracting the instantiation process.

3. Strategy Pattern

* Use Case:
** Dynamically applying different filtering criteria for notifications (e.g., active notifications, unread notifications, notifications for a specific course).
** This modularizes the filtering logic, making it easier to extend or change in the future.
* Implementation:
<code>
class ActiveNotificationStrategy
def filter(notifications)
notifications.where(is_active: true)
end
end

class UnreadNotificationStrategy
def filter(notifications, user)
notifications.joins(:user_notifications).where(user_notifications: { is_unread: true, user_id: user.id })
end
end

class NotificationFilter
def initialize(strategy)
@strategy = strategy
end

def filter(notifications, user = nil)
@strategy.filter(notifications, user)
end
end

# Usage in Controller
def index
strategy = case params[:filter]
when 'active'
ActiveNotificationStrategy.new
when 'unread'
UnreadNotificationStrategy.new
else
ActiveNotificationStrategy.new
end

@notifications = NotificationFilter.new(strategy).filter(Notification.all, current_user)
end
</code>
* Explanation:
** The Strategy Pattern separates filtering logic into individual strategy classes, making it easy to add new filters without modifying existing code.
** It also enhances the maintainability and testability of the system.

4. Decorator Pattern

* Use Case:
** Dynamically modifying the presentation of notifications based on user roles or other conditions.
** For example, students might see a simplified view of notifications, while instructors see a detailed view.
* Implementation:
<code>
class NotificationDecorator < SimpleDelegator
def formatted_subject
if user.role == 'student'
"[Student] #{subject}"
else
"[Instructor] #{subject} (Created by #{creator.name})"
end
end

def readable_description
description.truncate(100)
end
end

# Usage
@notification = NotificationDecorator.new(notification)
</code>
* Explanation:
** The Decorator Pattern adds additional functionality (like role-based formatting) without modifying the original Notification model.
** It keeps the model clean and focused on core functionality.

5. Command Pattern

* Use Case:
** Encapsulating the logic for sending notifications (e.g., emails, in-app alerts) into discrete, reusable objects.
** Useful for task queuing or asynchronous operations.
* Implementation:
<code>
class SendNotificationCommand
def initialize(user, notification)
@user = user
@notification = notification
end

def execute
NotificationMailer.new_notification(@user, @notification).deliver_later
end
end

# Usage
course.students.each do |student|
SendNotificationCommand.new(student, notification).execute
end
</code>
* Explanation:
** The Command Pattern encapsulates the logic for sending notifications, making it easier to queue or log these operations.
** It improves code reusability and separation of concerns.

6. Template Method Pattern

* Use Case:
** Defining a common process for creating notifications while allowing specific steps to be overridden for different types of notifications (e.g., course notifications vs. global announcements).
* Implementation:
<code>
class NotificationBase
def create_notification
validate_data
save_notification
send_notification
end

private

def validate_data
raise NotImplementedError, 'Subclasses must define validate_data'
end

def save_notification
Notification.create(subject: @subject, description: @description)
end

def send_notification
raise NotImplementedError, 'Subclasses must define send_notification'
end
end

class CourseNotification < NotificationBase
def validate_data
# Validation logic specific to course notifications
end

def send_notification
# Logic to notify enrolled students
end
end
</code>
* Explanation:
** The Template Method Pattern enforces a consistent process for creating notifications while allowing flexibility for specific steps.
** This ensures uniformity across different notification types.

7. Singleton Pattern

* Use Case:
** Managing a global notification scheduler or manager, ensuring that only one instance exists.
* Implementation:
<code>
class NotificationScheduler
include Singleton

def schedule_notifications
# Logic to schedule notifications
end
end

# Usage
NotificationScheduler.instance.schedule_notifications
</code>
* Explanation:
** The Singleton Pattern ensures that there is only one centralized manager for handling notification-related tasks, such as scheduling or batch operations.

8. Chain of Responsibility Pattern

* Use Case:
** Modularizing the validation logic for notifications (e.g., checking permissions, validating expiration dates, ensuring uniqueness).
* Implementation:
<code>
class BaseHandler
def set_next(handler)
@next_handler = handler
end

def handle(request)
return @next_handler.handle(request) if @next_handler
end
end

class RoleValidationHandler < BaseHandler
def handle(request)
raise 'Unauthorized' unless request.user.role == 'instructor'
super(request)
end
end

class ExpiryValidationHandler < BaseHandler
def handle(request)
raise 'Invalid expiration date' if request.expiration_date < Date.today
super(request)
end
end

# Usage
role_handler = RoleValidationHandler.new
expiry_handler = ExpiryValidationHandler.new

role_handler.set_next(expiry_handler)
role_handler.handle(request)
</code>
* Explanation:
** The Chain of Responsibility Pattern allows you to break down validation or processing logic into discrete steps, improving code readability and maintainability.

=Testing=

1. Model Tests:

* Validate presence and format of subject and description.
* Test is_active and is_unread default values.

2. Controller Tests:

* Ensure proper creation, update, and deletion of notifications.
* Test that only authorized users can manage notifications.

3. Integration Tests:

* Test access control to verify that only eligible users can view or manage notifications based on role and course association.

=Team=
Mentor Jay Patel : jhpatel9@ncsu.edu

* '''Vaibhavi Shetty:''' vshetty2@ncsu.edu
* '''Soubarnica Suresh''' ssomang@ncsu.edu
* '''Aditi Killedar''' akilled@ncsu.edu

=Relevant Links=
* '''Github Repository:'''
* '''Pull Request:'''

CSC/ECE 517 Fall 2024 - E2483. Reimplement Notification Controller and Model

2024-11-13T00:23:15Z

Ssomang:

CSC/ECE 517 Fall 2024 - E2483. Reimplement Notification Controller and Model

2024-11-13T00:18:17Z

Ssomang:

CSC/ECE 517 Fall 2024 - E2465. UI for Institutions and Notification

2024-10-30T02:51:50Z

Ssomang:

__TOC__

=About Expertiza=

[http://expertiza.ncsu.edu/ Expertiza], an open-source project built on Ruby on Rails, serves as a versatile learning management platform, enabling instructors to design and customize assignments. It facilitates collaborative learning by allowing students to select topics, form teams, and participate in peer reviews. Recently, the platform has expanded to incorporate modern frontend technologies, with components being refactored to use React.js and Typescript. This upgrade enhances the user experience, making the interface more interactive and responsive while supporting submissions in multiple formats, including URLs and wiki pages, for seamless review and evaluation.

=Issues with previous Functionality=
* The prior implementation effectively created user interfaces for managing roles and institutions but missed certain critical specifications.
* The project was not merged due to unnecessary dynamic role creation; only administrators required the ability to add roles, so this feature was removed to simplify the design.
* The institution management interface lacked proper authorization, allowing all users access to manage institutions, which conflicted with intended role-based permissions.

=Design Goals=
* Modernize the Frontend: Re-implement the existing Institutions UI from Ruby on Rails to TypeScript and ReactJS for improved modularity, performance, and maintainability.

* Authorization-Optimized UIs: Ensure role-based access by allowing only designated roles (e.g., TAs, Instructors) to manage specific functionalities in Institutions and Notifications.

* Enhanced Notifications Feature: Introduce a robust notification management system that enables course-specific notifications creation for higher roles and displays relevant notifications to enrolled students.

* Toggle and Filter Options: Implement a toggle for notifications to control active/inactive status and filter notifications for students to display only active, course-relevant alerts.

=Implementation=

=== Enhanced the Manage Institutions page UI ===

Improved the layout and styling of the Manage Institutions page to provide a more user-friendly interface. Adjusted table centering, optimized spacing, and updated visual elements for better alignment and readability.
[[File:Manage institutions.PNG|center|800px]]

===Added authorization for Institutions [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/0eb2a19b2aa2454f4e5e51b3a02afd28ec79e63c commit]===

Implemented role-based access control to ensure only users with Instructor or higher roles can manage institutions, aligning permissions with user roles and preventing unauthorized access.
[[File: Authentication for institution.PNG|center|800px]]

===Added Manage Notifications Page [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/de6b0d635cc1a0446928dbe7c838be3ad913f73d commit]===

Developed a dedicated page where authorized users, such as TAs and Instructors, can create, edit, and delete course-specific notifications to streamline communication and course updates.
[[File:Manage notifications.PNG|center|800px]]
Following pop-up window appears on clicking create button. the Close/ Create Notification button will redirect to the Manage Notifications page.
[[File:Manage notifications - create.png|center|800px]]
Following pop-up window appears on clicking edit button for an existing notification. the Close/ Update Notification button will redirect to the Manage Notifications page.
[[File:Manage notifications - update.png|center|800px]]
Following pop-up window appears on clicking delete button. the Delete button will redirect to the Manage Notifications page and dispatch an alert message on top of the page that the notification was deleted successfully.
[[File:Manage notifications - delete.png|center|800px]]

===Added My Notifications Page [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/c998ced0962c1d786d5e137c638f9cf051488e20 commit]===

Created a page for students to view relevant, active notifications for courses they are enrolled in, ensuring they receive timely updates on assignments, exams, and other course events.
[[File:My notifications.PNG|center|800px]]

===Added Toggle Notification Feature [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/d341cdfea89b85a24fb5c9be4340981b46bccba5 commit]===

Implemented a toggle option for authorized users to activate or deactivate notifications, allowing control over the visibility of notifications for students based on course requirements.
[[File:Toggle notifications.PNG|center|300px]]

===Added Notification Badge [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/a66f55a3907c6bf969a2b1751624cf81ab353583 commit]===

Introduced a notification badge on the "My Notifications" menu item, displaying the count of new or unread notifications to keep users informed of recent updates at a glance.
[[File:Notification badge.PNG|center|600px]]

===Added Alert on Home Page===

Implemented an alert on the home page to notify users of any unread notifications upon login, ensuring important updates are immediately visible.
[[File:Notification Alert.PNG|center|900px]]

=Testing=
Added mock data for verifying the pages are rendered as expected. There is currently no backend implemented, so the tests does not involve calling relevant API endpoints; this will be considered as future work.
[[File:mock data.png|center|800px]]
Following is the video demonstrating the UI workflows. Since this is a UI project, the functionality is tested manually.
* '''Test Video Link:'''

=Team=
Mentor Jay Patel : jhpatel9@ncsu.edu

* '''Vaibhavi Shetty:''' vshetty2@ncsu.edu
* '''Soubarnica Suresh''' ssomang@ncsu.edu

=Relevant Links=
* '''Github Repository:''' https://github.com/SoubarnicaSuresh/reimplementation-front-end
* '''Pull Request:''' https://github.com/expertiza/reimplementation-front-end/pull/67

CSC/ECE 517 Fall 2024 - E2465. UI for Institutions and Notification

2024-10-30T02:49:34Z

Ssomang:

__TOC__

=About Expertiza=

[http://expertiza.ncsu.edu/ Expertiza], an open-source project built on Ruby on Rails, serves as a versatile learning management platform, enabling instructors to design and customize assignments. It facilitates collaborative learning by allowing students to select topics, form teams, and participate in peer reviews. Recently, the platform has expanded to incorporate modern frontend technologies, with components being refactored to use React.js and Typescript. This upgrade enhances the user experience, making the interface more interactive and responsive while supporting submissions in multiple formats, including URLs and wiki pages, for seamless review and evaluation.

=Issues with previous Functionality=
* The prior implementation effectively created user interfaces for managing roles and institutions but missed certain critical specifications.
* The project was not merged due to unnecessary dynamic role creation; only administrators required the ability to add roles, so this feature was removed to simplify the design.
* The institution management interface lacked proper authorization, allowing all users access to manage institutions, which conflicted with intended role-based permissions.

=Design Goals=
* Modernize the Frontend: Re-implement the existing Institutions UI from Ruby on Rails to TypeScript and ReactJS for improved modularity, performance, and maintainability.

* Authorization-Optimized UIs: Ensure role-based access by allowing only designated roles (e.g., TAs, Instructors) to manage specific functionalities in Institutions and Notifications.

* Enhanced Notifications Feature: Introduce a robust notification management system that enables course-specific notifications creation for higher roles and displays relevant notifications to enrolled students.

* Toggle and Filter Options: Implement a toggle for notifications to control active/inactive status and filter notifications for students to display only active, course-relevant alerts.

=Implementation=

=== Enhanced the Manage Institutions page UI ===

Improved the layout and styling of the Manage Institutions page to provide a more user-friendly interface. Adjusted table centering, optimized spacing, and updated visual elements for better alignment and readability.
[[File:Manage institutions.PNG|center|800px]]

===Added authorization for Institutions [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/0eb2a19b2aa2454f4e5e51b3a02afd28ec79e63c commit]===

Implemented role-based access control to ensure only users with Instructor or higher roles can manage institutions, aligning permissions with user roles and preventing unauthorized access.
[[File: Authentication for institution.PNG|center|800px]]

===Added Manage Notifications Page [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/de6b0d635cc1a0446928dbe7c838be3ad913f73d commit]===

Developed a dedicated page where authorized users, such as TAs and Instructors, can create, edit, and delete course-specific notifications to streamline communication and course updates.
[[File:Manage notifications.PNG|center|800px]]
Following pop-up window appears on clicking create button. the Close/ Create Notification button will redirect to the Manage Notifications page.
[[File:Manage notifications - create.png|center|800px]]
Following pop-up window appears on clicking edit button for an existing notification. the Close/ Update Notification button will redirect to the Manage Notifications page.
[[File:Manage notifications - update.png|center|800px]]
Following pop-up window appears on clicking delete button. the Delete button will redirect to the Manage Notifications page and dispatch an alert message on top of the page that the notification was deleted successfully.
[[File:Manage notifications - delete.png|center|800px]]

===Added My Notifications Page [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/c998ced0962c1d786d5e137c638f9cf051488e20 commit]===

Created a page for students to view relevant, active notifications for courses they are enrolled in, ensuring they receive timely updates on assignments, exams, and other course events.
[[File:My notifications.PNG|center|800px]]

===Added Toggle Notification Feature [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/d341cdfea89b85a24fb5c9be4340981b46bccba5 commit]===

Implemented a toggle option for authorized users to activate or deactivate notifications, allowing control over the visibility of notifications for students based on course requirements.
[[File:Toggle notifications.PNG|center|300px]]

===Added Notification Badge [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/a66f55a3907c6bf969a2b1751624cf81ab353583 commit]===

Introduced a notification badge on the "My Notifications" menu item, displaying the count of new or unread notifications to keep users informed of recent updates at a glance.
[[File:Notification badge.PNG|center|600px]]

===Added Alert on Home Page===

Implemented an alert on the home page to notify users of any unread notifications upon login, ensuring important updates are immediately visible.
[[File:Notification Alert.PNG|center|900px]]

=Testing=
Added mock data for verifying the pages are rendered as expected. There is currently no backend implemented, so the tests does not involve calling relevant API endpoints; this will be considered as future work.
[[File:mock data.png|center|800px]]
Below is the video demonstrating the UI workflows:
* '''Test Video Link:'''

=Team=
Mentor Jay Patel : jhpatel9@ncsu.edu

* '''Vaibhavi Shetty:''' vshetty2@ncsu.edu
* '''Soubarnica Suresh''' ssomang@ncsu.edu

=Relevant Links=
* '''Github Repository:''' https://github.com/SoubarnicaSuresh/reimplementation-front-end
* '''Pull Request:''' https://github.com/expertiza/reimplementation-front-end/pull/67

CSC/ECE 517 Fall 2024 - E2465. UI for Institutions and Notification

2024-10-30T02:48:42Z

Ssomang:

__TOC__

=About Expertiza=

[http://expertiza.ncsu.edu/ Expertiza], an open-source project built on Ruby on Rails, serves as a versatile learning management platform, enabling instructors to design and customize assignments. It facilitates collaborative learning by allowing students to select topics, form teams, and participate in peer reviews. Recently, the platform has expanded to incorporate modern frontend technologies, with components being refactored to use React.js and Typescript. This upgrade enhances the user experience, making the interface more interactive and responsive while supporting submissions in multiple formats, including URLs and wiki pages, for seamless review and evaluation.

=Issues with previous Functionality=
* The prior implementation effectively created user interfaces for managing roles and institutions but missed certain critical specifications.
* The project was not merged due to unnecessary dynamic role creation; only administrators required the ability to add roles, so this feature was removed to simplify the design.
* The institution management interface lacked proper authorization, allowing all users access to manage institutions, which conflicted with intended role-based permissions.

=Design Goals=
* Modernize the Frontend: Re-implement the existing Institutions UI from Ruby on Rails to TypeScript and ReactJS for improved modularity, performance, and maintainability.

* Authorization-Optimized UIs: Ensure role-based access by allowing only designated roles (e.g., TAs, Instructors) to manage specific functionalities in Institutions and Notifications.

* Enhanced Notifications Feature: Introduce a robust notification management system that enables course-specific notifications creation for higher roles and displays relevant notifications to enrolled students.

* Toggle and Filter Options: Implement a toggle for notifications to control active/inactive status and filter notifications for students to display only active, course-relevant alerts.

=Implementation=

=== Enhanced the Manage Institutions page UI ===

Improved the layout and styling of the Manage Institutions page to provide a more user-friendly interface. Adjusted table centering, optimized spacing, and updated visual elements for better alignment and readability.
[[File:Manage institutions.PNG|center|800px]]

===Added authorization for Institutions [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/0eb2a19b2aa2454f4e5e51b3a02afd28ec79e63c commit]===

Implemented role-based access control to ensure only users with Instructor or higher roles can manage institutions, aligning permissions with user roles and preventing unauthorized access.
[[File: Authentication for institution.PNG|center|800px]]

===Added Manage Notifications Page [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/de6b0d635cc1a0446928dbe7c838be3ad913f73d commit]===

Developed a dedicated page where authorized users, such as TAs and Instructors, can create, edit, and delete course-specific notifications to streamline communication and course updates.
[[File:Manage notifications.PNG|center|800px]]
Following pop-up window appears on clicking create button. the Close/ Create Notification button will redirect to the Manage Notifications page.
[[File:Manage notifications - create.png|center|800px]]
Following pop-up window appears on clicking edit button for an existing notification. the Close/ Update Notification button will redirect to the Manage Notifications page.
[[File:Manage notifications - update.png|center|800px]]
Following pop-up window appears on clicking delete button. the Delete button will redirect to the Manage Notifications page and dispatch an alert message on top of the page that the notification was deleted successfully.
[[File:Manage notifications - delete.png|center|800px]]

===Added My Notifications Page [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/c998ced0962c1d786d5e137c638f9cf051488e20 commit]===

Created a page for students to view relevant, active notifications for courses they are enrolled in, ensuring they receive timely updates on assignments, exams, and other course events.
[[File:My notifications.PNG|center|800px]]

===Added Toggle Notification Feature [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/d341cdfea89b85a24fb5c9be4340981b46bccba5 commit]===

Implemented a toggle option for authorized users to activate or deactivate notifications, allowing control over the visibility of notifications for students based on course requirements.
[[File:Toggle notifications.PNG|center|300px]]

===Added Notification Badge [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/a66f55a3907c6bf969a2b1751624cf81ab353583 commit]===

Introduced a notification badge on the "My Notifications" menu item, displaying the count of new or unread notifications to keep users informed of recent updates at a glance.
[[File:Notification badge.PNG|center|600px]]

===Added Alert on Home Page===

Implemented an alert on the home page to notify users of any unread notifications upon login, ensuring important updates are immediately visible.
[[File:Notification Alert.PNG|center|900px]]

=Testing=
Added mock data for verifying the pages are rendered as expected. There is currently no backend implemented, so the tests does not involve calling relevant API endpoints; this will be considered as future work.
[[File:mock data.png|center|800px]]

=Team=
Mentor Jay Patel : jhpatel9@ncsu.edu

* '''Vaibhavi Shetty:''' vshetty2@ncsu.edu
* '''Soubarnica Suresh''' ssomang@ncsu.edu

=Relevant Links=
* '''Github Repository:''' https://github.com/SoubarnicaSuresh/reimplementation-front-end
* '''Pull Request:''' https://github.com/expertiza/reimplementation-front-end/pull/67
* '''Test Video Link:'''

CSC/ECE 517 Fall 2024 - E2465. UI for Institutions and Notification

2024-10-30T02:48:04Z

Ssomang: /* Testing */

__TOC__

=About Expertiza=

[http://expertiza.ncsu.edu/ Expertiza], an open-source project built on Ruby on Rails, serves as a versatile learning management platform, enabling instructors to design and customize assignments. It facilitates collaborative learning by allowing students to select topics, form teams, and participate in peer reviews. Recently, the platform has expanded to incorporate modern frontend technologies, with components being refactored to use React.js and Typescript. This upgrade enhances the user experience, making the interface more interactive and responsive while supporting submissions in multiple formats, including URLs and wiki pages, for seamless review and evaluation.

=Issues with previous Functionality=
* The prior implementation effectively created user interfaces for managing roles and institutions but missed certain critical specifications.
* The project was not merged due to unnecessary dynamic role creation; only administrators required the ability to add roles, so this feature was removed to simplify the design.
* The institution management interface lacked proper authorization, allowing all users access to manage institutions, which conflicted with intended role-based permissions.

=Design Goals=
* Modernize the Frontend: Re-implement the existing Institutions UI from Ruby on Rails to TypeScript and ReactJS for improved modularity, performance, and maintainability.

* Authorization-Optimized UIs: Ensure role-based access by allowing only designated roles (e.g., TAs, Instructors) to manage specific functionalities in Institutions and Notifications.

* Enhanced Notifications Feature: Introduce a robust notification management system that enables course-specific notifications creation for higher roles and displays relevant notifications to enrolled students.

* Toggle and Filter Options: Implement a toggle for notifications to control active/inactive status and filter notifications for students to display only active, course-relevant alerts.

=Implementation=

=== Enhanced the Manage Institutions page UI ===

Improved the layout and styling of the Manage Institutions page to provide a more user-friendly interface. Adjusted table centering, optimized spacing, and updated visual elements for better alignment and readability.
[[File:Manage institutions.PNG|center|800px]]

===Added authorization for Institutions [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/0eb2a19b2aa2454f4e5e51b3a02afd28ec79e63c commit]===

Implemented role-based access control to ensure only users with Instructor or higher roles can manage institutions, aligning permissions with user roles and preventing unauthorized access.
[[File: Authentication for institution.PNG|center|800px]]

===Added Manage Notifications Page [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/de6b0d635cc1a0446928dbe7c838be3ad913f73d commit]===

Developed a dedicated page where authorized users, such as TAs and Instructors, can create, edit, and delete course-specific notifications to streamline communication and course updates.
[[File:Manage notifications.PNG|center|800px]]
Following pop-up window appears on clicking create button. the Close/ Create Notification button will redirect to the Manage Notifications page.
[[File:Manage notifications - create.png|center|800px]]
Following pop-up window appears on clicking edit button for an existing notification. the Close/ Update Notification button will redirect to the Manage Notifications page.
[[File:Manage notifications - update.png|center|800px]]
Following pop-up window appears on clicking delete button. the Delete button will redirect to the Manage Notifications page and dispatch an alert message on top of the page that the notification was deleted successfully.
[[File:Manage notifications - delete.png|center|800px]]

===Added My Notifications Page [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/c998ced0962c1d786d5e137c638f9cf051488e20 commit]===

Created a page for students to view relevant, active notifications for courses they are enrolled in, ensuring they receive timely updates on assignments, exams, and other course events.
[[File:My notifications.PNG|center|800px]]

===Added Toggle Notification Feature [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/d341cdfea89b85a24fb5c9be4340981b46bccba5 commit]===

Implemented a toggle option for authorized users to activate or deactivate notifications, allowing control over the visibility of notifications for students based on course requirements.
[[File:Toggle notifications.PNG|center|300px]]

===Added Notification Badge [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/a66f55a3907c6bf969a2b1751624cf81ab353583 commit]===

Introduced a notification badge on the "My Notifications" menu item, displaying the count of new or unread notifications to keep users informed of recent updates at a glance.
[[File:Notification badge.PNG|center|600px]]

===Added Alert on Home Page===

Implemented an alert on the home page to notify users of any unread notifications upon login, ensuring important updates are immediately visible.
[[File:Notification Alert.PNG|center|900px]]

=Testing=
Added mock data for verifying the pages are rendered as expected. There is currently no backend implemented, so the tests does not involve calling relevant API endpoints; this will be considered as future work.
[[File:mock data.png|center|800px]]

Mentor Jay Patel : jhpatel9@ncsu.edu

* '''Vaibhavi Shetty:''' vshetty2@ncsu.edu
* '''Soubarnica Suresh''' ssomang@ncsu.edu

=Relevant Links=
* '''Github Repository:''' https://github.com/SoubarnicaSuresh/reimplementation-front-end
* '''Pull Request:''' https://github.com/expertiza/reimplementation-front-end/pull/67
* '''Test Video Link:'''

File:Mock data.png

2024-10-30T02:47:33Z

Ssomang:

CSC/ECE 517 Fall 2024 - E2465. UI for Institutions and Notification

2024-10-30T02:47:12Z

Ssomang:

__TOC__

=About Expertiza=

[http://expertiza.ncsu.edu/ Expertiza], an open-source project built on Ruby on Rails, serves as a versatile learning management platform, enabling instructors to design and customize assignments. It facilitates collaborative learning by allowing students to select topics, form teams, and participate in peer reviews. Recently, the platform has expanded to incorporate modern frontend technologies, with components being refactored to use React.js and Typescript. This upgrade enhances the user experience, making the interface more interactive and responsive while supporting submissions in multiple formats, including URLs and wiki pages, for seamless review and evaluation.

=Issues with previous Functionality=
* The prior implementation effectively created user interfaces for managing roles and institutions but missed certain critical specifications.
* The project was not merged due to unnecessary dynamic role creation; only administrators required the ability to add roles, so this feature was removed to simplify the design.
* The institution management interface lacked proper authorization, allowing all users access to manage institutions, which conflicted with intended role-based permissions.

=Design Goals=
* Modernize the Frontend: Re-implement the existing Institutions UI from Ruby on Rails to TypeScript and ReactJS for improved modularity, performance, and maintainability.

* Authorization-Optimized UIs: Ensure role-based access by allowing only designated roles (e.g., TAs, Instructors) to manage specific functionalities in Institutions and Notifications.

* Enhanced Notifications Feature: Introduce a robust notification management system that enables course-specific notifications creation for higher roles and displays relevant notifications to enrolled students.

* Toggle and Filter Options: Implement a toggle for notifications to control active/inactive status and filter notifications for students to display only active, course-relevant alerts.

=Implementation=

=== Enhanced the Manage Institutions page UI ===

Improved the layout and styling of the Manage Institutions page to provide a more user-friendly interface. Adjusted table centering, optimized spacing, and updated visual elements for better alignment and readability.
[[File:Manage institutions.PNG|center|800px]]

===Added authorization for Institutions [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/0eb2a19b2aa2454f4e5e51b3a02afd28ec79e63c commit]===

Implemented role-based access control to ensure only users with Instructor or higher roles can manage institutions, aligning permissions with user roles and preventing unauthorized access.
[[File: Authentication for institution.PNG|center|800px]]

===Added Manage Notifications Page [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/de6b0d635cc1a0446928dbe7c838be3ad913f73d commit]===

Developed a dedicated page where authorized users, such as TAs and Instructors, can create, edit, and delete course-specific notifications to streamline communication and course updates.
[[File:Manage notifications.PNG|center|800px]]
Following pop-up window appears on clicking create button. the Close/ Create Notification button will redirect to the Manage Notifications page.
[[File:Manage notifications - create.png|center|800px]]
Following pop-up window appears on clicking edit button for an existing notification. the Close/ Update Notification button will redirect to the Manage Notifications page.
[[File:Manage notifications - update.png|center|800px]]
Following pop-up window appears on clicking delete button. the Delete button will redirect to the Manage Notifications page and dispatch an alert message on top of the page that the notification was deleted successfully.
[[File:Manage notifications - delete.png|center|800px]]

===Added My Notifications Page [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/c998ced0962c1d786d5e137c638f9cf051488e20 commit]===

Created a page for students to view relevant, active notifications for courses they are enrolled in, ensuring they receive timely updates on assignments, exams, and other course events.
[[File:My notifications.PNG|center|800px]]

===Added Toggle Notification Feature [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/d341cdfea89b85a24fb5c9be4340981b46bccba5 commit]===

Implemented a toggle option for authorized users to activate or deactivate notifications, allowing control over the visibility of notifications for students based on course requirements.
[[File:Toggle notifications.PNG|center|300px]]

===Added Notification Badge [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/a66f55a3907c6bf969a2b1751624cf81ab353583 commit]===

Introduced a notification badge on the "My Notifications" menu item, displaying the count of new or unread notifications to keep users informed of recent updates at a glance.
[[File:Notification badge.PNG|center|600px]]

===Added Alert on Home Page===

Implemented an alert on the home page to notify users of any unread notifications upon login, ensuring important updates are immediately visible.
[[File:Notification Alert.PNG|center|900px]]

=Testing=
Added mock data for verifying the pages are rendered as expected. There is currently no backend implemented, so the tests does not involve calling relevant API endpoints; this will be considered as future work.

Mentor Jay Patel : jhpatel9@ncsu.edu

* '''Vaibhavi Shetty:''' vshetty2@ncsu.edu
* '''Soubarnica Suresh''' ssomang@ncsu.edu

=Relevant Links=
* '''Github Repository:''' https://github.com/SoubarnicaSuresh/reimplementation-front-end
* '''Pull Request:''' https://github.com/expertiza/reimplementation-front-end/pull/67
* '''Test Video Link:'''

CSC/ECE 517 Fall 2024 - E2465. UI for Institutions and Notification

2024-10-30T02:39:03Z

Ssomang: /* Relevant Links */

__TOC__

=About Expertiza=

[http://expertiza.ncsu.edu/ Expertiza], an open-source project built on Ruby on Rails, serves as a versatile learning management platform, enabling instructors to design and customize assignments. It facilitates collaborative learning by allowing students to select topics, form teams, and participate in peer reviews. Recently, the platform has expanded to incorporate modern frontend technologies, with components being refactored to use React.js and Typescript. This upgrade enhances the user experience, making the interface more interactive and responsive while supporting submissions in multiple formats, including URLs and wiki pages, for seamless review and evaluation.

=Issues with previous Functionality=
* The prior implementation effectively created user interfaces for managing roles and institutions but missed certain critical specifications.
* The project was not merged due to unnecessary dynamic role creation; only administrators required the ability to add roles, so this feature was removed to simplify the design.
* The institution management interface lacked proper authorization, allowing all users access to manage institutions, which conflicted with intended role-based permissions.

=Design Goals=
* Modernize the Frontend: Re-implement the existing Institutions UI from Ruby on Rails to TypeScript and ReactJS for improved modularity, performance, and maintainability.

* Authorization-Optimized UIs: Ensure role-based access by allowing only designated roles (e.g., TAs, Instructors) to manage specific functionalities in Institutions and Notifications.

* Enhanced Notifications Feature: Introduce a robust notification management system that enables course-specific notifications creation for higher roles and displays relevant notifications to enrolled students.

* Toggle and Filter Options: Implement a toggle for notifications to control active/inactive status and filter notifications for students to display only active, course-relevant alerts.

=Implementation=

=== Enhanced the Manage Institutions page UI ===

Improved the layout and styling of the Manage Institutions page to provide a more user-friendly interface. Adjusted table centering, optimized spacing, and updated visual elements for better alignment and readability.
[[File:Manage institutions.PNG|center|800px]]

===Added authorization for Institutions [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/0eb2a19b2aa2454f4e5e51b3a02afd28ec79e63c commit]===

Implemented role-based access control to ensure only users with Instructor or higher roles can manage institutions, aligning permissions with user roles and preventing unauthorized access.
[[File: Authentication for institution.PNG|center|800px]]

===Added Manage Notifications Page [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/de6b0d635cc1a0446928dbe7c838be3ad913f73d commit]===

Developed a dedicated page where authorized users, such as TAs and Instructors, can create, edit, and delete course-specific notifications to streamline communication and course updates.
[[File:Manage notifications.PNG|center|800px]]
Following pop-up window appears on clicking create button. the Close/ Create Notification button will redirect to the Manage Notifications page.
[[File:Manage notifications - create.png|center|800px]]
Following pop-up window appears on clicking edit button for an existing notification. the Close/ Update Notification button will redirect to the Manage Notifications page.
[[File:Manage notifications - update.png|center|800px]]
Following pop-up window appears on clicking delete button. the Delete button will redirect to the Manage Notifications page and dispatch an alert message on top of the page that the notification was deleted successfully.
[[File:Manage notifications - delete.png|center|800px]]

===Added My Notifications Page [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/c998ced0962c1d786d5e137c638f9cf051488e20 commit]===

Created a page for students to view relevant, active notifications for courses they are enrolled in, ensuring they receive timely updates on assignments, exams, and other course events.
[[File:My notifications.PNG|center|800px]]

===Added Toggle Notification Feature [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/d341cdfea89b85a24fb5c9be4340981b46bccba5 commit]===

Implemented a toggle option for authorized users to activate or deactivate notifications, allowing control over the visibility of notifications for students based on course requirements.
[[File:Toggle notifications.PNG|center|300px]]

===Added Notification Badge [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/a66f55a3907c6bf969a2b1751624cf81ab353583 commit]===

Introduced a notification badge on the "My Notifications" menu item, displaying the count of new or unread notifications to keep users informed of recent updates at a glance.
[[File:Notification badge.PNG|center|600px]]

===Added Alert on Home Page===

Implemented an alert on the home page to notify users of any unread notifications upon login, ensuring important updates are immediately visible.
[[File:Notification Alert.PNG|center|900px]]

=Team=

Mentor Jay Patel : jhpatel9@ncsu.edu

* '''Vaibhavi Shetty:''' vshetty2@ncsu.edu
* '''Soubarnica Suresh''' ssomang@ncsu.edu

=Relevant Links=
* '''Github Repository:''' https://github.com/SoubarnicaSuresh/reimplementation-front-end
* '''Pull Request:''' https://github.com/expertiza/reimplementation-front-end/pull/67
* '''Test Video Link:'''

CSC/ECE 517 Fall 2024 - E2465. UI for Institutions and Notification

2024-10-30T02:22:33Z

Ssomang: /* Added Manage Notifications Page commit */

__TOC__

=About Expertiza=

[http://expertiza.ncsu.edu/ Expertiza], an open-source project built on Ruby on Rails, serves as a versatile learning management platform, enabling instructors to design and customize assignments. It facilitates collaborative learning by allowing students to select topics, form teams, and participate in peer reviews. Recently, the platform has expanded to incorporate modern frontend technologies, with components being refactored to use React.js and Typescript. This upgrade enhances the user experience, making the interface more interactive and responsive while supporting submissions in multiple formats, including URLs and wiki pages, for seamless review and evaluation.

=Issues with previous Functionality=
* The prior implementation effectively created user interfaces for managing roles and institutions but missed certain critical specifications.
* The project was not merged due to unnecessary dynamic role creation; only administrators required the ability to add roles, so this feature was removed to simplify the design.
* The institution management interface lacked proper authorization, allowing all users access to manage institutions, which conflicted with intended role-based permissions.

=Design Goals=
* Modernize the Frontend: Re-implement the existing Institutions UI from Ruby on Rails to TypeScript and ReactJS for improved modularity, performance, and maintainability.

* Authorization-Optimized UIs: Ensure role-based access by allowing only designated roles (e.g., TAs, Instructors) to manage specific functionalities in Institutions and Notifications.

* Enhanced Notifications Feature: Introduce a robust notification management system that enables course-specific notifications creation for higher roles and displays relevant notifications to enrolled students.

* Toggle and Filter Options: Implement a toggle for notifications to control active/inactive status and filter notifications for students to display only active, course-relevant alerts.

=Implementation=

=== Enhanced the Manage Institutions page UI ===

Improved the layout and styling of the Manage Institutions page to provide a more user-friendly interface. Adjusted table centering, optimized spacing, and updated visual elements for better alignment and readability.
[[File:Manage institutions.PNG|center|800px]]

===Added authorization for Institutions [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/0eb2a19b2aa2454f4e5e51b3a02afd28ec79e63c commit]===

Implemented role-based access control to ensure only users with Instructor or higher roles can manage institutions, aligning permissions with user roles and preventing unauthorized access.
[[File: Authentication for institution.PNG|center|800px]]

===Added Manage Notifications Page [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/de6b0d635cc1a0446928dbe7c838be3ad913f73d commit]===

Developed a dedicated page where authorized users, such as TAs and Instructors, can create, edit, and delete course-specific notifications to streamline communication and course updates.
[[File:Manage notifications.PNG|center|800px]]
Following pop-up window appears on clicking create button. the Close/ Create Notification button will redirect to the Manage Notifications page.
[[File:Manage notifications - create.png|center|800px]]
Following pop-up window appears on clicking edit button for an existing notification. the Close/ Update Notification button will redirect to the Manage Notifications page.
[[File:Manage notifications - update.png|center|800px]]
Following pop-up window appears on clicking delete button. the Delete button will redirect to the Manage Notifications page and dispatch an alert message on top of the page that the notification was deleted successfully.
[[File:Manage notifications - delete.png|center|800px]]

===Added My Notifications Page [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/c998ced0962c1d786d5e137c638f9cf051488e20 commit]===

Created a page for students to view relevant, active notifications for courses they are enrolled in, ensuring they receive timely updates on assignments, exams, and other course events.
[[File:My notifications.PNG|center|800px]]

===Added Toggle Notification Feature [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/d341cdfea89b85a24fb5c9be4340981b46bccba5 commit]===

Implemented a toggle option for authorized users to activate or deactivate notifications, allowing control over the visibility of notifications for students based on course requirements.
[[File:Toggle notifications.PNG|center|300px]]

===Added Notification Badge [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/a66f55a3907c6bf969a2b1751624cf81ab353583 commit]===

Introduced a notification badge on the "My Notifications" menu item, displaying the count of new or unread notifications to keep users informed of recent updates at a glance.
[[File:Notification badge.PNG|center|600px]]

===Added Alert on Home Page===

Implemented an alert on the home page to notify users of any unread notifications upon login, ensuring important updates are immediately visible.
[[File:Notification Alert.PNG|center|900px]]

=Team=

Mentor Jay Patel : jhpatel9@ncsu.edu

* '''Vaibhavi Shetty:''' vshetty2@ncsu.edu
* '''Soubarnica Suresh''' ssomang@ncsu.edu

=Relevant Links=
* '''Github Repository:''' https://github.com/SoubarnicaSuresh/reimplementation-front-end
* '''Pull Request:'''
* '''Test Video Link:'''

CSC/ECE 517 Fall 2024 - E2465. UI for Institutions and Notification

2024-10-30T02:18:23Z

Ssomang: /* Added Manage Notifications Page commit */

__TOC__

=About Expertiza=

[http://expertiza.ncsu.edu/ Expertiza], an open-source project built on Ruby on Rails, serves as a versatile learning management platform, enabling instructors to design and customize assignments. It facilitates collaborative learning by allowing students to select topics, form teams, and participate in peer reviews. Recently, the platform has expanded to incorporate modern frontend technologies, with components being refactored to use React.js and Typescript. This upgrade enhances the user experience, making the interface more interactive and responsive while supporting submissions in multiple formats, including URLs and wiki pages, for seamless review and evaluation.

=Issues with previous Functionality=
* The prior implementation effectively created user interfaces for managing roles and institutions but missed certain critical specifications.
* The project was not merged due to unnecessary dynamic role creation; only administrators required the ability to add roles, so this feature was removed to simplify the design.
* The institution management interface lacked proper authorization, allowing all users access to manage institutions, which conflicted with intended role-based permissions.

=Design Goals=
* Modernize the Frontend: Re-implement the existing Institutions UI from Ruby on Rails to TypeScript and ReactJS for improved modularity, performance, and maintainability.

* Authorization-Optimized UIs: Ensure role-based access by allowing only designated roles (e.g., TAs, Instructors) to manage specific functionalities in Institutions and Notifications.

* Enhanced Notifications Feature: Introduce a robust notification management system that enables course-specific notifications creation for higher roles and displays relevant notifications to enrolled students.

* Toggle and Filter Options: Implement a toggle for notifications to control active/inactive status and filter notifications for students to display only active, course-relevant alerts.

=Implementation=

=== Enhanced the Manage Institutions page UI ===

Improved the layout and styling of the Manage Institutions page to provide a more user-friendly interface. Adjusted table centering, optimized spacing, and updated visual elements for better alignment and readability.
[[File:Manage institutions.PNG|center|800px]]

===Added authorization for Institutions [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/0eb2a19b2aa2454f4e5e51b3a02afd28ec79e63c commit]===

Implemented role-based access control to ensure only users with Instructor or higher roles can manage institutions, aligning permissions with user roles and preventing unauthorized access.
[[File: Authentication for institution.PNG|center|800px]]

===Added Manage Notifications Page [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/de6b0d635cc1a0446928dbe7c838be3ad913f73d commit]===

Developed a dedicated page where authorized users, such as TAs and Instructors, can create, edit, and delete course-specific notifications to streamline communication and course updates.
[[File:Manage notifications.PNG|center|800px]]
Following pop-up window appears on clicking create button
[[File:Manage notifications - create.png|center|800px]]
Following pop-up window appears on clicking edit button for an existing notification
[[File:Manage notifications - update.png|center|800px]]
Following pop-up window appears on clicking delete button
[[File:Manage notifications - delete.png|center|800px]]

===Added My Notifications Page [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/c998ced0962c1d786d5e137c638f9cf051488e20 commit]===

Created a page for students to view relevant, active notifications for courses they are enrolled in, ensuring they receive timely updates on assignments, exams, and other course events.
[[File:My notifications.PNG|center|800px]]

===Added Toggle Notification Feature [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/d341cdfea89b85a24fb5c9be4340981b46bccba5 commit]===

Implemented a toggle option for authorized users to activate or deactivate notifications, allowing control over the visibility of notifications for students based on course requirements.
[[File:Toggle notifications.PNG|center|300px]]

===Added Notification Badge [https://github.com/SoubarnicaSuresh/reimplementation-front-end/commit/a66f55a3907c6bf969a2b1751624cf81ab353583 commit]===

Introduced a notification badge on the "My Notifications" menu item, displaying the count of new or unread notifications to keep users informed of recent updates at a glance.
[[File:Notification badge.PNG|center|600px]]

===Added Alert on Home Page===

Implemented an alert on the home page to notify users of any unread notifications upon login, ensuring important updates are immediately visible.
[[File:Notification Alert.PNG|center|900px]]

=Team=

Mentor Jay Patel : jhpatel9@ncsu.edu

* '''Vaibhavi Shetty:''' vshetty2@ncsu.edu
* '''Soubarnica Suresh''' ssomang@ncsu.edu

=Relevant Links=
* '''Github Repository:''' https://github.com/SoubarnicaSuresh/reimplementation-front-end
* '''Pull Request:'''
* '''Test Video Link:'''

File:Manage notifications - delete.png

2024-10-30T02:15:06Z

Ssomang:

File:Manage notifications - create.png

2024-10-30T02:14:47Z

Ssomang:

File:Manage notifications - update.png

2024-10-30T02:14:29Z

Ssomang: