Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Spring 2024 - E2415. Reimplement responses controller.rb (Design Document)

2024-04-26T18:50:29Z

Jriehle: /* Links */

CSC/ECE 517 Spring 2024 - E2415: Reimplementation of responses_controller.rb (Design Document)

==Expertiza==
The Expertiza project, an open-source endeavor rooted in Ruby on Rails, embarks on continuous improvement to adapt and integrate modern software engineering practices. The Responses Controller is engineered to assist reviewers in submitting structured data that is specifically aligned with an assignment's rubrics, ensuring the provision of relevant questions for each round within the correct due date period. It enables a reviewer to evaluate and score the rubric questions pertinent to the assignment's topics. Furthermore, it ensures the delivery of appropriate questions for each assignment round, allowing reviewers to create and modify scores and comments for each of the rubric questions associated with the assignment. After reviewers submit their scored questions and comments, the Responses Controller dispatches an email notification to the instructor and the reviewed team's members.

==Problem Statement==
The ResponseController in Expertiza, a legacy system with conventions predating Rails standards, is overly complex, encompassing functionalities beyond basic CRUD operations and needing adherence to modern Rails naming and design principles. Key issues include the direct implementation of functionalities like sorting reviews and checking reviewer roles within the controller, suggesting a shift towards polymorphism and a more structured approach to code organization. Furthermore, the controller's handling of email notifications and feedback mechanisms is inconsistent, indicating the necessity for a dedicated helper to streamline communication processes. The reimplementation effort must focus on simplifying the controller, adhering to Rails conventions, and improving code readability and maintainability by appropriately distributing responsibilities.

==Design Goal==
The redesign of the `responses_controller.rb` is guided by several key objectives to improve the code quality, system behavior, and developer interaction. The goals include:

* Maintainability and Scalability: Ensuring the code is easy to understand, modify, and extend. The reimplementation should simplify future updates and feature additions.

* Adherence to Rails Best Practices: Following Rails conventions for naming, structure, and coding practices to ensure code consistency and reliability.

* DRY Principle: "Don't Repeat Yourself" - removing redundant code and logic to create a more efficient and error-resistant codebase.

* Single Responsibility Principle: Restructuring the controller and associated models so that each class and method has one purpose and one purpose only, leading to easier testing and management.

* Improved Testing and Coverage: Enhancing test suites to cover more scenarios and edge cases, increasing confidence in the application's stability and performance.

* Performance Optimization: Identifying and optimizing slow or inefficient areas in the code to ensure the application runs smoothly.

* Clean Up Dead Methods: Audit the codebase for any unused ("dead") methods within the current controller and remove them to declutter the code.

* Reduced Controller Complexity: We already have streamline the `ResponseController` to focus primarily on CRUD operations and extract non-essential logic to appropriate models or helpers, now we aim to implement the rest operations.

By meeting these design goals, the project aims to produce a `responses_controller.rb` that is robust, efficient, and a pleasure to work with, both for the current development team and for those who will maintain the system in the future.

== Design Pattern ==

During the code refactoring process, we conscientiously followed various design patterns to enhance the overall structure.
When refactoring the Response model and associated controller and helper methods in the application, several key design patterns and principles were followed to ensure improved code quality, maintainability, and scalability. Here are the primary patterns and principles that were considered:

=== Single Responsibility Principle (SRP) ===
This principle was applied to break down complex methods into smaller, more focused functions that handle a specific part of the process

*In the Response Model:
Validate_params was broken down into multiple smaller methods, each handling a specific part of the validation process. This allows each method to manage one aspect of the validation, making the code easier to maintain and modify.
Creation and management of relationships and basic attributes were clearly defined, ensuring that the Response class isn't overloaded with logic that doesn't pertain to its direct attributes or relationships.

*In the ResponsesController:
The controller methods like create, update, show, etc., were defined to handle only HTTP requests and delegate business logic to the model or helper methods. This keeps the controller actions clean and focused on routing and basic request handling.

*In the ResponseHelper:
Methods such as create_answers and update_answers are good examples where each method is tasked with either creating or updating answers but not both. This follows SRP by dividing the responsibilities into more manageable, discrete operations.

===Factory Method===
The Factory Method pattern can be seen implicitly where object creation processes are encapsulated within the model or helper methods, such as creating a new ResponseMap or generating new Answer objects. This ensures that object creation is modular and separated from the main application logic.
===Strategy Pattern===
By defining a family of algorithms (in this case, validation rules for different actions like create or update), encapsulating each one, and making them interchangeable, the strategy pattern lets the algorithm vary independently from the clients that use it. For instance, separating the validation conditions for creating and updating responses allows for flexible swapping and extension of validation logic without modifying the controller or model directly.
===Observer Pattern===
Used typically in scenarios where changes to a particular object need to notify other dependent objects automatically. In the context of this application, this could relate to notifying instructors or peers upon the submission or update of responses, handled through the helper methods for sending emails.
===Template Method===
This pattern can be used in defining the skeleton of an operation in a method, deferring some steps to subclasses or other methods. It's seen in how validate_params uses a general structure for validation but defers the specifics to methods like validate_create_conditions and validate_update_conditions.

By integrating these design patterns and principles, the refactoring aims to achieve a more robust, maintainable, and scalable system. This approach not only addresses current complexities but also lays a foundation for easier future enhancements and modifications.

== Class Diagram ==
[[File:controller_Class_diagram.png|900px]]

== Use cases ==
[[File:Use_cases_controller.png|900px]]

== Solutions/Details of Changes Made==
=== Response Model ===
Methods within the response model were refactored or introduced, including:
==== set_content ====
Redesigned to gather and prepare the required data for response objects, optimizing the interaction with associated models
==== validate_params ====
This is the original method that was 46 lines long:

[[File:Validate parameters before.png|900px]]

===This method was significantly refactored to improve parameter validation. It was split into multiple smaller, focused methods, each dedicated to handling a specific aspect of the validation process. Each new method does one thing only, which makes them easier to understand and maintain.===
* assign_map_id_from_params: Sets the map_id for the response based on the provided parameters, ensuring the correct map ID is used for both creating and updating responses.
[[File:Assign map id.png|900px]]

*set_and_validate_response_map: Establishes and validates the presence of the response_map based on map_id. It's crucial to ensure that any response being created or updated is linked to a valid response map.This method attempts to find a ResponseMap based on map_id. If it fails to find one, it records an error and halts further validation, signaling an issue early in the process.
[[File:Set and validte response.png|900px]]

*set_response_attributes(params):Assigns additional attributes to the response object from the parameters. This centralizes attribute setting, reducing redundancy and errors.Directly extracts values like round, version_num, additional_comment, and visibility from the parameters and assigns them to the response object.
[[File:Set response attributes.png|900px]]

*action_specific_validation(params, action): Directs the validation flow based on whether the action is to create or update a response, organizing the logic clearly and preventing condition sprawl in the main validation method.Calls specific validation methods based on the action type: validate_create_conditions for creation and validate_update_conditions for updates.
[[File:Action specific validation.png|900px]]

*validate_create_conditions: Ensures that a new response doesn't duplicate an existing one under the same response map, round, and version number.Searches for an existing response that matches the current map_id, round, and version_num. If such a response exists, it adds a validation error and prevents the creation of a duplicate response.
[[File:Validate create condition.png|900px]]

*validate_update_conditions(params): Ensures that updates to a response are valid, specifically checking that a response isn't already submitted and that its map_id remains unchanged.Checks the submission status and whether there's an attempt to change the map_id. If either condition is violated, it records an error.
[[File:Validate update conditions.png|900px]]

*validate_submission_status(params): Updates the submission status of the response during the update process, ensuring the attribute is correctly set based on the provided parameters.Extracts and sets the is_submitted status from the parameters, which is crucial for controlling the editability of the response.
[[File:Validate submission status .png|900px]]

==== serialize_response ====
Improved to efficiently serialize response data for API interactions, enhancing the clarity and usability of data exchanges.

=== Response Controller ===
The ResponseController, originally extensive with numerous functions beyond basic CRUD operations, has been streamlined for our API application. In this context, there's no need to manage data variables for view pages, simplifying the handling of request data solely through request methods.To enhance the architecture and efficiency of our application, we've eliminated redundant methods and consolidated functionalities across the model, controller, and helper files. This restructuring was essential for refining the response endpoints specifically tailored for an API application.

Before we added Basic CRUD like New, Create, Update, edit, destroy.

Removed Methods: Legacy methods like Questionnaire_from_response_map and Questionnaire_from_response were removed following the refactoring of set_content, which now handles its functionalities internally without the need for these methods.

==== Show_calibration_results_for_student ====
Before:

[[File:Show calibration results for student.PNG|900px]]

The old implementation also made use of database queries in the view. This will not be possible in the reimplemented Expertiza, and the required data will need to be made available in the JSON response sent by the controller.
[[File:DB access in view.PNG|900px]]
[[File:DB access in view 2.PNG|900px]]

The new show_calibration_results_for_student method retrieves and displays calibration and review responses based on provided map IDs. It fetches responses using these IDs, retrieves associated questions and answers, and returns the data as a formatted JSON object. If a response is not found, it returns an error indicating the missing response. The method handles any exceptions by returning a standard error message, ensuring robust error handling throughout the process.
Serves as an API endpoint to fetch detailed response data for a student's calibration and review tasks, providing all necessary details about the questions asked and the answers provided in both contexts

[[File:Show_calibration_results.png|900px]]

=== Response Helper ===

The method create_update_answers(response, answers) was originally handling both the creation and updating of answer records within a single method:

[[File:Create_update_answers_before.png|900px]]

To improve code maintainability and adhere to the Single Responsibility Principle, this method has been divided into two distinct methods:

==== Create_answers ====
This method focuses solely on creating new answer records. It iterates over the answers provided, checking if each answer does not already exist in the database. If the answer does not exist, it creates a new record for that answer. This ensures that each answer is unique and prevents duplication.
[[File:Create_answers_after.png|900px]]

==== Update_answers ====
This method is responsible for updating existing answer records. It searches for existing answers in the database based on the response and question identifiers. If an answer is found, it updates the existing record with the new information provided. This method ensures that all modifications to answers are captured accurately and that the database is kept up-to-date.

[[File:Update_answers_after.png|900px]]

==Files Modified/Added==
List of primary files modified or created includes:
* responses_controller.rb
* response_helper.rb
* response.rb

==Test==

===Validate Parameters===
====Postman Tests====

[[File:Postman_after_update.png|900px]]
[[File:DB validate parameters update test.png|900px]]

===Separated Answer Creation and Update Logic===
====Postman Tests====
Creation:
[[File:Postman after create for answer.png|900px]]
[[File:DB after create.png|900px]]

Update:
[[File:Postman after update for answer.png|900px]]
[[File:DB after update.png|900px]]

==Team==
===== Mentor=====
*Ameya Vaichalkar

=====Members=====
* Jeff Riehle
* Maday Moya
* Shardul Ladekar

==Links==
Postman Video Links:
*create: https://youtu.be/hXQl-JkfuUc
*update: https://youtu.be/BeifLsCRQlk
*show_calibration_results_for_student: https://www.youtube.com/watch?v=ltJarFGb25k

Pull request: https://github.com/expertiza/reimplementation-back-end/pull/92

Model Tests Video: https://youtu.be/7x8x4l3AksE

Controller Tests Video: https://youtu.be/0PV-ycXfyZU

==References==

*

CSC/ECE 517 Spring 2024 - E2415. Reimplement responses controller.rb (Design Document)

2024-04-26T18:43:29Z

Jriehle: /* Links */

CSC/ECE 517 Spring 2024 - E2415. Reimplement responses controller.rb (Design Document)

2024-04-26T17:09:03Z

Jriehle: /* Links */

CSC/ECE 517 Spring 2024 - E2415: Reimplementation of responses_controller.rb (Design Document)

==Expertiza==
The Expertiza project, an open-source endeavor rooted in Ruby on Rails, embarks on continuous improvement to adapt and integrate modern software engineering practices. The Responses Controller is engineered to assist reviewers in submitting structured data that is specifically aligned with an assignment's rubrics, ensuring the provision of relevant questions for each round within the correct due date period. It enables a reviewer to evaluate and score the rubric questions pertinent to the assignment's topics. Furthermore, it ensures the delivery of appropriate questions for each assignment round, allowing reviewers to create and modify scores and comments for each of the rubric questions associated with the assignment. After reviewers submit their scored questions and comments, the Responses Controller dispatches an email notification to the instructor and the reviewed team's members.

==Problem Statement==
The ResponseController in Expertiza, a legacy system with conventions predating Rails standards, is overly complex, encompassing functionalities beyond basic CRUD operations and needing adherence to modern Rails naming and design principles. Key issues include the direct implementation of functionalities like sorting reviews and checking reviewer roles within the controller, suggesting a shift towards polymorphism and a more structured approach to code organization. Furthermore, the controller's handling of email notifications and feedback mechanisms is inconsistent, indicating the necessity for a dedicated helper to streamline communication processes. The reimplementation effort must focus on simplifying the controller, adhering to Rails conventions, and improving code readability and maintainability by appropriately distributing responsibilities.

==Design Goal==
The redesign of the `responses_controller.rb` is guided by several key objectives to improve the code quality, system behavior, and developer interaction. The goals include:

* Maintainability and Scalability: Ensuring the code is easy to understand, modify, and extend. The reimplementation should simplify future updates and feature additions.

* Adherence to Rails Best Practices: Following Rails conventions for naming, structure, and coding practices to ensure code consistency and reliability.

* DRY Principle: "Don't Repeat Yourself" - removing redundant code and logic to create a more efficient and error-resistant codebase.

* Single Responsibility Principle: Restructuring the controller and associated models so that each class and method has one purpose and one purpose only, leading to easier testing and management.

* Improved Testing and Coverage: Enhancing test suites to cover more scenarios and edge cases, increasing confidence in the application's stability and performance.

* Performance Optimization: Identifying and optimizing slow or inefficient areas in the code to ensure the application runs smoothly.

* Clean Up Dead Methods: Audit the codebase for any unused ("dead") methods within the current controller and remove them to declutter the code.

* Reduced Controller Complexity: We already have streamline the `ResponseController` to focus primarily on CRUD operations and extract non-essential logic to appropriate models or helpers, now we aim to implement the rest operations.

By meeting these design goals, the project aims to produce a `responses_controller.rb` that is robust, efficient, and a pleasure to work with, both for the current development team and for those who will maintain the system in the future.

== Design Pattern ==

During the code refactoring process, we conscientiously followed various design patterns to enhance the overall structure.
When refactoring the Response model and associated controller and helper methods in the application, several key design patterns and principles were followed to ensure improved code quality, maintainability, and scalability. Here are the primary patterns and principles that were considered:

=== Single Responsibility Principle (SRP) ===
This principle was applied to break down complex methods into smaller, more focused functions that handle a specific part of the process

*In the Response Model:
Validate_params was broken down into multiple smaller methods, each handling a specific part of the validation process. This allows each method to manage one aspect of the validation, making the code easier to maintain and modify.
Creation and management of relationships and basic attributes were clearly defined, ensuring that the Response class isn't overloaded with logic that doesn't pertain to its direct attributes or relationships.

*In the ResponsesController:
The controller methods like create, update, show, etc., were defined to handle only HTTP requests and delegate business logic to the model or helper methods. This keeps the controller actions clean and focused on routing and basic request handling.

*In the ResponseHelper:
Methods such as create_answers and update_answers are good examples where each method is tasked with either creating or updating answers but not both. This follows SRP by dividing the responsibilities into more manageable, discrete operations.

===Factory Method===
The Factory Method pattern can be seen implicitly where object creation processes are encapsulated within the model or helper methods, such as creating a new ResponseMap or generating new Answer objects. This ensures that object creation is modular and separated from the main application logic.
===Strategy Pattern===
By defining a family of algorithms (in this case, validation rules for different actions like create or update), encapsulating each one, and making them interchangeable, the strategy pattern lets the algorithm vary independently from the clients that use it. For instance, separating the validation conditions for creating and updating responses allows for flexible swapping and extension of validation logic without modifying the controller or model directly.
===Observer Pattern===
Used typically in scenarios where changes to a particular object need to notify other dependent objects automatically. In the context of this application, this could relate to notifying instructors or peers upon the submission or update of responses, handled through the helper methods for sending emails.
===Template Method===
This pattern can be used in defining the skeleton of an operation in a method, deferring some steps to subclasses or other methods. It's seen in how validate_params uses a general structure for validation but defers the specifics to methods like validate_create_conditions and validate_update_conditions.

By integrating these design patterns and principles, the refactoring aims to achieve a more robust, maintainable, and scalable system. This approach not only addresses current complexities but also lays a foundation for easier future enhancements and modifications.

== Class Diagram ==
[[File:controller_Class_diagram.png|900px]]

== Use cases ==
[[File:Use_cases_controller.png|900px]]

== Solutions/Details of Changes Made==
=== Response Model ===
Methods within the response model were refactored or introduced, including:
==== set_content ====
Redesigned to gather and prepare the required data for response objects, optimizing the interaction with associated models
==== validate_params ====
This is the original method that was 46 lines long:

[[File:Validate parameters before.png|900px]]

===This method was significantly refactored to improve parameter validation. It was split into multiple smaller, focused methods, each dedicated to handling a specific aspect of the validation process. Each new method does one thing only, which makes them easier to understand and maintain.===
* assign_map_id_from_params: Sets the map_id for the response based on the provided parameters, ensuring the correct map ID is used for both creating and updating responses.
[[File:Assign map id.png|900px]]

*set_and_validate_response_map: Establishes and validates the presence of the response_map based on map_id. It's crucial to ensure that any response being created or updated is linked to a valid response map.This method attempts to find a ResponseMap based on map_id. If it fails to find one, it records an error and halts further validation, signaling an issue early in the process.
[[File:Set and validte response.png|900px]]

*set_response_attributes(params):Assigns additional attributes to the response object from the parameters. This centralizes attribute setting, reducing redundancy and errors.Directly extracts values like round, version_num, additional_comment, and visibility from the parameters and assigns them to the response object.
[[File:Set response attributes.png|900px]]

*action_specific_validation(params, action): Directs the validation flow based on whether the action is to create or update a response, organizing the logic clearly and preventing condition sprawl in the main validation method.Calls specific validation methods based on the action type: validate_create_conditions for creation and validate_update_conditions for updates.
[[File:Action specific validation.png|900px]]

*validate_create_conditions: Ensures that a new response doesn't duplicate an existing one under the same response map, round, and version number.Searches for an existing response that matches the current map_id, round, and version_num. If such a response exists, it adds a validation error and prevents the creation of a duplicate response.
[[File:Validate create condition.png|900px]]

*validate_update_conditions(params): Ensures that updates to a response are valid, specifically checking that a response isn't already submitted and that its map_id remains unchanged.Checks the submission status and whether there's an attempt to change the map_id. If either condition is violated, it records an error.
[[File:Validate update conditions.png|900px]]

*validate_submission_status(params): Updates the submission status of the response during the update process, ensuring the attribute is correctly set based on the provided parameters.Extracts and sets the is_submitted status from the parameters, which is crucial for controlling the editability of the response.
[[File:Validate submission status .png|900px]]

==== serialize_response ====
Improved to efficiently serialize response data for API interactions, enhancing the clarity and usability of data exchanges.

=== Response Controller ===
The ResponseController, originally extensive with numerous functions beyond basic CRUD operations, has been streamlined for our API application. In this context, there's no need to manage data variables for view pages, simplifying the handling of request data solely through request methods.To enhance the architecture and efficiency of our application, we've eliminated redundant methods and consolidated functionalities across the model, controller, and helper files. This restructuring was essential for refining the response endpoints specifically tailored for an API application.

Before we added Basic CRUD like New, Create, Update, edit, destroy.

Removed Methods: Legacy methods like Questionnaire_from_response_map and Questionnaire_from_response were removed following the refactoring of set_content, which now handles its functionalities internally without the need for these methods.

==== Show_calibration_results_for_student ====
Before:

[[File:Show calibration results for student.PNG|900px]]

The old implementation also made use of database queries in the view. This will not be possible in the reimplemented Expertiza, and the required data will need to be made available in the JSON response sent by the controller.
[[File:DB access in view.PNG|900px]]
[[File:DB access in view 2.PNG|900px]]

The new show_calibration_results_for_student method retrieves and displays calibration and review responses based on provided map IDs. It fetches responses using these IDs, retrieves associated questions and answers, and returns the data as a formatted JSON object. If a response is not found, it returns an error indicating the missing response. The method handles any exceptions by returning a standard error message, ensuring robust error handling throughout the process.
Serves as an API endpoint to fetch detailed response data for a student's calibration and review tasks, providing all necessary details about the questions asked and the answers provided in both contexts

[[File:Show_calibration_results.png|900px]]

=== Response Helper ===

The method create_update_answers(response, answers) was originally handling both the creation and updating of answer records within a single method:

[[File:Create_update_answers_before.png|900px]]

To improve code maintainability and adhere to the Single Responsibility Principle, this method has been divided into two distinct methods:

==== Create_answers ====
This method focuses solely on creating new answer records. It iterates over the answers provided, checking if each answer does not already exist in the database. If the answer does not exist, it creates a new record for that answer. This ensures that each answer is unique and prevents duplication.
[[File:Create_answers_after.png|900px]]

==== Update_answers ====
This method is responsible for updating existing answer records. It searches for existing answers in the database based on the response and question identifiers. If an answer is found, it updates the existing record with the new information provided. This method ensures that all modifications to answers are captured accurately and that the database is kept up-to-date.

[[File:Update_answers_after.png|900px]]

==Files Modified/Added==
List of primary files modified or created includes:
* responses_controller.rb
* response_helper.rb
* response.rb

==Test==

===Validate Parameters===
====Postman Tests====

[[File:Postman_after_update.png|900px]]
[[File:DB validate parameters update test.png|900px]]

===Separated Answer Creation and Update Logic===
====Postman Tests====
Creation:
[[File:Postman after create for answer.png|900px]]
[[File:DB after create.png|900px]]

Update:
[[File:Postman after update for answer.png|900px]]
[[File:DB after update.png|900px]]

==Team==
===== Mentor=====
*Ameya Vaichalkar

=====Members=====
* Jeff Riehle
* Maday Moya
* Shardul Ladekar

==Links==
Postman Video Links:
*create: https://youtu.be/hXQl-JkfuUc
*update: https://youtu.be/BeifLsCRQlk
*show_calibration_results_for_student: https://www.youtube.com/watch?v=ltJarFGb25k

Pull request: https://github.com/expertiza/reimplementation-back-end/pull/92

Model Tests Video: https://youtu.be/EPoD3ai33qk

Controller Tests Video: https://youtu.be/moZrjXE-dM8

==References==

*

CSC/ECE 517 Spring 2024 - E2415. Reimplement responses controller.rb (Design Document)

2024-04-24T03:50:22Z

Jriehle: /* Links */

CSC/ECE 517 Spring 2024 - E2415: Reimplementation of responses_controller.rb (Design Document)

==Expertiza==
The Expertiza project, an open-source endeavor rooted in Ruby on Rails, embarks on continuous improvement to adapt and integrate modern software engineering practices. The Responses Controller is engineered to assist reviewers in submitting structured data that is specifically aligned with an assignment's rubrics, ensuring the provision of relevant questions for each round within the correct due date period. It enables a reviewer to evaluate and score the rubric questions pertinent to the assignment's topics. Furthermore, it ensures the delivery of appropriate questions for each assignment round, allowing reviewers to create and modify scores and comments for each of the rubric questions associated with the assignment. After reviewers submit their scored questions and comments, the Responses Controller dispatches an email notification to the instructor and the reviewed team's members.

==Problem Statement==
The ResponseController in Expertiza, a legacy system with conventions predating Rails standards, is overly complex, encompassing functionalities beyond basic CRUD operations and needing adherence to modern Rails naming and design principles. Key issues include the direct implementation of functionalities like sorting reviews and checking reviewer roles within the controller, suggesting a shift towards polymorphism and a more structured approach to code organization. Furthermore, the controller's handling of email notifications and feedback mechanisms is inconsistent, indicating the necessity for a dedicated helper to streamline communication processes. The reimplementation effort must focus on simplifying the controller, adhering to Rails conventions, and improving code readability and maintainability by appropriately distributing responsibilities.

==Design Goal==
The redesign of the `responses_controller.rb` is guided by several key objectives to improve the code quality, system behavior, and developer interaction. The goals include:

* Maintainability and Scalability: Ensuring the code is easy to understand, modify, and extend. The reimplementation should simplify future updates and feature additions.

* Adherence to Rails Best Practices: Following Rails conventions for naming, structure, and coding practices to ensure code consistency and reliability.

* DRY Principle: "Don't Repeat Yourself" - removing redundant code and logic to create a more efficient and error-resistant codebase.

* Single Responsibility Principle: Restructuring the controller and associated models so that each class and method has one purpose and one purpose only, leading to easier testing and management.

* Improved Testing and Coverage: Enhancing test suites to cover more scenarios and edge cases, increasing confidence in the application's stability and performance.

* Performance Optimization: Identifying and optimizing slow or inefficient areas in the code to ensure the application runs smoothly.

* Clean Up Dead Methods: Audit the codebase for any unused ("dead") methods within the current controller and remove them to declutter the code.

* Reduced Controller Complexity: We already have streamline the `ResponseController` to focus primarily on CRUD operations and extract non-essential logic to appropriate models or helpers, now we aim to implement the rest operations.

By meeting these design goals, the project aims to produce a `responses_controller.rb` that is robust, efficient, and a pleasure to work with, both for the current development team and for those who will maintain the system in the future.

== Design Pattern ==

During the code refactoring process, we conscientiously followed various design patterns to enhance the overall structure.
When refactoring the Response model and associated controller and helper methods in the application, several key design patterns and principles were followed to ensure improved code quality, maintainability, and scalability. Here are the primary patterns and principles that were considered:

=== Single Responsibility Principle (SRP) ===
This principle was applied to break down complex methods into smaller, more focused functions that handle a specific part of the process

*In the Response Model:
Validate_params was broken down into multiple smaller methods, each handling a specific part of the validation process. This allows each method to manage one aspect of the validation, making the code easier to maintain and modify.
Creation and management of relationships and basic attributes were clearly defined, ensuring that the Response class isn't overloaded with logic that doesn't pertain to its direct attributes or relationships.

*In the ResponsesController:
The controller methods like create, update, show, etc., were defined to handle only HTTP requests and delegate business logic to the model or helper methods. This keeps the controller actions clean and focused on routing and basic request handling.

*In the ResponseHelper:
Methods such as create_answers and update_answers are good examples where each method is tasked with either creating or updating answers but not both. This follows SRP by dividing the responsibilities into more manageable, discrete operations.

===Factory Method===
The Factory Method pattern can be seen implicitly where object creation processes are encapsulated within the model or helper methods, such as creating a new ResponseMap or generating new Answer objects. This ensures that object creation is modular and separated from the main application logic.
===Strategy Pattern===
By defining a family of algorithms (in this case, validation rules for different actions like create or update), encapsulating each one, and making them interchangeable, the strategy pattern lets the algorithm vary independently from the clients that use it. For instance, separating the validation conditions for creating and updating responses allows for flexible swapping and extension of validation logic without modifying the controller or model directly.
===Observer Pattern===
Used typically in scenarios where changes to a particular object need to notify other dependent objects automatically. In the context of this application, this could relate to notifying instructors or peers upon the submission or update of responses, handled through the helper methods for sending emails.
===Template Method===
This pattern can be used in defining the skeleton of an operation in a method, deferring some steps to subclasses or other methods. It's seen in how validate_params uses a general structure for validation but defers the specifics to methods like validate_create_conditions and validate_update_conditions.

By integrating these design patterns and principles, the refactoring aims to achieve a more robust, maintainable, and scalable system. This approach not only addresses current complexities but also lays a foundation for easier future enhancements and modifications.

== Class Diagram ==
[[File:controller_Class_diagram.png|900px]]

== Use cases ==
[[File:Use_cases_controller.png|900px]]

== Solutions/Details of Changes Made==
=== Response Model ===
Methods within the response model were refactored or introduced, including:
==== set_content ====
Redesigned to gather and prepare the required data for response objects, optimizing the interaction with associated models
==== validate_params ====
This is the original method that was 46 lines long:

[[File:Validate parameters before.png|900px]]

===This method was significantly refactored to improve parameter validation. It was split into multiple smaller, focused methods, each dedicated to handling a specific aspect of the validation process. Each new method does one thing only, which makes them easier to understand and maintain.===
* assign_map_id_from_params: Sets the map_id for the response based on the provided parameters, ensuring the correct map ID is used for both creating and updating responses.
[[File:Assign map id.png|900px]]

*set_and_validate_response_map: Establishes and validates the presence of the response_map based on map_id. It's crucial to ensure that any response being created or updated is linked to a valid response map.This method attempts to find a ResponseMap based on map_id. If it fails to find one, it records an error and halts further validation, signaling an issue early in the process.
[[File:Set and validte response.png|900px]]

*set_response_attributes(params):Assigns additional attributes to the response object from the parameters. This centralizes attribute setting, reducing redundancy and errors.Directly extracts values like round, version_num, additional_comment, and visibility from the parameters and assigns them to the response object.
[[File:Set response attributes.png|900px]]

*action_specific_validation(params, action): Directs the validation flow based on whether the action is to create or update a response, organizing the logic clearly and preventing condition sprawl in the main validation method.Calls specific validation methods based on the action type: validate_create_conditions for creation and validate_update_conditions for updates.
[[File:Action specific validation.png|900px]]

*validate_create_conditions: Ensures that a new response doesn't duplicate an existing one under the same response map, round, and version number.Searches for an existing response that matches the current map_id, round, and version_num. If such a response exists, it adds a validation error and prevents the creation of a duplicate response.
[[File:Validate create condition.png|900px]]

*validate_update_conditions(params): Ensures that updates to a response are valid, specifically checking that a response isn't already submitted and that its map_id remains unchanged.Checks the submission status and whether there's an attempt to change the map_id. If either condition is violated, it records an error.
[[File:Validate update conditions.png|900px]]

*validate_submission_status(params): Updates the submission status of the response during the update process, ensuring the attribute is correctly set based on the provided parameters.Extracts and sets the is_submitted status from the parameters, which is crucial for controlling the editability of the response.
[[File:Validate submission status .png|900px]]

==== serialize_response ====
Improved to efficiently serialize response data for API interactions, enhancing the clarity and usability of data exchanges.

=== Response Controller ===
The ResponseController, originally extensive with numerous functions beyond basic CRUD operations, has been streamlined for our API application. In this context, there's no need to manage data variables for view pages, simplifying the handling of request data solely through request methods.To enhance the architecture and efficiency of our application, we've eliminated redundant methods and consolidated functionalities across the model, controller, and helper files. This restructuring was essential for refining the response endpoints specifically tailored for an API application.

Before we added Basic CRUD like New, Create, Update, edit, destroy.

Removed Methods: Legacy methods like Questionnaire_from_response_map and Questionnaire_from_response were removed following the refactoring of set_content, which now handles its functionalities internally without the need for these methods.

==== Show_calibration_results_for_student ====
Before:

[[File:Show calibration results for student.PNG|900px]]

The old implementation also made use of database queries in the view. This will not be possible in the reimplemented Expertiza, and the required data will need to be made available in the JSON response sent by the controller.
[[File:DB access in view.PNG|900px]]
[[File:DB access in view 2.PNG|900px]]

The new show_calibration_results_for_student method retrieves and displays calibration and review responses based on provided map IDs. It fetches responses using these IDs, retrieves associated questions and answers, and returns the data as a formatted JSON object. If a response is not found, it returns an error indicating the missing response. The method handles any exceptions by returning a standard error message, ensuring robust error handling throughout the process.
Serves as an API endpoint to fetch detailed response data for a student's calibration and review tasks, providing all necessary details about the questions asked and the answers provided in both contexts

[[File:Show_calibration_results.png|900px]]

=== Response Helper ===

The method create_update_answers(response, answers) was originally handling both the creation and updating of answer records within a single method:

[[File:Create_update_answers_before.png|900px]]

To improve code maintainability and adhere to the Single Responsibility Principle, this method has been divided into two distinct methods:

==== Create_answers ====
This method focuses solely on creating new answer records. It iterates over the answers provided, checking if each answer does not already exist in the database. If the answer does not exist, it creates a new record for that answer. This ensures that each answer is unique and prevents duplication.
[[File:Create_answers_after.png|900px]]

==== Update_answers ====
This method is responsible for updating existing answer records. It searches for existing answers in the database based on the response and question identifiers. If an answer is found, it updates the existing record with the new information provided. This method ensures that all modifications to answers are captured accurately and that the database is kept up-to-date.

[[File:Update_answers_after.png|900px]]

==Files Modified/Added==
List of primary files modified or created includes:
* responses_controller.rb
* response_helper.rb
* response.rb

==Test==

===Response model test===
====Postman Tests====
Validate Parameters :

[[File:Postman_after_update.png|900px]]
[[File:DB validate parameters update test.png|900px]]

===Response model test===
====Postman Tests====

===Responses Controller test===
====Postman Tests====

==Team==
===== Mentor=====
*Ameya Vaichalkar

=====Members=====
* Jeff Riehle
* Maday Moya
* Shardul Ladekar

==Links==
Postman Video Links:
*create: https://youtu.be/hXQl-JkfuUc
*update: https://youtu.be/BeifLsCRQlk
*show_calibration_results_for_student: https://youtu.be/EWxvSC9hPtU

Pull request: https://github.com/expertiza/reimplementation-back-end/pull/92

Model Tests Video: https://youtu.be/EPoD3ai33qk

Controller Tests Video: https://youtu.be/moZrjXE-dM8

==References==

*

CSC/ECE 517 Spring 2024 - E2415. Reimplement responses controller.rb (Design Document)

2024-04-24T03:18:54Z

Jriehle: /* Links */

CSC/ECE 517 Spring 2024 - E2415: Reimplementation of responses_controller.rb (Design Document)

==Expertiza==
The Expertiza project, an open-source endeavor rooted in Ruby on Rails, embarks on continuous improvement to adapt and integrate modern software engineering practices. The Responses Controller is engineered to assist reviewers in submitting structured data that is specifically aligned with an assignment's rubrics, ensuring the provision of relevant questions for each round within the correct due date period. It enables a reviewer to evaluate and score the rubric questions pertinent to the assignment's topics. Furthermore, it ensures the delivery of appropriate questions for each assignment round, allowing reviewers to create and modify scores and comments for each of the rubric questions associated with the assignment. After reviewers submit their scored questions and comments, the Responses Controller dispatches an email notification to the instructor and the reviewed team's members.

==Problem Statement==
The ResponseController in Expertiza, a legacy system with conventions predating Rails standards, is overly complex, encompassing functionalities beyond basic CRUD operations and needing adherence to modern Rails naming and design principles. Key issues include the direct implementation of functionalities like sorting reviews and checking reviewer roles within the controller, suggesting a shift towards polymorphism and a more structured approach to code organization. Furthermore, the controller's handling of email notifications and feedback mechanisms is inconsistent, indicating the necessity for a dedicated helper to streamline communication processes. The reimplementation effort must focus on simplifying the controller, adhering to Rails conventions, and improving code readability and maintainability by appropriately distributing responsibilities.

==Design Goal==
The redesign of the `responses_controller.rb` is guided by several key objectives to improve the code quality, system behavior, and developer interaction. The goals include:

* Maintainability and Scalability: Ensuring the code is easy to understand, modify, and extend. The reimplementation should simplify future updates and feature additions.

* Adherence to Rails Best Practices: Following Rails conventions for naming, structure, and coding practices to ensure code consistency and reliability.

* DRY Principle: "Don't Repeat Yourself" - removing redundant code and logic to create a more efficient and error-resistant codebase.

* Single Responsibility Principle: Restructuring the controller and associated models so that each class and method has one purpose and one purpose only, leading to easier testing and management.

* Improved Testing and Coverage: Enhancing test suites to cover more scenarios and edge cases, increasing confidence in the application's stability and performance.

* Performance Optimization: Identifying and optimizing slow or inefficient areas in the code to ensure the application runs smoothly.

* Clean Up Dead Methods: Audit the codebase for any unused ("dead") methods within the current controller and remove them to declutter the code.

* Reduced Controller Complexity: We already have streamline the `ResponseController` to focus primarily on CRUD operations and extract non-essential logic to appropriate models or helpers, now we aim to implement the rest operations.

By meeting these design goals, the project aims to produce a `responses_controller.rb` that is robust, efficient, and a pleasure to work with, both for the current development team and for those who will maintain the system in the future.

== Design Pattern ==

During the code refactoring process, we conscientiously followed various design patterns to enhance the overall structure.
When refactoring the Response model and associated controller and helper methods in the application, several key design patterns and principles were followed to ensure improved code quality, maintainability, and scalability. Here are the primary patterns and principles that were considered:

=== Single Responsibility Principle (SRP) ===
This principle was applied to break down complex methods into smaller, more focused functions that handle a specific part of the process

*In the Response Model:
Validate_params was broken down into multiple smaller methods, each handling a specific part of the validation process. This allows each method to manage one aspect of the validation, making the code easier to maintain and modify.
Creation and management of relationships and basic attributes were clearly defined, ensuring that the Response class isn't overloaded with logic that doesn't pertain to its direct attributes or relationships.

*In the ResponsesController:
The controller methods like create, update, show, etc., were defined to handle only HTTP requests and delegate business logic to the model or helper methods. This keeps the controller actions clean and focused on routing and basic request handling.

*In the ResponseHelper:
Methods such as create_answers and update_answers are good examples where each method is tasked with either creating or updating answers but not both. This follows SRP by dividing the responsibilities into more manageable, discrete operations.

===Factory Method===
The Factory Method pattern can be seen implicitly where object creation processes are encapsulated within the model or helper methods, such as creating a new ResponseMap or generating new Answer objects. This ensures that object creation is modular and separated from the main application logic.
===Strategy Pattern===
By defining a family of algorithms (in this case, validation rules for different actions like create or update), encapsulating each one, and making them interchangeable, the strategy pattern lets the algorithm vary independently from the clients that use it. For instance, separating the validation conditions for creating and updating responses allows for flexible swapping and extension of validation logic without modifying the controller or model directly.
===Observer Pattern===
Used typically in scenarios where changes to a particular object need to notify other dependent objects automatically. In the context of this application, this could relate to notifying instructors or peers upon the submission or update of responses, handled through the helper methods for sending emails.
===Template Method===
This pattern can be used in defining the skeleton of an operation in a method, deferring some steps to subclasses or other methods. It's seen in how validate_params uses a general structure for validation but defers the specifics to methods like validate_create_conditions and validate_update_conditions.

By integrating these design patterns and principles, the refactoring aims to achieve a more robust, maintainable, and scalable system. This approach not only addresses current complexities but also lays a foundation for easier future enhancements and modifications.

== Class Diagram ==
[[File:controller_Class_diagram.png|900px]]

== Use cases ==
[[File:Use_cases_controller.png|900px]]

== Solutions/Details of Changes Made==
=== Response Model ===
Methods within the response model were refactored or introduced, including:
==== set_content ====
Redesigned to gather and prepare the required data for response objects, optimizing the interaction with associated models
==== validate_params ====
This is the original method that was 46 lines long:

[[File:Validate parameters before.png|900px]]

===This method was significantly refactored to improve parameter validation. It was split into multiple smaller, focused methods, each dedicated to handling a specific aspect of the validation process. Each new method does one thing only, which makes them easier to understand and maintain.===
* assign_map_id_from_params: Sets the map_id for the response based on the provided parameters, ensuring the correct map ID is used for both creating and updating responses.
[[File:Assign map id.png|900px]]

*set_and_validate_response_map: Establishes and validates the presence of the response_map based on map_id. It's crucial to ensure that any response being created or updated is linked to a valid response map.This method attempts to find a ResponseMap based on map_id. If it fails to find one, it records an error and halts further validation, signaling an issue early in the process.
[[File:Set and validte response.png|900px]]

*set_response_attributes(params):Assigns additional attributes to the response object from the parameters. This centralizes attribute setting, reducing redundancy and errors.Directly extracts values like round, version_num, additional_comment, and visibility from the parameters and assigns them to the response object.
[[File:Set response attributes.png|900px]]

*action_specific_validation(params, action): Directs the validation flow based on whether the action is to create or update a response, organizing the logic clearly and preventing condition sprawl in the main validation method.Calls specific validation methods based on the action type: validate_create_conditions for creation and validate_update_conditions for updates.
[[File:Action specific validation.png|900px]]

*validate_create_conditions: Ensures that a new response doesn't duplicate an existing one under the same response map, round, and version number.Searches for an existing response that matches the current map_id, round, and version_num. If such a response exists, it adds a validation error and prevents the creation of a duplicate response.
[[File:Validate create condition.png|900px]]

*validate_update_conditions(params): Ensures that updates to a response are valid, specifically checking that a response isn't already submitted and that its map_id remains unchanged.Checks the submission status and whether there's an attempt to change the map_id. If either condition is violated, it records an error.
[[File:Validate update conditions.png|900px]]

*validate_submission_status(params): Updates the submission status of the response during the update process, ensuring the attribute is correctly set based on the provided parameters.Extracts and sets the is_submitted status from the parameters, which is crucial for controlling the editability of the response.
[[File:Validate submission status .png|900px]]

==== serialize_response ====
Improved to efficiently serialize response data for API interactions, enhancing the clarity and usability of data exchanges.

=== Response Controller ===
The ResponseController, originally extensive with numerous functions beyond basic CRUD operations, has been streamlined for our API application. In this context, there's no need to manage data variables for view pages, simplifying the handling of request data solely through request methods.To enhance the architecture and efficiency of our application, we've eliminated redundant methods and consolidated functionalities across the model, controller, and helper files. This restructuring was essential for refining the response endpoints specifically tailored for an API application.

Before we added Basic CRUD like New, Create, Update, edit, destroy.

Removed Methods: Legacy methods like Questionnaire_from_response_map and Questionnaire_from_response were removed following the refactoring of set_content, which now handles its functionalities internally without the need for these methods.

==== Show_calibration_results_for_student ====
Before:

[[File:Show calibration results for student.PNG|900px]]

The old implementation also made use of database queries in the view. This will not be possible in the reimplemented Expertiza, and the required data will need to be made available in the JSON response sent by the controller.
[[File:DB access in view.PNG|900px]]
[[File:DB access in view 2.PNG|900px]]

The new show_calibration_results_for_student method retrieves and displays calibration and review responses based on provided map IDs. It fetches responses using these IDs, retrieves associated questions and answers, and returns the data as a formatted JSON object. If a response is not found, it returns an error indicating the missing response. The method handles any exceptions by returning a standard error message, ensuring robust error handling throughout the process.
Serves as an API endpoint to fetch detailed response data for a student's calibration and review tasks, providing all necessary details about the questions asked and the answers provided in both contexts

[[File:Show_calibration_results.png|900px]]

=== Response Helper ===

The method create_update_answers(response, answers) was originally handling both the creation and updating of answer records within a single method:

[[File:Create_update_answers_before.png|900px]]

To improve code maintainability and adhere to the Single Responsibility Principle, this method has been divided into two distinct methods:

==== Create_answers ====
This method focuses solely on creating new answer records. It iterates over the answers provided, checking if each answer does not already exist in the database. If the answer does not exist, it creates a new record for that answer. This ensures that each answer is unique and prevents duplication.
[[File:Create_answers_after.png|900px]]

==== Update_answers ====
This method is responsible for updating existing answer records. It searches for existing answers in the database based on the response and question identifiers. If an answer is found, it updates the existing record with the new information provided. This method ensures that all modifications to answers are captured accurately and that the database is kept up-to-date.

[[File:Update_answers_after.png|900px]]

==Files Modified/Added==
List of primary files modified or created includes:
* responses_controller.rb
* response_helper.rb
* response.rb

==Test==

The Model and Controller functions will be tested throughoughly.

Rspec unit tests will be used to test each function of the refactored and reimplemented functions to verify the expected responses are received for given inputs.

Unit tests will be written for the following model functions:

Unit tests will also be written for the controller functions:

The Swagger UI will be utilized to make the controller functions accessible VIA API calls. This will allow for testing of the input and outputs of the API calls to the methods, and will function as integration tests.

==Team==
===== Mentor=====
*Ameya Vaichalkar

=====Members=====
* Jeff Riehle
* Maday Moya
* Shardul Ladekar

==Links==
Postman Video Links:
*create: https://youtu.be/hXQl-JkfuUc
*update: https://youtu.be/BeifLsCRQlk

Pull request: https://github.com/expertiza/reimplementation-back-end/pull/92

Model Tests Video: https://youtu.be/EPoD3ai33qk

Controller Tests Video: https://youtu.be/moZrjXE-dM8

==References==

*

CSC/ECE 517 Spring 2024 - E2415. Reimplement responses controller.rb (Design Document)

2024-04-24T03:14:47Z

Jriehle: /* Links */

CSC/ECE 517 Spring 2024 - E2415: Reimplementation of responses_controller.rb (Design Document)

==Expertiza==
The Expertiza project, an open-source endeavor rooted in Ruby on Rails, embarks on continuous improvement to adapt and integrate modern software engineering practices. The Responses Controller is engineered to assist reviewers in submitting structured data that is specifically aligned with an assignment's rubrics, ensuring the provision of relevant questions for each round within the correct due date period. It enables a reviewer to evaluate and score the rubric questions pertinent to the assignment's topics. Furthermore, it ensures the delivery of appropriate questions for each assignment round, allowing reviewers to create and modify scores and comments for each of the rubric questions associated with the assignment. After reviewers submit their scored questions and comments, the Responses Controller dispatches an email notification to the instructor and the reviewed team's members.

==Problem Statement==
The ResponseController in Expertiza, a legacy system with conventions predating Rails standards, is overly complex, encompassing functionalities beyond basic CRUD operations and needing adherence to modern Rails naming and design principles. Key issues include the direct implementation of functionalities like sorting reviews and checking reviewer roles within the controller, suggesting a shift towards polymorphism and a more structured approach to code organization. Furthermore, the controller's handling of email notifications and feedback mechanisms is inconsistent, indicating the necessity for a dedicated helper to streamline communication processes. The reimplementation effort must focus on simplifying the controller, adhering to Rails conventions, and improving code readability and maintainability by appropriately distributing responsibilities.

==Design Goal==
The redesign of the `responses_controller.rb` is guided by several key objectives to improve the code quality, system behavior, and developer interaction. The goals include:

* Maintainability and Scalability: Ensuring the code is easy to understand, modify, and extend. The reimplementation should simplify future updates and feature additions.

* Adherence to Rails Best Practices: Following Rails conventions for naming, structure, and coding practices to ensure code consistency and reliability.

* DRY Principle: "Don't Repeat Yourself" - removing redundant code and logic to create a more efficient and error-resistant codebase.

* Single Responsibility Principle: Restructuring the controller and associated models so that each class and method has one purpose and one purpose only, leading to easier testing and management.

* Improved Testing and Coverage: Enhancing test suites to cover more scenarios and edge cases, increasing confidence in the application's stability and performance.

* Performance Optimization: Identifying and optimizing slow or inefficient areas in the code to ensure the application runs smoothly.

* Clean Up Dead Methods: Audit the codebase for any unused ("dead") methods within the current controller and remove them to declutter the code.

* Reduced Controller Complexity: We already have streamline the `ResponseController` to focus primarily on CRUD operations and extract non-essential logic to appropriate models or helpers, now we aim to implement the rest operations.

By meeting these design goals, the project aims to produce a `responses_controller.rb` that is robust, efficient, and a pleasure to work with, both for the current development team and for those who will maintain the system in the future.

== Design Pattern ==

During the code refactoring process, we conscientiously followed various design patterns to enhance the overall structure.
When refactoring the Response model and associated controller and helper methods in the application, several key design patterns and principles were followed to ensure improved code quality, maintainability, and scalability. Here are the primary patterns and principles that were considered:

=== Single Responsibility Principle (SRP) ===
This principle was applied to break down complex methods into smaller, more focused functions that handle a specific part of the process

*In the Response Model:
Validate_params was broken down into multiple smaller methods, each handling a specific part of the validation process. This allows each method to manage one aspect of the validation, making the code easier to maintain and modify.
Creation and management of relationships and basic attributes were clearly defined, ensuring that the Response class isn't overloaded with logic that doesn't pertain to its direct attributes or relationships.

*In the ResponsesController:
The controller methods like create, update, show, etc., were defined to handle only HTTP requests and delegate business logic to the model or helper methods. This keeps the controller actions clean and focused on routing and basic request handling.

*In the ResponseHelper:
Methods such as create_answers and update_answers are good examples where each method is tasked with either creating or updating answers but not both. This follows SRP by dividing the responsibilities into more manageable, discrete operations.

===Factory Method===
The Factory Method pattern can be seen implicitly where object creation processes are encapsulated within the model or helper methods, such as creating a new ResponseMap or generating new Answer objects. This ensures that object creation is modular and separated from the main application logic.
===Strategy Pattern===
By defining a family of algorithms (in this case, validation rules for different actions like create or update), encapsulating each one, and making them interchangeable, the strategy pattern lets the algorithm vary independently from the clients that use it. For instance, separating the validation conditions for creating and updating responses allows for flexible swapping and extension of validation logic without modifying the controller or model directly.
===Observer Pattern===
Used typically in scenarios where changes to a particular object need to notify other dependent objects automatically. In the context of this application, this could relate to notifying instructors or peers upon the submission or update of responses, handled through the helper methods for sending emails.
===Template Method===
This pattern can be used in defining the skeleton of an operation in a method, deferring some steps to subclasses or other methods. It's seen in how validate_params uses a general structure for validation but defers the specifics to methods like validate_create_conditions and validate_update_conditions.

By integrating these design patterns and principles, the refactoring aims to achieve a more robust, maintainable, and scalable system. This approach not only addresses current complexities but also lays a foundation for easier future enhancements and modifications.

== Class Diagram ==
[[File:controller_Class_diagram.png|900px]]

== Use cases ==
[[File:Use_cases_controller.png|900px]]

== Solutions/Details of Changes Made==
=== Response Model ===
Methods within the response model were refactored or introduced, including:
==== set_content ====
Redesigned to gather and prepare the required data for response objects, optimizing the interaction with associated models
==== validate_params ====
This is the original method that was 46 lines long:

[[File:Validate parameters before.png|900px]]

===This method was significantly refactored to improve parameter validation. It was split into multiple smaller, focused methods, each dedicated to handling a specific aspect of the validation process. Each new method does one thing only, which makes them easier to understand and maintain.===
* assign_map_id_from_params: Sets the map_id for the response based on the provided parameters, ensuring the correct map ID is used for both creating and updating responses.
[[File:Assign map id.png|900px]]

*set_and_validate_response_map: Establishes and validates the presence of the response_map based on map_id. It's crucial to ensure that any response being created or updated is linked to a valid response map.This method attempts to find a ResponseMap based on map_id. If it fails to find one, it records an error and halts further validation, signaling an issue early in the process.
[[File:Set and validte response.png|900px]]

*set_response_attributes(params):Assigns additional attributes to the response object from the parameters. This centralizes attribute setting, reducing redundancy and errors.Directly extracts values like round, version_num, additional_comment, and visibility from the parameters and assigns them to the response object.
[[File:Set response attributes.png|900px]]

*action_specific_validation(params, action): Directs the validation flow based on whether the action is to create or update a response, organizing the logic clearly and preventing condition sprawl in the main validation method.Calls specific validation methods based on the action type: validate_create_conditions for creation and validate_update_conditions for updates.
[[File:Action specific validation.png|900px]]

*validate_create_conditions: Ensures that a new response doesn't duplicate an existing one under the same response map, round, and version number.Searches for an existing response that matches the current map_id, round, and version_num. If such a response exists, it adds a validation error and prevents the creation of a duplicate response.
[[File:Validate create condition.png|900px]]

*validate_update_conditions(params): Ensures that updates to a response are valid, specifically checking that a response isn't already submitted and that its map_id remains unchanged.Checks the submission status and whether there's an attempt to change the map_id. If either condition is violated, it records an error.
[[File:Validate update conditions.png|900px]]

*validate_submission_status(params): Updates the submission status of the response during the update process, ensuring the attribute is correctly set based on the provided parameters.Extracts and sets the is_submitted status from the parameters, which is crucial for controlling the editability of the response.
[[File:Validate submission status .png|900px]]

==== serialize_response ====
Improved to efficiently serialize response data for API interactions, enhancing the clarity and usability of data exchanges.

=== Response Controller ===
The ResponseController, originally extensive with numerous functions beyond basic CRUD operations, has been streamlined for our API application. In this context, there's no need to manage data variables for view pages, simplifying the handling of request data solely through request methods.To enhance the architecture and efficiency of our application, we've eliminated redundant methods and consolidated functionalities across the model, controller, and helper files. This restructuring was essential for refining the response endpoints specifically tailored for an API application.

Before we added Basic CRUD like New, Create, Update, edit, destroy.

Removed Methods: Legacy methods like Questionnaire_from_response_map and Questionnaire_from_response were removed following the refactoring of set_content, which now handles its functionalities internally without the need for these methods.

==== Show_calibration_results_for_student ====
Before:

[[File:Show calibration results for student.PNG|900px]]

The old implementation also made use of database queries in the view. This will not be possible in the reimplemented Expertiza, and the required data will need to be made available in the JSON response sent by the controller.
[[File:DB access in view.PNG|900px]]
[[File:DB access in view 2.PNG|900px]]

The new show_calibration_results_for_student method retrieves and displays calibration and review responses based on provided map IDs. It fetches responses using these IDs, retrieves associated questions and answers, and returns the data as a formatted JSON object. If a response is not found, it returns an error indicating the missing response. The method handles any exceptions by returning a standard error message, ensuring robust error handling throughout the process.
Serves as an API endpoint to fetch detailed response data for a student's calibration and review tasks, providing all necessary details about the questions asked and the answers provided in both contexts

[[File:Show_calibration_results.png|900px]]

=== Response Helper ===

The method create_update_answers(response, answers) was originally handling both the creation and updating of answer records within a single method:

[[File:Create_update_answers_before.png|900px]]

To improve code maintainability and adhere to the Single Responsibility Principle, this method has been divided into two distinct methods:

==== Create_answers ====
This method focuses solely on creating new answer records. It iterates over the answers provided, checking if each answer does not already exist in the database. If the answer does not exist, it creates a new record for that answer. This ensures that each answer is unique and prevents duplication.
[[File:Create_answers_after.png|900px]]

==== Update_answers ====
This method is responsible for updating existing answer records. It searches for existing answers in the database based on the response and question identifiers. If an answer is found, it updates the existing record with the new information provided. This method ensures that all modifications to answers are captured accurately and that the database is kept up-to-date.

[[File:Update_answers_after.png|900px]]

==Files Modified/Added==
List of primary files modified or created includes:
* responses_controller.rb
* response_helper.rb
* response.rb

==Test==

The Model and Controller functions will be tested throughoughly.

Rspec unit tests will be used to test each function of the refactored and reimplemented functions to verify the expected responses are received for given inputs.

Unit tests will be written for the following model functions:

Unit tests will also be written for the controller functions:

The Swagger UI will be utilized to make the controller functions accessible VIA API calls. This will allow for testing of the input and outputs of the API calls to the methods, and will function as integration tests.

==Team==
===== Mentor=====
*Ameya Vaichalkar

=====Members=====
* Jeff Riehle
* Maday Moya
* Shardul Ladekar

==Links==
Postman Video Links:
*create: https://youtu.be/hXQl-JkfuUc

Pull request: https://github.com/expertiza/reimplementation-back-end/pull/92

Model Tests Video: https://youtu.be/EPoD3ai33qk

Controller Tests Video: https://youtu.be/moZrjXE-dM8

==References==

*

CSC/ECE 517 Spring 2024 - E2415. Reimplement responses controller.rb (Design Document)

2024-04-24T03:14:33Z

Jriehle: /* Links */

CSC/ECE 517 Spring 2024 - E2415: Reimplementation of responses_controller.rb (Design Document)

==Expertiza==
The Expertiza project, an open-source endeavor rooted in Ruby on Rails, embarks on continuous improvement to adapt and integrate modern software engineering practices. The Responses Controller is engineered to assist reviewers in submitting structured data that is specifically aligned with an assignment's rubrics, ensuring the provision of relevant questions for each round within the correct due date period. It enables a reviewer to evaluate and score the rubric questions pertinent to the assignment's topics. Furthermore, it ensures the delivery of appropriate questions for each assignment round, allowing reviewers to create and modify scores and comments for each of the rubric questions associated with the assignment. After reviewers submit their scored questions and comments, the Responses Controller dispatches an email notification to the instructor and the reviewed team's members.

==Problem Statement==
The ResponseController in Expertiza, a legacy system with conventions predating Rails standards, is overly complex, encompassing functionalities beyond basic CRUD operations and needing adherence to modern Rails naming and design principles. Key issues include the direct implementation of functionalities like sorting reviews and checking reviewer roles within the controller, suggesting a shift towards polymorphism and a more structured approach to code organization. Furthermore, the controller's handling of email notifications and feedback mechanisms is inconsistent, indicating the necessity for a dedicated helper to streamline communication processes. The reimplementation effort must focus on simplifying the controller, adhering to Rails conventions, and improving code readability and maintainability by appropriately distributing responsibilities.

==Design Goal==
The redesign of the `responses_controller.rb` is guided by several key objectives to improve the code quality, system behavior, and developer interaction. The goals include:

* Maintainability and Scalability: Ensuring the code is easy to understand, modify, and extend. The reimplementation should simplify future updates and feature additions.

* Adherence to Rails Best Practices: Following Rails conventions for naming, structure, and coding practices to ensure code consistency and reliability.

* DRY Principle: "Don't Repeat Yourself" - removing redundant code and logic to create a more efficient and error-resistant codebase.

* Single Responsibility Principle: Restructuring the controller and associated models so that each class and method has one purpose and one purpose only, leading to easier testing and management.

* Improved Testing and Coverage: Enhancing test suites to cover more scenarios and edge cases, increasing confidence in the application's stability and performance.

* Performance Optimization: Identifying and optimizing slow or inefficient areas in the code to ensure the application runs smoothly.

* Clean Up Dead Methods: Audit the codebase for any unused ("dead") methods within the current controller and remove them to declutter the code.

* Reduced Controller Complexity: We already have streamline the `ResponseController` to focus primarily on CRUD operations and extract non-essential logic to appropriate models or helpers, now we aim to implement the rest operations.

By meeting these design goals, the project aims to produce a `responses_controller.rb` that is robust, efficient, and a pleasure to work with, both for the current development team and for those who will maintain the system in the future.

== Design Pattern ==

During the code refactoring process, we conscientiously followed various design patterns to enhance the overall structure.
When refactoring the Response model and associated controller and helper methods in the application, several key design patterns and principles were followed to ensure improved code quality, maintainability, and scalability. Here are the primary patterns and principles that were considered:

=== Single Responsibility Principle (SRP) ===
This principle was applied to break down complex methods into smaller, more focused functions that handle a specific part of the process

*In the Response Model:
Validate_params was broken down into multiple smaller methods, each handling a specific part of the validation process. This allows each method to manage one aspect of the validation, making the code easier to maintain and modify.
Creation and management of relationships and basic attributes were clearly defined, ensuring that the Response class isn't overloaded with logic that doesn't pertain to its direct attributes or relationships.

*In the ResponsesController:
The controller methods like create, update, show, etc., were defined to handle only HTTP requests and delegate business logic to the model or helper methods. This keeps the controller actions clean and focused on routing and basic request handling.

*In the ResponseHelper:
Methods such as create_answers and update_answers are good examples where each method is tasked with either creating or updating answers but not both. This follows SRP by dividing the responsibilities into more manageable, discrete operations.

===Factory Method===
The Factory Method pattern can be seen implicitly where object creation processes are encapsulated within the model or helper methods, such as creating a new ResponseMap or generating new Answer objects. This ensures that object creation is modular and separated from the main application logic.
===Strategy Pattern===
By defining a family of algorithms (in this case, validation rules for different actions like create or update), encapsulating each one, and making them interchangeable, the strategy pattern lets the algorithm vary independently from the clients that use it. For instance, separating the validation conditions for creating and updating responses allows for flexible swapping and extension of validation logic without modifying the controller or model directly.
===Observer Pattern===
Used typically in scenarios where changes to a particular object need to notify other dependent objects automatically. In the context of this application, this could relate to notifying instructors or peers upon the submission or update of responses, handled through the helper methods for sending emails.
===Template Method===
This pattern can be used in defining the skeleton of an operation in a method, deferring some steps to subclasses or other methods. It's seen in how validate_params uses a general structure for validation but defers the specifics to methods like validate_create_conditions and validate_update_conditions.

By integrating these design patterns and principles, the refactoring aims to achieve a more robust, maintainable, and scalable system. This approach not only addresses current complexities but also lays a foundation for easier future enhancements and modifications.

== Class Diagram ==
[[File:controller_Class_diagram.png|900px]]

== Use cases ==
[[File:Use_cases_controller.png|900px]]

== Solutions/Details of Changes Made==
=== Response Model ===
Methods within the response model were refactored or introduced, including:
==== set_content ====
Redesigned to gather and prepare the required data for response objects, optimizing the interaction with associated models
==== validate_params ====
This is the original method that was 46 lines long:

[[File:Validate parameters before.png|900px]]

===This method was significantly refactored to improve parameter validation. It was split into multiple smaller, focused methods, each dedicated to handling a specific aspect of the validation process. Each new method does one thing only, which makes them easier to understand and maintain.===
* assign_map_id_from_params: Sets the map_id for the response based on the provided parameters, ensuring the correct map ID is used for both creating and updating responses.
[[File:Assign map id.png|900px]]

*set_and_validate_response_map: Establishes and validates the presence of the response_map based on map_id. It's crucial to ensure that any response being created or updated is linked to a valid response map.This method attempts to find a ResponseMap based on map_id. If it fails to find one, it records an error and halts further validation, signaling an issue early in the process.
[[File:Set and validte response.png|900px]]

*set_response_attributes(params):Assigns additional attributes to the response object from the parameters. This centralizes attribute setting, reducing redundancy and errors.Directly extracts values like round, version_num, additional_comment, and visibility from the parameters and assigns them to the response object.
[[File:Set response attributes.png|900px]]

*action_specific_validation(params, action): Directs the validation flow based on whether the action is to create or update a response, organizing the logic clearly and preventing condition sprawl in the main validation method.Calls specific validation methods based on the action type: validate_create_conditions for creation and validate_update_conditions for updates.
[[File:Action specific validation.png|900px]]

*validate_create_conditions: Ensures that a new response doesn't duplicate an existing one under the same response map, round, and version number.Searches for an existing response that matches the current map_id, round, and version_num. If such a response exists, it adds a validation error and prevents the creation of a duplicate response.
[[File:Validate create condition.png|900px]]

*validate_update_conditions(params): Ensures that updates to a response are valid, specifically checking that a response isn't already submitted and that its map_id remains unchanged.Checks the submission status and whether there's an attempt to change the map_id. If either condition is violated, it records an error.
[[File:Validate update conditions.png|900px]]

*validate_submission_status(params): Updates the submission status of the response during the update process, ensuring the attribute is correctly set based on the provided parameters.Extracts and sets the is_submitted status from the parameters, which is crucial for controlling the editability of the response.
[[File:Validate submission status .png|900px]]

==== serialize_response ====
Improved to efficiently serialize response data for API interactions, enhancing the clarity and usability of data exchanges.

=== Response Controller ===
The ResponseController, originally extensive with numerous functions beyond basic CRUD operations, has been streamlined for our API application. In this context, there's no need to manage data variables for view pages, simplifying the handling of request data solely through request methods.To enhance the architecture and efficiency of our application, we've eliminated redundant methods and consolidated functionalities across the model, controller, and helper files. This restructuring was essential for refining the response endpoints specifically tailored for an API application.

Before we added Basic CRUD like New, Create, Update, edit, destroy.

Removed Methods: Legacy methods like Questionnaire_from_response_map and Questionnaire_from_response were removed following the refactoring of set_content, which now handles its functionalities internally without the need for these methods.

==== Show_calibration_results_for_student ====
Before:

[[File:Show calibration results for student.PNG|900px]]

The old implementation also made use of database queries in the view. This will not be possible in the reimplemented Expertiza, and the required data will need to be made available in the JSON response sent by the controller.
[[File:DB access in view.PNG|900px]]
[[File:DB access in view 2.PNG|900px]]

The new show_calibration_results_for_student method retrieves and displays calibration and review responses based on provided map IDs. It fetches responses using these IDs, retrieves associated questions and answers, and returns the data as a formatted JSON object. If a response is not found, it returns an error indicating the missing response. The method handles any exceptions by returning a standard error message, ensuring robust error handling throughout the process.
Serves as an API endpoint to fetch detailed response data for a student's calibration and review tasks, providing all necessary details about the questions asked and the answers provided in both contexts

[[File:Show_calibration_results.png|900px]]

=== Response Helper ===

The method create_update_answers(response, answers) was originally handling both the creation and updating of answer records within a single method:

[[File:Create_update_answers_before.png|900px]]

To improve code maintainability and adhere to the Single Responsibility Principle, this method has been divided into two distinct methods:

==== Create_answers ====
This method focuses solely on creating new answer records. It iterates over the answers provided, checking if each answer does not already exist in the database. If the answer does not exist, it creates a new record for that answer. This ensures that each answer is unique and prevents duplication.
[[File:Create_answers_after.png|900px]]

==== Update_answers ====
This method is responsible for updating existing answer records. It searches for existing answers in the database based on the response and question identifiers. If an answer is found, it updates the existing record with the new information provided. This method ensures that all modifications to answers are captured accurately and that the database is kept up-to-date.

[[File:Update_answers_after.png|900px]]

==Files Modified/Added==
List of primary files modified or created includes:
* responses_controller.rb
* response_helper.rb
* response.rb

==Test==

The Model and Controller functions will be tested throughoughly.

Rspec unit tests will be used to test each function of the refactored and reimplemented functions to verify the expected responses are received for given inputs.

Unit tests will be written for the following model functions:

Unit tests will also be written for the controller functions:

The Swagger UI will be utilized to make the controller functions accessible VIA API calls. This will allow for testing of the input and outputs of the API calls to the methods, and will function as integration tests.

==Team==
===== Mentor=====
*Ameya Vaichalkar

=====Members=====
* Jeff Riehle
* Maday Moya
* Shardul Ladekar

==Links==
Postman Video Links:
create: https://youtu.be/hXQl-JkfuUc

Pull request: https://github.com/expertiza/reimplementation-back-end/pull/92

Model Tests Video: https://youtu.be/EPoD3ai33qk

Controller Tests Video: https://youtu.be/moZrjXE-dM8

==References==

*

CSC/ECE 517 Spring 2024 - E2415. Reimplement responses controller.rb (Design Document)

2024-04-24T03:14:26Z

Jriehle: /* Links */

CSC/ECE 517 Spring 2024 - E2415: Reimplementation of responses_controller.rb (Design Document)

==Expertiza==
The Expertiza project, an open-source endeavor rooted in Ruby on Rails, embarks on continuous improvement to adapt and integrate modern software engineering practices. The Responses Controller is engineered to assist reviewers in submitting structured data that is specifically aligned with an assignment's rubrics, ensuring the provision of relevant questions for each round within the correct due date period. It enables a reviewer to evaluate and score the rubric questions pertinent to the assignment's topics. Furthermore, it ensures the delivery of appropriate questions for each assignment round, allowing reviewers to create and modify scores and comments for each of the rubric questions associated with the assignment. After reviewers submit their scored questions and comments, the Responses Controller dispatches an email notification to the instructor and the reviewed team's members.

==Problem Statement==
The ResponseController in Expertiza, a legacy system with conventions predating Rails standards, is overly complex, encompassing functionalities beyond basic CRUD operations and needing adherence to modern Rails naming and design principles. Key issues include the direct implementation of functionalities like sorting reviews and checking reviewer roles within the controller, suggesting a shift towards polymorphism and a more structured approach to code organization. Furthermore, the controller's handling of email notifications and feedback mechanisms is inconsistent, indicating the necessity for a dedicated helper to streamline communication processes. The reimplementation effort must focus on simplifying the controller, adhering to Rails conventions, and improving code readability and maintainability by appropriately distributing responsibilities.

==Design Goal==
The redesign of the `responses_controller.rb` is guided by several key objectives to improve the code quality, system behavior, and developer interaction. The goals include:

* Maintainability and Scalability: Ensuring the code is easy to understand, modify, and extend. The reimplementation should simplify future updates and feature additions.

* Adherence to Rails Best Practices: Following Rails conventions for naming, structure, and coding practices to ensure code consistency and reliability.

* DRY Principle: "Don't Repeat Yourself" - removing redundant code and logic to create a more efficient and error-resistant codebase.

* Single Responsibility Principle: Restructuring the controller and associated models so that each class and method has one purpose and one purpose only, leading to easier testing and management.

* Improved Testing and Coverage: Enhancing test suites to cover more scenarios and edge cases, increasing confidence in the application's stability and performance.

* Performance Optimization: Identifying and optimizing slow or inefficient areas in the code to ensure the application runs smoothly.

* Clean Up Dead Methods: Audit the codebase for any unused ("dead") methods within the current controller and remove them to declutter the code.

* Reduced Controller Complexity: We already have streamline the `ResponseController` to focus primarily on CRUD operations and extract non-essential logic to appropriate models or helpers, now we aim to implement the rest operations.

By meeting these design goals, the project aims to produce a `responses_controller.rb` that is robust, efficient, and a pleasure to work with, both for the current development team and for those who will maintain the system in the future.

== Design Pattern ==

During the code refactoring process, we conscientiously followed various design patterns to enhance the overall structure.
When refactoring the Response model and associated controller and helper methods in the application, several key design patterns and principles were followed to ensure improved code quality, maintainability, and scalability. Here are the primary patterns and principles that were considered:

=== Single Responsibility Principle (SRP) ===
This principle was applied to break down complex methods into smaller, more focused functions that handle a specific part of the process

*In the Response Model:
Validate_params was broken down into multiple smaller methods, each handling a specific part of the validation process. This allows each method to manage one aspect of the validation, making the code easier to maintain and modify.
Creation and management of relationships and basic attributes were clearly defined, ensuring that the Response class isn't overloaded with logic that doesn't pertain to its direct attributes or relationships.

*In the ResponsesController:
The controller methods like create, update, show, etc., were defined to handle only HTTP requests and delegate business logic to the model or helper methods. This keeps the controller actions clean and focused on routing and basic request handling.

*In the ResponseHelper:
Methods such as create_answers and update_answers are good examples where each method is tasked with either creating or updating answers but not both. This follows SRP by dividing the responsibilities into more manageable, discrete operations.

===Factory Method===
The Factory Method pattern can be seen implicitly where object creation processes are encapsulated within the model or helper methods, such as creating a new ResponseMap or generating new Answer objects. This ensures that object creation is modular and separated from the main application logic.
===Strategy Pattern===
By defining a family of algorithms (in this case, validation rules for different actions like create or update), encapsulating each one, and making them interchangeable, the strategy pattern lets the algorithm vary independently from the clients that use it. For instance, separating the validation conditions for creating and updating responses allows for flexible swapping and extension of validation logic without modifying the controller or model directly.
===Observer Pattern===
Used typically in scenarios where changes to a particular object need to notify other dependent objects automatically. In the context of this application, this could relate to notifying instructors or peers upon the submission or update of responses, handled through the helper methods for sending emails.
===Template Method===
This pattern can be used in defining the skeleton of an operation in a method, deferring some steps to subclasses or other methods. It's seen in how validate_params uses a general structure for validation but defers the specifics to methods like validate_create_conditions and validate_update_conditions.

By integrating these design patterns and principles, the refactoring aims to achieve a more robust, maintainable, and scalable system. This approach not only addresses current complexities but also lays a foundation for easier future enhancements and modifications.

== Class Diagram ==
[[File:controller_Class_diagram.png|900px]]

== Use cases ==
[[File:Use_cases_controller.png|900px]]

== Solutions/Details of Changes Made==
=== Response Model ===
Methods within the response model were refactored or introduced, including:
==== set_content ====
Redesigned to gather and prepare the required data for response objects, optimizing the interaction with associated models
==== validate_params ====
This is the original method that was 46 lines long:

[[File:Validate parameters before.png|900px]]

===This method was significantly refactored to improve parameter validation. It was split into multiple smaller, focused methods, each dedicated to handling a specific aspect of the validation process. Each new method does one thing only, which makes them easier to understand and maintain.===
* assign_map_id_from_params: Sets the map_id for the response based on the provided parameters, ensuring the correct map ID is used for both creating and updating responses.
[[File:Assign map id.png|900px]]

*set_and_validate_response_map: Establishes and validates the presence of the response_map based on map_id. It's crucial to ensure that any response being created or updated is linked to a valid response map.This method attempts to find a ResponseMap based on map_id. If it fails to find one, it records an error and halts further validation, signaling an issue early in the process.
[[File:Set and validte response.png|900px]]

*set_response_attributes(params):Assigns additional attributes to the response object from the parameters. This centralizes attribute setting, reducing redundancy and errors.Directly extracts values like round, version_num, additional_comment, and visibility from the parameters and assigns them to the response object.
[[File:Set response attributes.png|900px]]

*action_specific_validation(params, action): Directs the validation flow based on whether the action is to create or update a response, organizing the logic clearly and preventing condition sprawl in the main validation method.Calls specific validation methods based on the action type: validate_create_conditions for creation and validate_update_conditions for updates.
[[File:Action specific validation.png|900px]]

*validate_create_conditions: Ensures that a new response doesn't duplicate an existing one under the same response map, round, and version number.Searches for an existing response that matches the current map_id, round, and version_num. If such a response exists, it adds a validation error and prevents the creation of a duplicate response.
[[File:Validate create condition.png|900px]]

*validate_update_conditions(params): Ensures that updates to a response are valid, specifically checking that a response isn't already submitted and that its map_id remains unchanged.Checks the submission status and whether there's an attempt to change the map_id. If either condition is violated, it records an error.
[[File:Validate update conditions.png|900px]]

*validate_submission_status(params): Updates the submission status of the response during the update process, ensuring the attribute is correctly set based on the provided parameters.Extracts and sets the is_submitted status from the parameters, which is crucial for controlling the editability of the response.
[[File:Validate submission status .png|900px]]

==== serialize_response ====
Improved to efficiently serialize response data for API interactions, enhancing the clarity and usability of data exchanges.

=== Response Controller ===
The ResponseController, originally extensive with numerous functions beyond basic CRUD operations, has been streamlined for our API application. In this context, there's no need to manage data variables for view pages, simplifying the handling of request data solely through request methods.To enhance the architecture and efficiency of our application, we've eliminated redundant methods and consolidated functionalities across the model, controller, and helper files. This restructuring was essential for refining the response endpoints specifically tailored for an API application.

Before we added Basic CRUD like New, Create, Update, edit, destroy.

Removed Methods: Legacy methods like Questionnaire_from_response_map and Questionnaire_from_response were removed following the refactoring of set_content, which now handles its functionalities internally without the need for these methods.

==== Show_calibration_results_for_student ====
Before:

[[File:Show calibration results for student.PNG|900px]]

The old implementation also made use of database queries in the view. This will not be possible in the reimplemented Expertiza, and the required data will need to be made available in the JSON response sent by the controller.
[[File:DB access in view.PNG|900px]]
[[File:DB access in view 2.PNG|900px]]

The new show_calibration_results_for_student method retrieves and displays calibration and review responses based on provided map IDs. It fetches responses using these IDs, retrieves associated questions and answers, and returns the data as a formatted JSON object. If a response is not found, it returns an error indicating the missing response. The method handles any exceptions by returning a standard error message, ensuring robust error handling throughout the process.
Serves as an API endpoint to fetch detailed response data for a student's calibration and review tasks, providing all necessary details about the questions asked and the answers provided in both contexts

[[File:Show_calibration_results.png|900px]]

=== Response Helper ===

The method create_update_answers(response, answers) was originally handling both the creation and updating of answer records within a single method:

[[File:Create_update_answers_before.png|900px]]

To improve code maintainability and adhere to the Single Responsibility Principle, this method has been divided into two distinct methods:

==== Create_answers ====
This method focuses solely on creating new answer records. It iterates over the answers provided, checking if each answer does not already exist in the database. If the answer does not exist, it creates a new record for that answer. This ensures that each answer is unique and prevents duplication.
[[File:Create_answers_after.png|900px]]

==== Update_answers ====
This method is responsible for updating existing answer records. It searches for existing answers in the database based on the response and question identifiers. If an answer is found, it updates the existing record with the new information provided. This method ensures that all modifications to answers are captured accurately and that the database is kept up-to-date.

[[File:Update_answers_after.png|900px]]

==Files Modified/Added==
List of primary files modified or created includes:
* responses_controller.rb
* response_helper.rb
* response.rb

==Test==

The Model and Controller functions will be tested throughoughly.

Rspec unit tests will be used to test each function of the refactored and reimplemented functions to verify the expected responses are received for given inputs.

Unit tests will be written for the following model functions:

Unit tests will also be written for the controller functions:

The Swagger UI will be utilized to make the controller functions accessible VIA API calls. This will allow for testing of the input and outputs of the API calls to the methods, and will function as integration tests.

==Team==
===== Mentor=====
*Ameya Vaichalkar

=====Members=====
* Jeff Riehle
* Maday Moya
* Shardul Ladekar

==Links==
Postman Video Links:
create: https://youtu.be/hXQl-JkfuUc

Pull request: https://github.com/expertiza/reimplementation-back-end/pull/92

Model Tests Video: https://youtu.be/EPoD3ai33qk

Controller Tests Video: https://youtu.be/moZrjXE-dM8

==References==

*

CSC/ECE 517 Spring 2024 - E2415. Reimplement responses controller.rb (Design Document)

2024-04-24T03:09:00Z

Jriehle: /* Solutions/Details of Changes Made */

CSC/ECE 517 Spring 2024 - E2415: Reimplementation of responses_controller.rb (Design Document)

==Expertiza==
The Expertiza project, an open-source endeavor rooted in Ruby on Rails, embarks on continuous improvement to adapt and integrate modern software engineering practices. The Responses Controller is engineered to assist reviewers in submitting structured data that is specifically aligned with an assignment's rubrics, ensuring the provision of relevant questions for each round within the correct due date period. It enables a reviewer to evaluate and score the rubric questions pertinent to the assignment's topics. Furthermore, it ensures the delivery of appropriate questions for each assignment round, allowing reviewers to create and modify scores and comments for each of the rubric questions associated with the assignment. After reviewers submit their scored questions and comments, the Responses Controller dispatches an email notification to the instructor and the reviewed team's members.

==Problem Statement==
The ResponseController in Expertiza, a legacy system with conventions predating Rails standards, is overly complex, encompassing functionalities beyond basic CRUD operations and needing adherence to modern Rails naming and design principles. Key issues include the direct implementation of functionalities like sorting reviews and checking reviewer roles within the controller, suggesting a shift towards polymorphism and a more structured approach to code organization. Furthermore, the controller's handling of email notifications and feedback mechanisms is inconsistent, indicating the necessity for a dedicated helper to streamline communication processes. The reimplementation effort must focus on simplifying the controller, adhering to Rails conventions, and improving code readability and maintainability by appropriately distributing responsibilities.

==Design Goal==
The redesign of the `responses_controller.rb` is guided by several key objectives to improve the code quality, system behavior, and developer interaction. The goals include:

* Maintainability and Scalability: Ensuring the code is easy to understand, modify, and extend. The reimplementation should simplify future updates and feature additions.

* Adherence to Rails Best Practices: Following Rails conventions for naming, structure, and coding practices to ensure code consistency and reliability.

* DRY Principle: "Don't Repeat Yourself" - removing redundant code and logic to create a more efficient and error-resistant codebase.

* Single Responsibility Principle: Restructuring the controller and associated models so that each class and method has one purpose and one purpose only, leading to easier testing and management.

* Improved Testing and Coverage: Enhancing test suites to cover more scenarios and edge cases, increasing confidence in the application's stability and performance.

* Performance Optimization: Identifying and optimizing slow or inefficient areas in the code to ensure the application runs smoothly.

* Clean Up Dead Methods: Audit the codebase for any unused ("dead") methods within the current controller and remove them to declutter the code.

* Reduced Controller Complexity: We already have streamline the `ResponseController` to focus primarily on CRUD operations and extract non-essential logic to appropriate models or helpers, now we aim to implement the rest operations.

By meeting these design goals, the project aims to produce a `responses_controller.rb` that is robust, efficient, and a pleasure to work with, both for the current development team and for those who will maintain the system in the future.

== Design Pattern ==

During the code refactoring process, we conscientiously followed various design patterns to enhance the overall structure.
When refactoring the Response model and associated controller and helper methods in the application, several key design patterns and principles were followed to ensure improved code quality, maintainability, and scalability. Here are the primary patterns and principles that were considered:

=== Single Responsibility Principle (SRP) ===
This principle was applied to break down complex methods into smaller, more focused functions that handle a specific part of the process

*In the Response Model:
Validate_params was broken down into multiple smaller methods, each handling a specific part of the validation process. This allows each method to manage one aspect of the validation, making the code easier to maintain and modify.
Creation and management of relationships and basic attributes were clearly defined, ensuring that the Response class isn't overloaded with logic that doesn't pertain to its direct attributes or relationships.

*In the ResponsesController:
The controller methods like create, update, show, etc., were defined to handle only HTTP requests and delegate business logic to the model or helper methods. This keeps the controller actions clean and focused on routing and basic request handling.

*In the ResponseHelper:
Methods such as create_answers and update_answers are good examples where each method is tasked with either creating or updating answers but not both. This follows SRP by dividing the responsibilities into more manageable, discrete operations.

===Factory Method===
The Factory Method pattern can be seen implicitly where object creation processes are encapsulated within the model or helper methods, such as creating a new ResponseMap or generating new Answer objects. This ensures that object creation is modular and separated from the main application logic.
===Strategy Pattern===
By defining a family of algorithms (in this case, validation rules for different actions like create or update), encapsulating each one, and making them interchangeable, the strategy pattern lets the algorithm vary independently from the clients that use it. For instance, separating the validation conditions for creating and updating responses allows for flexible swapping and extension of validation logic without modifying the controller or model directly.
===Observer Pattern===
Used typically in scenarios where changes to a particular object need to notify other dependent objects automatically. In the context of this application, this could relate to notifying instructors or peers upon the submission or update of responses, handled through the helper methods for sending emails.
===Template Method===
This pattern can be used in defining the skeleton of an operation in a method, deferring some steps to subclasses or other methods. It's seen in how validate_params uses a general structure for validation but defers the specifics to methods like validate_create_conditions and validate_update_conditions.

By integrating these design patterns and principles, the refactoring aims to achieve a more robust, maintainable, and scalable system. This approach not only addresses current complexities but also lays a foundation for easier future enhancements and modifications.

== Class Diagram ==
[[File:controller_Class_diagram.png|900px]]

== Use cases ==
[[File:Use_cases_controller.png|900px]]

== Solutions/Details of Changes Made==
=== Response Model ===
Methods within the response model were refactored or introduced, including:
==== set_content ====
Redesigned to gather and prepare the required data for response objects, optimizing the interaction with associated models
==== validate_params ====
This is the original method that was 46 lines long:

[[File:Validate parameters before.png|900px]]

===This method was significantly refactored to improve parameter validation. It was split into multiple smaller, focused methods, each dedicated to handling a specific aspect of the validation process. Each new method does one thing only, which makes them easier to understand and maintain.===
* assign_map_id_from_params: Sets the map_id for the response based on the provided parameters, ensuring the correct map ID is used for both creating and updating responses.
[[File:Assign map id.png|900px]]

*set_and_validate_response_map: Establishes and validates the presence of the response_map based on map_id. It's crucial to ensure that any response being created or updated is linked to a valid response map.This method attempts to find a ResponseMap based on map_id. If it fails to find one, it records an error and halts further validation, signaling an issue early in the process.
[[File:Set and validte response.png|900px]]

*set_response_attributes(params):Assigns additional attributes to the response object from the parameters. This centralizes attribute setting, reducing redundancy and errors.Directly extracts values like round, version_num, additional_comment, and visibility from the parameters and assigns them to the response object.
[[File:Set response attributes.png|900px]]

*action_specific_validation(params, action): Directs the validation flow based on whether the action is to create or update a response, organizing the logic clearly and preventing condition sprawl in the main validation method.Calls specific validation methods based on the action type: validate_create_conditions for creation and validate_update_conditions for updates.
[[File:Action specific validation.png|900px]]

*validate_create_conditions: Ensures that a new response doesn't duplicate an existing one under the same response map, round, and version number.Searches for an existing response that matches the current map_id, round, and version_num. If such a response exists, it adds a validation error and prevents the creation of a duplicate response.
[[File:Validate create condition.png|900px]]

*validate_update_conditions(params): Ensures that updates to a response are valid, specifically checking that a response isn't already submitted and that its map_id remains unchanged.Checks the submission status and whether there's an attempt to change the map_id. If either condition is violated, it records an error.
[[File:Validate update conditions.png|900px]]

*validate_submission_status(params): Updates the submission status of the response during the update process, ensuring the attribute is correctly set based on the provided parameters.Extracts and sets the is_submitted status from the parameters, which is crucial for controlling the editability of the response.
[[File:Validate submission status .png|900px]]

==== serialize_response ====
Improved to efficiently serialize response data for API interactions, enhancing the clarity and usability of data exchanges.

=== Response Controller ===
The ResponseController, originally extensive with numerous functions beyond basic CRUD operations, has been streamlined for our API application. In this context, there's no need to manage data variables for view pages, simplifying the handling of request data solely through request methods.To enhance the architecture and efficiency of our application, we've eliminated redundant methods and consolidated functionalities across the model, controller, and helper files. This restructuring was essential for refining the response endpoints specifically tailored for an API application.

Before we added Basic CRUD like New, Create, Update, edit, destroy.

Removed Methods: Legacy methods like Questionnaire_from_response_map and Questionnaire_from_response were removed following the refactoring of set_content, which now handles its functionalities internally without the need for these methods.

==== Show_calibration_results_for_student ====
Before:

[[File:Show calibration results for student.PNG|900px]]

The old implementation also made use of database queries in the view. This will not be possible in the reimplemented Expertiza, and the required data will need to be made available in the JSON response sent by the controller.
[[File:DB access in view.PNG|900px]]
[[File:DB access in view 2.PNG|900px]]

The new show_calibration_results_for_student method retrieves and displays calibration and review responses based on provided map IDs. It fetches responses using these IDs, retrieves associated questions and answers, and returns the data as a formatted JSON object. If a response is not found, it returns an error indicating the missing response. The method handles any exceptions by returning a standard error message, ensuring robust error handling throughout the process.
Serves as an API endpoint to fetch detailed response data for a student's calibration and review tasks, providing all necessary details about the questions asked and the answers provided in both contexts

[[File:Show_calibration_results.png|900px]]

=== Response Helper ===

The method create_update_answers(response, answers) was originally handling both the creation and updating of answer records within a single method:

[[File:Create_update_answers_before.png|900px]]

To improve code maintainability and adhere to the Single Responsibility Principle, this method has been divided into two distinct methods:

==== Create_answers ====
This method focuses solely on creating new answer records. It iterates over the answers provided, checking if each answer does not already exist in the database. If the answer does not exist, it creates a new record for that answer. This ensures that each answer is unique and prevents duplication.
[[File:Create_answers_after.png|900px]]

==== Update_answers ====
This method is responsible for updating existing answer records. It searches for existing answers in the database based on the response and question identifiers. If an answer is found, it updates the existing record with the new information provided. This method ensures that all modifications to answers are captured accurately and that the database is kept up-to-date.

[[File:Update_answers_after.png|900px]]

==Files Modified/Added==
List of primary files modified or created includes:
* responses_controller.rb
* response_helper.rb
* response.rb

==Test==

The Model and Controller functions will be tested throughoughly.

Rspec unit tests will be used to test each function of the refactored and reimplemented functions to verify the expected responses are received for given inputs.

Unit tests will be written for the following model functions:

Unit tests will also be written for the controller functions:

The Swagger UI will be utilized to make the controller functions accessible VIA API calls. This will allow for testing of the input and outputs of the API calls to the methods, and will function as integration tests.

==Team==
===== Mentor=====
*Ameya Vaichalkar

=====Members=====
* Jeff Riehle
* Maday Moya
* Shardul Ladekar

==Links==
Swagger Video Link:

Pull request: https://github.com/expertiza/reimplementation-back-end/pull/92

Model Tests Video: https://youtu.be/EPoD3ai33qk

Controller Tests Video: https://youtu.be/moZrjXE-dM8

==References==

*

CSC/ECE 517 Spring 2024 - E2415. Reimplement responses controller.rb (Design Document)

2024-04-24T02:39:59Z

Jriehle: /* Links */

CSC/ECE 517 Spring 2024 - E2415: Reimplementation of responses_controller.rb (Design Document)

==Expertiza==
The Expertiza project, an open-source endeavor rooted in Ruby on Rails, embarks on continuous improvement to adapt and integrate modern software engineering practices. The Responses Controller is engineered to assist reviewers in submitting structured data that is specifically aligned with an assignment's rubrics, ensuring the provision of relevant questions for each round within the correct due date period. It enables a reviewer to evaluate and score the rubric questions pertinent to the assignment's topics. Furthermore, it ensures the delivery of appropriate questions for each assignment round, allowing reviewers to create and modify scores and comments for each of the rubric questions associated with the assignment. After reviewers submit their scored questions and comments, the Responses Controller dispatches an email notification to the instructor and the reviewed team's members.

==Problem Statement==
The ResponseController in Expertiza, a legacy system with conventions predating Rails standards, is overly complex, encompassing functionalities beyond basic CRUD operations and needing adherence to modern Rails naming and design principles. Key issues include the direct implementation of functionalities like sorting reviews and checking reviewer roles within the controller, suggesting a shift towards polymorphism and a more structured approach to code organization. Furthermore, the controller's handling of email notifications and feedback mechanisms is inconsistent, indicating the necessity for a dedicated helper to streamline communication processes. The reimplementation effort must focus on simplifying the controller, adhering to Rails conventions, and improving code readability and maintainability by appropriately distributing responsibilities.

==Design Goal==
The redesign of the `responses_controller.rb` is guided by several key objectives to improve the code quality, system behavior, and developer interaction. The goals include:

* Maintainability and Scalability: Ensuring the code is easy to understand, modify, and extend. The reimplementation should simplify future updates and feature additions.

* Adherence to Rails Best Practices: Following Rails conventions for naming, structure, and coding practices to ensure code consistency and reliability.

* DRY Principle: "Don't Repeat Yourself" - removing redundant code and logic to create a more efficient and error-resistant codebase.

* Single Responsibility Principle: Restructuring the controller and associated models so that each class and method has one purpose and one purpose only, leading to easier testing and management.

* Improved Testing and Coverage: Enhancing test suites to cover more scenarios and edge cases, increasing confidence in the application's stability and performance.

* Performance Optimization: Identifying and optimizing slow or inefficient areas in the code to ensure the application runs smoothly.

* Clean Up Dead Methods: Audit the codebase for any unused ("dead") methods within the current controller and remove them to declutter the code.

* Reduced Controller Complexity: We already have streamline the `ResponseController` to focus primarily on CRUD operations and extract non-essential logic to appropriate models or helpers, now we aim to implement the rest operations.

By meeting these design goals, the project aims to produce a `responses_controller.rb` that is robust, efficient, and a pleasure to work with, both for the current development team and for those who will maintain the system in the future.

== Design Pattern ==

During the code refactoring process, we conscientiously followed various design patterns to enhance the overall structure.
When refactoring the Response model and associated controller and helper methods in the application, several key design patterns and principles were followed to ensure improved code quality, maintainability, and scalability. Here are the primary patterns and principles that were considered:

=== Single Responsibility Principle (SRP) ===
This principle was applied to break down complex methods into smaller, more focused functions that handle a specific part of the process

*In the Response Model:
Validate_params was broken down into multiple smaller methods, each handling a specific part of the validation process. This allows each method to manage one aspect of the validation, making the code easier to maintain and modify.
Creation and management of relationships and basic attributes were clearly defined, ensuring that the Response class isn't overloaded with logic that doesn't pertain to its direct attributes or relationships.

*In the ResponsesController:
The controller methods like create, update, show, etc., were defined to handle only HTTP requests and delegate business logic to the model or helper methods. This keeps the controller actions clean and focused on routing and basic request handling.

*In the ResponseHelper:
Methods such as create_answers and update_answers are good examples where each method is tasked with either creating or updating answers but not both. This follows SRP by dividing the responsibilities into more manageable, discrete operations.

===Factory Method===
The Factory Method pattern can be seen implicitly where object creation processes are encapsulated within the model or helper methods, such as creating a new ResponseMap or generating new Answer objects. This ensures that object creation is modular and separated from the main application logic.
===Strategy Pattern===
By defining a family of algorithms (in this case, validation rules for different actions like create or update), encapsulating each one, and making them interchangeable, the strategy pattern lets the algorithm vary independently from the clients that use it. For instance, separating the validation conditions for creating and updating responses allows for flexible swapping and extension of validation logic without modifying the controller or model directly.
===Observer Pattern===
Used typically in scenarios where changes to a particular object need to notify other dependent objects automatically. In the context of this application, this could relate to notifying instructors or peers upon the submission or update of responses, handled through the helper methods for sending emails.
===Template Method===
This pattern can be used in defining the skeleton of an operation in a method, deferring some steps to subclasses or other methods. It's seen in how validate_params uses a general structure for validation but defers the specifics to methods like validate_create_conditions and validate_update_conditions.

By integrating these design patterns and principles, the refactoring aims to achieve a more robust, maintainable, and scalable system. This approach not only addresses current complexities but also lays a foundation for easier future enhancements and modifications.

== Solutions/Details of Changes Made==
=== Response Model ===
Methods within the response model were refactored or introduced, including:
==== set_content ====
Redesigned to gather and prepare the required data for response objects, optimizing the interaction with associated models
==== validate_params ====
This is the original method that was 46 lines long:

[[File:Validate parameters before.png|900px]]

===This method was significantly refactored to improve parameter validation. It was split into multiple smaller, focused methods, each dedicated to handling a specific aspect of the validation process. Each new method does one thing only, which makes them easier to understand and maintain.===
* assign_map_id_from_params: Sets the map_id for the response based on the provided parameters, ensuring the correct map ID is used for both creating and updating responses.
[[File:Assign map id.png|900px]]

*set_and_validate_response_map: Establishes and validates the presence of the response_map based on map_id. It's crucial to ensure that any response being created or updated is linked to a valid response map.This method attempts to find a ResponseMap based on map_id. If it fails to find one, it records an error and halts further validation, signaling an issue early in the process.
[[File:Set and validte response.png|900px]]

*set_response_attributes(params):Assigns additional attributes to the response object from the parameters. This centralizes attribute setting, reducing redundancy and errors.Directly extracts values like round, version_num, additional_comment, and visibility from the parameters and assigns them to the response object.
[[File:Set response attributes.png|900px]]

*action_specific_validation(params, action): Directs the validation flow based on whether the action is to create or update a response, organizing the logic clearly and preventing condition sprawl in the main validation method.Calls specific validation methods based on the action type: validate_create_conditions for creation and validate_update_conditions for updates.
[[File:Action specific validation.png|900px]]

*validate_create_conditions: Ensures that a new response doesn't duplicate an existing one under the same response map, round, and version number.Searches for an existing response that matches the current map_id, round, and version_num. If such a response exists, it adds a validation error and prevents the creation of a duplicate response.
[[File:Validate create condition.png|900px]]

*validate_update_conditions(params): Ensures that updates to a response are valid, specifically checking that a response isn't already submitted and that its map_id remains unchanged.Checks the submission status and whether there's an attempt to change the map_id. If either condition is violated, it records an error.
[[File:Validate update conditions.png|900px]]

*validate_submission_status(params): Updates the submission status of the response during the update process, ensuring the attribute is correctly set based on the provided parameters.Extracts and sets the is_submitted status from the parameters, which is crucial for controlling the editability of the response.
[[File:Validate submission status .png|900px]]

==== serialize_response ====
Improved to efficiently serialize response data for API interactions, enhancing the clarity and usability of data exchanges.

=== Response Controller ===
The ResponseController, originally extensive with numerous functions beyond basic CRUD operations, has been streamlined for our API application. In this context, there's no need to manage data variables for view pages, simplifying the handling of request data solely through request methods.To enhance the architecture and efficiency of our application, we've eliminated redundant methods and consolidated functionalities across the model, controller, and helper files. This restructuring was essential for refining the response endpoints specifically tailored for an API application.

Before we added Basic CRUD like New, Create, Update, edit, destroy.

Removed Methods: Legacy methods like Questionnaire_from_response_map and Questionnaire_from_response were removed following the refactoring of set_content, which now handles its functionalities internally without the need for these methods.

==== Show_calibration_results_for_student ====
Before:

[[File:Show calibration results for student.PNG|900px]]

The old implementation also made use of database queries in the view. This will not be possible in the reimplemented Expertiza, and the required data will need to be made available in the JSON response sent by the controller.
[[File:DB access in view.PNG|900px]]
[[File:DB access in view 2.PNG|900px]]

The new show_calibration_results_for_student method retrieves and displays calibration and review responses based on provided map IDs. It fetches responses using these IDs, retrieves associated questions and answers, and returns the data as a formatted JSON object. If a response is not found, it returns an error indicating the missing response. The method handles any exceptions by returning a standard error message, ensuring robust error handling throughout the process.
Serves as an API endpoint to fetch detailed response data for a student's calibration and review tasks, providing all necessary details about the questions asked and the answers provided in both contexts

[[File:Show_calibration_results.png|900px]]

==== Init_answers ====

==== Save ====

=== Response Helper ===

The method create_update_answers(response, answers) was originally handling both the creation and updating of answer records within a single method:

[[File:Create_update_answers_before.png|900px]]

To improve code maintainability and adhere to the Single Responsibility Principle, this method has been divided into two distinct methods:

==== Create_answers ====
This method focuses solely on creating new answer records. It iterates over the answers provided, checking if each answer does not already exist in the database. If the answer does not exist, it creates a new record for that answer. This ensures that each answer is unique and prevents duplication.
[[File:Create_answers_after.png|900px]]

==== Update_answers ====
This method is responsible for updating existing answer records. It searches for existing answers in the database based on the response and question identifiers. If an answer is found, it updates the existing record with the new information provided. This method ensures that all modifications to answers are captured accurately and that the database is kept up-to-date.

[[File:Update_answers_after.png|900px]]

==Files Modified/Added==
List of primary files modified or created includes:
* responses_controller.rb
* response_helper.rb
* response.rb

==Test Plan==

The Model and Controller functions will be tested throughoughly.

Rspec unit tests will be used to test each function of the refactored and reimplemented functions to verify the expected responses are received for given inputs.

Unit tests will be written for the following model functions:

Unit tests will also be written for the controller functions:

The Swagger UI will be utilized to make the controller functions accessible VIA API calls. This will allow for testing of the input and outputs of the API calls to the methods, and will function as integration tests.

==Team==
===== Mentor=====
*Ameya Vaichalkar

=====Members=====
* Jeff Riehle
* Maday Moya
* Shardul Ladekar

==Links==
Swagger Video Link:

Pull request: https://github.com/expertiza/reimplementation-back-end/pull/92

Model Tests Video: https://youtu.be/EPoD3ai33qk

Controller Tests Video: https://youtu.be/moZrjXE-dM8

==References==

*

CSC/ECE 517 Spring 2024 - E2415. Reimplement responses controller.rb (Design Document)

2024-04-24T00:59:19Z

Jriehle: /* Links */

CSC/ECE 517 Spring 2024 - E2415: Reimplementation of responses_controller.rb (Design Document)

==Expertiza==
The Expertiza project, an open-source endeavor rooted in Ruby on Rails, embarks on continuous improvement to adapt and integrate modern software engineering practices. The Responses Controller is engineered to assist reviewers in submitting structured data that is specifically aligned with an assignment's rubrics, ensuring the provision of relevant questions for each round within the correct due date period. It enables a reviewer to evaluate and score the rubric questions pertinent to the assignment's topics. Furthermore, it ensures the delivery of appropriate questions for each assignment round, allowing reviewers to create and modify scores and comments for each of the rubric questions associated with the assignment. After reviewers submit their scored questions and comments, the Responses Controller dispatches an email notification to the instructor and the reviewed team's members.

==Problem Statement==
The ResponseController in Expertiza, a legacy system with conventions predating Rails standards, is overly complex, encompassing functionalities beyond basic CRUD operations and needing adherence to modern Rails naming and design principles. Key issues include the direct implementation of functionalities like sorting reviews and checking reviewer roles within the controller, suggesting a shift towards polymorphism and a more structured approach to code organization. Furthermore, the controller's handling of email notifications and feedback mechanisms is inconsistent, indicating the necessity for a dedicated helper to streamline communication processes. The reimplementation effort must focus on simplifying the controller, adhering to Rails conventions, and improving code readability and maintainability by appropriately distributing responsibilities.

==Design Goal==
The redesign of the `responses_controller.rb` is guided by several key objectives to improve the code quality, system behavior, and developer interaction. The goals include:

* Maintainability and Scalability: Ensuring the code is easy to understand, modify, and extend. The reimplementation should simplify future updates and feature additions.

* Adherence to Rails Best Practices: Following Rails conventions for naming, structure, and coding practices to ensure code consistency and reliability.

* DRY Principle: "Don't Repeat Yourself" - removing redundant code and logic to create a more efficient and error-resistant codebase.

* Single Responsibility Principle: Restructuring the controller and associated models so that each class and method has one purpose and one purpose only, leading to easier testing and management.

* Improved Testing and Coverage: Enhancing test suites to cover more scenarios and edge cases, increasing confidence in the application's stability and performance.

* Performance Optimization: Identifying and optimizing slow or inefficient areas in the code to ensure the application runs smoothly.

* Clean Up Dead Methods: Audit the codebase for any unused ("dead") methods within the current controller and remove them to declutter the code.

* Reduced Controller Complexity: We already have streamline the `ResponseController` to focus primarily on CRUD operations and extract non-essential logic to appropriate models or helpers, now we aim to implement the rest operations.

By meeting these design goals, the project aims to produce a `responses_controller.rb` that is robust, efficient, and a pleasure to work with, both for the current development team and for those who will maintain the system in the future.

== Design Pattern ==

During the code refactoring process, we conscientiously followed various design patterns to enhance the overall structure.
When refactoring the Response model and associated controller and helper methods in the application, several key design patterns and principles were followed to ensure improved code quality, maintainability, and scalability. Here are the primary patterns and principles that were considered:

=== Single Responsibility Principle (SRP) ===
This principle was applied to break down complex methods into smaller, more focused functions that handle a specific part of the process

*In the Response Model:
Validate_params was broken down into multiple smaller methods, each handling a specific part of the validation process. This allows each method to manage one aspect of the validation, making the code easier to maintain and modify.
Creation and management of relationships and basic attributes were clearly defined, ensuring that the Response class isn't overloaded with logic that doesn't pertain to its direct attributes or relationships.

*In the ResponsesController:
The controller methods like create, update, show, etc., were defined to handle only HTTP requests and delegate business logic to the model or helper methods. This keeps the controller actions clean and focused on routing and basic request handling.

*In the ResponseHelper:
Methods such as create_answers and update_answers are good examples where each method is tasked with either creating or updating answers but not both. This follows SRP by dividing the responsibilities into more manageable, discrete operations.

===Factory Method===
The Factory Method pattern can be seen implicitly where object creation processes are encapsulated within the model or helper methods, such as creating a new ResponseMap or generating new Answer objects. This ensures that object creation is modular and separated from the main application logic.
===Strategy Pattern===
By defining a family of algorithms (in this case, validation rules for different actions like create or update), encapsulating each one, and making them interchangeable, the strategy pattern lets the algorithm vary independently from the clients that use it. For instance, separating the validation conditions for creating and updating responses allows for flexible swapping and extension of validation logic without modifying the controller or model directly.
===Observer Pattern===
Used typically in scenarios where changes to a particular object need to notify other dependent objects automatically. In the context of this application, this could relate to notifying instructors or peers upon the submission or update of responses, handled through the helper methods for sending emails.
===Template Method===
This pattern can be used in defining the skeleton of an operation in a method, deferring some steps to subclasses or other methods. It's seen in how validate_params uses a general structure for validation but defers the specifics to methods like validate_create_conditions and validate_update_conditions.

By integrating these design patterns and principles, the refactoring aims to achieve a more robust, maintainable, and scalable system. This approach not only addresses current complexities but also lays a foundation for easier future enhancements and modifications.

== Solutions/Details of Changes Made==
=== Response Model ===
Methods within the response model were refactored or introduced, including:
==== set_content ====
Redesigned to gather and prepare the required data for response objects, optimizing the interaction with associated models
==== validate_params ====
This is the original method that was 46 lines long:

[[File:Validate parameters before.png|900px]]

===This method was significantly refactored to improve parameter validation. It was split into multiple smaller, focused methods, each dedicated to handling a specific aspect of the validation process. Each new method does one thing only, which makes them easier to understand and maintain.===
* assign_map_id_from_params: Sets the map_id for the response based on the provided parameters, ensuring the correct map ID is used for both creating and updating responses.
[[File:Assign map id.png|900px]]

*set_and_validate_response_map: Establishes and validates the presence of the response_map based on map_id. It's crucial to ensure that any response being created or updated is linked to a valid response map.This method attempts to find a ResponseMap based on map_id. If it fails to find one, it records an error and halts further validation, signaling an issue early in the process.
[[File:Set and validte response.png|900px]]

*set_response_attributes(params):Assigns additional attributes to the response object from the parameters. This centralizes attribute setting, reducing redundancy and errors.Directly extracts values like round, version_num, additional_comment, and visibility from the parameters and assigns them to the response object.
[[File:Set response attributes.png|900px]]

*action_specific_validation(params, action): Directs the validation flow based on whether the action is to create or update a response, organizing the logic clearly and preventing condition sprawl in the main validation method.Calls specific validation methods based on the action type: validate_create_conditions for creation and validate_update_conditions for updates.
[[File:Action specific validation.png|900px]]

*validate_create_conditions: Ensures that a new response doesn't duplicate an existing one under the same response map, round, and version number.Searches for an existing response that matches the current map_id, round, and version_num. If such a response exists, it adds a validation error and prevents the creation of a duplicate response.
[[File:Validate create condition.png|900px]]

*validate_update_conditions(params): Ensures that updates to a response are valid, specifically checking that a response isn't already submitted and that its map_id remains unchanged.Checks the submission status and whether there's an attempt to change the map_id. If either condition is violated, it records an error.
[[File:Validate update conditions.png|900px]]

*validate_submission_status(params): Updates the submission status of the response during the update process, ensuring the attribute is correctly set based on the provided parameters.Extracts and sets the is_submitted status from the parameters, which is crucial for controlling the editability of the response.
[[File:Validate submission status .png|900px]]

==== serialize_response ====
Improved to efficiently serialize response data for API interactions, enhancing the clarity and usability of data exchanges.

=== Response Controller ===
The ResponseController, originally extensive with numerous functions beyond basic CRUD operations, has been streamlined for our API application. In this context, there's no need to manage data variables for view pages, simplifying the handling of request data solely through request methods.To enhance the architecture and efficiency of our application, we've eliminated redundant methods and consolidated functionalities across the model, controller, and helper files. This restructuring was essential for refining the response endpoints specifically tailored for an API application.

Before we added Basic CRUD like New, Create, Update, edit, destroy.

Removed Methods: Legacy methods like Questionnaire_from_response_map and Questionnaire_from_response were removed following the refactoring of set_content, which now handles its functionalities internally without the need for these methods.

==== Show_calibration_results_for_student ====
Before:

[[File:Show calibration results for student.PNG|900px]]

The old implementation also made use of database queries in the view. This will not be possible in the reimplemented Expertiza, and the required data will need to be made available in the JSON response sent by the controller.
[[File:DB access in view.PNG|900px]]
[[File:DB access in view 2.PNG|900px]]

The new show_calibration_results_for_student method retrieves and displays calibration and review responses based on provided map IDs. It fetches responses using these IDs, retrieves associated questions and answers, and returns the data as a formatted JSON object. If a response is not found, it returns an error indicating the missing response. The method handles any exceptions by returning a standard error message, ensuring robust error handling throughout the process.
Serves as an API endpoint to fetch detailed response data for a student's calibration and review tasks, providing all necessary details about the questions asked and the answers provided in both contexts

[[File:Show_calibration_results.png|900px]]

==== Init_answers ====

==== Save ====

=== Response Helper ===

The method create_update_answers(response, answers) was originally handling both the creation and updating of answer records within a single method:

[[File:Create_update_answers_before.png|900px]]

To improve code maintainability and adhere to the Single Responsibility Principle, this method has been divided into two distinct methods:

==== Create_answers ====
This method focuses solely on creating new answer records. It iterates over the answers provided, checking if each answer does not already exist in the database. If the answer does not exist, it creates a new record for that answer. This ensures that each answer is unique and prevents duplication.
[[File:Create_answers_after.png|900px]]

==== Update_answers ====
This method is responsible for updating existing answer records. It searches for existing answers in the database based on the response and question identifiers. If an answer is found, it updates the existing record with the new information provided. This method ensures that all modifications to answers are captured accurately and that the database is kept up-to-date.

[[File:Update_answers_after.png|900px]]

==Files Modified/Added==
List of primary files modified or created includes:
* responses_controller.rb
* response_helper.rb
* response.rb

==Test Plan==

The Model and Controller functions will be tested throughoughly.

Rspec unit tests will be used to test each function of the refactored and reimplemented functions to verify the expected responses are received for given inputs.

Unit tests will be written for the following model functions:

Unit tests will also be written for the controller functions:

The Swagger UI will be utilized to make the controller functions accessible VIA API calls. This will allow for testing of the input and outputs of the API calls to the methods, and will function as integration tests.

==Team==
===== Mentor=====
*Ameya Vaichalkar

=====Members=====
* Jeff Riehle
* Maday Moya
* Shardul Ladekar

==Links==
Swagger Video Link:

Pull request: https://github.com/expertiza/reimplementation-back-end/pull/92

Model Tests Video: https://youtu.be/EPoD3ai33qk

Controller Tests Video:

==References==

*

CSC/ECE 517 Spring 2024 - E2415. Reimplement responses controller.rb (Design Document)

2024-04-23T05:15:15Z

Jriehle: /* Show_calibration_results_for_student */

CSC/ECE 517 Spring 2024 - E2415: Reimplementation of responses_controller.rb (Design Document)

==Expertiza==
The Expertiza project, an open-source endeavor rooted in Ruby on Rails, embarks on continuous improvement to adapt and integrate modern software engineering practices. The Responses Controller is engineered to assist reviewers in submitting structured data that is specifically aligned with an assignment's rubrics, ensuring the provision of relevant questions for each round within the correct due date period. It enables a reviewer to evaluate and score the rubric questions pertinent to the assignment's topics. Furthermore, it ensures the delivery of appropriate questions for each assignment round, allowing reviewers to create and modify scores and comments for each of the rubric questions associated with the assignment. After reviewers submit their scored questions and comments, the Responses Controller dispatches an email notification to the instructor and the reviewed team's members.

==Problem Statement==
The ResponseController in Expertiza, a legacy system with conventions predating Rails standards, is overly complex, encompassing functionalities beyond basic CRUD operations and needing adherence to modern Rails naming and design principles. Key issues include the direct implementation of functionalities like sorting reviews and checking reviewer roles within the controller, suggesting a shift towards polymorphism and a more structured approach to code organization. Furthermore, the controller's handling of email notifications and feedback mechanisms is inconsistent, indicating the necessity for a dedicated helper to streamline communication processes. The reimplementation effort must focus on simplifying the controller, adhering to Rails conventions, and improving code readability and maintainability by appropriately distributing responsibilities.

==Design Goal==
The redesign of the `responses_controller.rb` is guided by several key objectives to improve the code quality, system behavior, and developer interaction. The goals include:

* Maintainability and Scalability: Ensuring the code is easy to understand, modify, and extend. The reimplementation should simplify future updates and feature additions.

* Adherence to Rails Best Practices: Following Rails conventions for naming, structure, and coding practices to ensure code consistency and reliability.

* DRY Principle: "Don't Repeat Yourself" - removing redundant code and logic to create a more efficient and error-resistant codebase.

* Single Responsibility Principle: Restructuring the controller and associated models so that each class and method has one purpose and one purpose only, leading to easier testing and management.

* Improved Testing and Coverage: Enhancing test suites to cover more scenarios and edge cases, increasing confidence in the application's stability and performance.

* Performance Optimization: Identifying and optimizing slow or inefficient areas in the code to ensure the application runs smoothly.

* Clean Up Dead Methods: Audit the codebase for any unused ("dead") methods within the current controller and remove them to declutter the code.

* Reduced Controller Complexity: We already have streamline the `ResponseController` to focus primarily on CRUD operations and extract non-essential logic to appropriate models or helpers, now we aim to implement the rest operations.

By meeting these design goals, the project aims to produce a `responses_controller.rb` that is robust, efficient, and a pleasure to work with, both for the current development team and for those who will maintain the system in the future.

== Design Pattern ==

During the code refactoring process, we conscientiously followed various design patterns to enhance the overall structure.
When refactoring the Response model and associated controller and helper methods in the application, several key design patterns and principles were followed to ensure improved code quality, maintainability, and scalability. Here are the primary patterns and principles that were considered:

=== Single Responsibility Principle (SRP) ===
This principle was applied to break down complex methods into smaller, more focused functions that handle a specific part of the process

*In the Response Model:
Validate_params was broken down into multiple smaller methods, each handling a specific part of the validation process. This allows each method to manage one aspect of the validation, making the code easier to maintain and modify.
Creation and management of relationships and basic attributes were clearly defined, ensuring that the Response class isn't overloaded with logic that doesn't pertain to its direct attributes or relationships.

*In the ResponsesController:
The controller methods like create, update, show, etc., were defined to handle only HTTP requests and delegate business logic to the model or helper methods. This keeps the controller actions clean and focused on routing and basic request handling.

*In the ResponseHelper:
Methods such as create_answers and update_answers are good examples where each method is tasked with either creating or updating answers but not both. This follows SRP by dividing the responsibilities into more manageable, discrete operations.

===Factory Method===
The Factory Method pattern can be seen implicitly where object creation processes are encapsulated within the model or helper methods, such as creating a new ResponseMap or generating new Answer objects. This ensures that object creation is modular and separated from the main application logic.
===Strategy Pattern===
By defining a family of algorithms (in this case, validation rules for different actions like create or update), encapsulating each one, and making them interchangeable, the strategy pattern lets the algorithm vary independently from the clients that use it. For instance, separating the validation conditions for creating and updating responses allows for flexible swapping and extension of validation logic without modifying the controller or model directly.
===Observer Pattern===
Used typically in scenarios where changes to a particular object need to notify other dependent objects automatically. In the context of this application, this could relate to notifying instructors or peers upon the submission or update of responses, handled through the helper methods for sending emails.
===Template Method===
This pattern can be used in defining the skeleton of an operation in a method, deferring some steps to subclasses or other methods. It's seen in how validate_params uses a general structure for validation but defers the specifics to methods like validate_create_conditions and validate_update_conditions.

By integrating these design patterns and principles, the refactoring aims to achieve a more robust, maintainable, and scalable system. This approach not only addresses current complexities but also lays a foundation for easier future enhancements and modifications.

== Solutions/Details of Changes Made==
=== Response Model ===
Methods within the response model were refactored or introduced, including:
==== set_content ====
Redesigned to gather and prepare the required data for response objects, optimizing the interaction with associated models
==== validate_params ====
This is the original method that was 46 lines long:

[[File:Validate parameters before.png|900px]]

===This method was significantly refactored to improve parameter validation. It was split into multiple smaller, focused methods, each dedicated to handling a specific aspect of the validation process. Each new method does one thing only, which makes them easier to understand and maintain.===
* assign_map_id_from_params: Sets the map_id for the response based on the provided parameters, ensuring the correct map ID is used for both creating and updating responses.
[[File:Assign map id.png|900px]]

*set_and_validate_response_map: Establishes and validates the presence of the response_map based on map_id. It's crucial to ensure that any response being created or updated is linked to a valid response map.This method attempts to find a ResponseMap based on map_id. If it fails to find one, it records an error and halts further validation, signaling an issue early in the process.
[[File:Set and validte response.png|900px]]

*set_response_attributes(params):Assigns additional attributes to the response object from the parameters. This centralizes attribute setting, reducing redundancy and errors.Directly extracts values like round, version_num, additional_comment, and visibility from the parameters and assigns them to the response object.
[[File:Set response attributes.png|900px]]

*action_specific_validation(params, action): Directs the validation flow based on whether the action is to create or update a response, organizing the logic clearly and preventing condition sprawl in the main validation method.Calls specific validation methods based on the action type: validate_create_conditions for creation and validate_update_conditions for updates.
[[File:Action specific validation.png|900px]]

*validate_create_conditions: Ensures that a new response doesn't duplicate an existing one under the same response map, round, and version number.Searches for an existing response that matches the current map_id, round, and version_num. If such a response exists, it adds a validation error and prevents the creation of a duplicate response.
[[File:Validate create condition.png|900px]]

*validate_update_conditions(params): Ensures that updates to a response are valid, specifically checking that a response isn't already submitted and that its map_id remains unchanged.Checks the submission status and whether there's an attempt to change the map_id. If either condition is violated, it records an error.
[[File:Validate update conditions.png|900px]]

*validate_submission_status(params): Updates the submission status of the response during the update process, ensuring the attribute is correctly set based on the provided parameters.Extracts and sets the is_submitted status from the parameters, which is crucial for controlling the editability of the response.
[[File:Validate submission status .png|900px]]

==== serialize_response ====
Improved to efficiently serialize response data for API interactions, enhancing the clarity and usability of data exchanges.

=== Response Controller ===
The ResponseController, originally extensive with numerous functions beyond basic CRUD operations, has been streamlined for our API application. In this context, there's no need to manage data variables for view pages, simplifying the handling of request data solely through request methods.To enhance the architecture and efficiency of our application, we've eliminated redundant methods and consolidated functionalities across the model, controller, and helper files. This restructuring was essential for refining the response endpoints specifically tailored for an API application.

Before we added Basic CRUD like New, Create, Update, edit, destroy.

Removed Methods: Legacy methods like Questionnaire_from_response_map and Questionnaire_from_response were removed following the refactoring of set_content, which now handles its functionalities internally without the need for these methods.

==== Show_calibration_results_for_student ====
Before:

[[File:Show calibration results for student.PNG|900px]]

The old implementation also made use of database queries in the view. This will not be possible in the reimplemented Expertiza, and the required data will need to be made available in the JSON response sent by the controller.
[[File:DB access in view.PNG|900px]]
[[File:DB access in view 2.PNG|900px]]

The new show_calibration_results_for_student method retrieves and displays calibration and review responses based on provided map IDs. It fetches responses using these IDs, retrieves associated questions and answers, and returns the data as a formatted JSON object. If a response is not found, it returns an error indicating the missing response. The method handles any exceptions by returning a standard error message, ensuring robust error handling throughout the process.
Serves as an API endpoint to fetch detailed response data for a student's calibration and review tasks, providing all necessary details about the questions asked and the answers provided in both contexts

[[File:Show_calibration_results.png|900px]]

==== Init_answers ====

==== Save ====

=== Response Helper ===

The method create_update_answers(response, answers) was originally handling both the creation and updating of answer records within a single method:

[[File:Create_update_answers_before.png|900px]]

To improve code maintainability and adhere to the Single Responsibility Principle, this method has been divided into two distinct methods:

==== Create_answers ====
This method focuses solely on creating new answer records. It iterates over the answers provided, checking if each answer does not already exist in the database. If the answer does not exist, it creates a new record for that answer. This ensures that each answer is unique and prevents duplication.
[[File:Create_answers_after.png|900px]]

==== Update_answers ====
This method is responsible for updating existing answer records. It searches for existing answers in the database based on the response and question identifiers. If an answer is found, it updates the existing record with the new information provided. This method ensures that all modifications to answers are captured accurately and that the database is kept up-to-date.

[[File:Update_answers_after.png|900px]]

==Files Modified/Added==
List of primary files modified or created includes:
* responses_controller.rb
* response_helper.rb
* response.rb

==Test Plan==

The Model and Controller functions will be tested throughoughly.

Rspec unit tests will be used to test each function of the refactored and reimplemented functions to verify the expected responses are received for given inputs.

Unit tests will be written for the following model functions:

Unit tests will also be written for the controller functions:

The Swagger UI will be utilized to make the controller functions accessible VIA API calls. This will allow for testing of the input and outputs of the API calls to the methods, and will function as integration tests.

==Team==
===== Mentor=====
*Ameya Vaichalkar

=====Members=====
* Jeff Riehle
* Maday Moya
* Shardul Ladekar

==Links==
Swagger Video Link:

Pull request: https://github.com/expertiza/reimplementation-back-end/pull/92

Model Tests Video:

Controller Tests Video:

==References==

*

CSC/ECE 517 Spring 2024 - E2415. Reimplement responses controller.rb (Design Document)

2024-04-23T05:14:39Z

Jriehle: /* Show_calibration_results_for_student */

CSC/ECE 517 Spring 2024 - E2415: Reimplementation of responses_controller.rb (Design Document)

==Expertiza==
The Expertiza project, an open-source endeavor rooted in Ruby on Rails, embarks on continuous improvement to adapt and integrate modern software engineering practices. The Responses Controller is engineered to assist reviewers in submitting structured data that is specifically aligned with an assignment's rubrics, ensuring the provision of relevant questions for each round within the correct due date period. It enables a reviewer to evaluate and score the rubric questions pertinent to the assignment's topics. Furthermore, it ensures the delivery of appropriate questions for each assignment round, allowing reviewers to create and modify scores and comments for each of the rubric questions associated with the assignment. After reviewers submit their scored questions and comments, the Responses Controller dispatches an email notification to the instructor and the reviewed team's members.

==Problem Statement==
The ResponseController in Expertiza, a legacy system with conventions predating Rails standards, is overly complex, encompassing functionalities beyond basic CRUD operations and needing adherence to modern Rails naming and design principles. Key issues include the direct implementation of functionalities like sorting reviews and checking reviewer roles within the controller, suggesting a shift towards polymorphism and a more structured approach to code organization. Furthermore, the controller's handling of email notifications and feedback mechanisms is inconsistent, indicating the necessity for a dedicated helper to streamline communication processes. The reimplementation effort must focus on simplifying the controller, adhering to Rails conventions, and improving code readability and maintainability by appropriately distributing responsibilities.

==Design Goal==
The redesign of the `responses_controller.rb` is guided by several key objectives to improve the code quality, system behavior, and developer interaction. The goals include:

* Maintainability and Scalability: Ensuring the code is easy to understand, modify, and extend. The reimplementation should simplify future updates and feature additions.

* Adherence to Rails Best Practices: Following Rails conventions for naming, structure, and coding practices to ensure code consistency and reliability.

* DRY Principle: "Don't Repeat Yourself" - removing redundant code and logic to create a more efficient and error-resistant codebase.

* Single Responsibility Principle: Restructuring the controller and associated models so that each class and method has one purpose and one purpose only, leading to easier testing and management.

* Improved Testing and Coverage: Enhancing test suites to cover more scenarios and edge cases, increasing confidence in the application's stability and performance.

* Performance Optimization: Identifying and optimizing slow or inefficient areas in the code to ensure the application runs smoothly.

* Clean Up Dead Methods: Audit the codebase for any unused ("dead") methods within the current controller and remove them to declutter the code.

* Reduced Controller Complexity: We already have streamline the `ResponseController` to focus primarily on CRUD operations and extract non-essential logic to appropriate models or helpers, now we aim to implement the rest operations.

By meeting these design goals, the project aims to produce a `responses_controller.rb` that is robust, efficient, and a pleasure to work with, both for the current development team and for those who will maintain the system in the future.

== Design Pattern ==

During the code refactoring process, we conscientiously followed various design patterns to enhance the overall structure.
When refactoring the Response model and associated controller and helper methods in the application, several key design patterns and principles were followed to ensure improved code quality, maintainability, and scalability. Here are the primary patterns and principles that were considered:

=== Single Responsibility Principle (SRP) ===
This principle was applied to break down complex methods into smaller, more focused functions that handle a specific part of the process

*In the Response Model:
Validate_params was broken down into multiple smaller methods, each handling a specific part of the validation process. This allows each method to manage one aspect of the validation, making the code easier to maintain and modify.
Creation and management of relationships and basic attributes were clearly defined, ensuring that the Response class isn't overloaded with logic that doesn't pertain to its direct attributes or relationships.

*In the ResponsesController:
The controller methods like create, update, show, etc., were defined to handle only HTTP requests and delegate business logic to the model or helper methods. This keeps the controller actions clean and focused on routing and basic request handling.

*In the ResponseHelper:
Methods such as create_answers and update_answers are good examples where each method is tasked with either creating or updating answers but not both. This follows SRP by dividing the responsibilities into more manageable, discrete operations.

===Factory Method===
The Factory Method pattern can be seen implicitly where object creation processes are encapsulated within the model or helper methods, such as creating a new ResponseMap or generating new Answer objects. This ensures that object creation is modular and separated from the main application logic.
===Strategy Pattern===
By defining a family of algorithms (in this case, validation rules for different actions like create or update), encapsulating each one, and making them interchangeable, the strategy pattern lets the algorithm vary independently from the clients that use it. For instance, separating the validation conditions for creating and updating responses allows for flexible swapping and extension of validation logic without modifying the controller or model directly.
===Observer Pattern===
Used typically in scenarios where changes to a particular object need to notify other dependent objects automatically. In the context of this application, this could relate to notifying instructors or peers upon the submission or update of responses, handled through the helper methods for sending emails.
===Template Method===
This pattern can be used in defining the skeleton of an operation in a method, deferring some steps to subclasses or other methods. It's seen in how validate_params uses a general structure for validation but defers the specifics to methods like validate_create_conditions and validate_update_conditions.

By integrating these design patterns and principles, the refactoring aims to achieve a more robust, maintainable, and scalable system. This approach not only addresses current complexities but also lays a foundation for easier future enhancements and modifications.

== Solutions/Details of Changes Made==
=== Response Model ===
Methods within the response model were refactored or introduced, including:
==== set_content ====
Redesigned to gather and prepare the required data for response objects, optimizing the interaction with associated models
==== validate_params ====
This is the original method that was 46 lines long:

[[File:Validate parameters before.png|900px]]

===This method was significantly refactored to improve parameter validation. It was split into multiple smaller, focused methods, each dedicated to handling a specific aspect of the validation process. Each new method does one thing only, which makes them easier to understand and maintain.===
* assign_map_id_from_params: Sets the map_id for the response based on the provided parameters, ensuring the correct map ID is used for both creating and updating responses.
[[File:Assign map id.png|900px]]

*set_and_validate_response_map: Establishes and validates the presence of the response_map based on map_id. It's crucial to ensure that any response being created or updated is linked to a valid response map.This method attempts to find a ResponseMap based on map_id. If it fails to find one, it records an error and halts further validation, signaling an issue early in the process.
[[File:Set and validte response.png|900px]]

*set_response_attributes(params):Assigns additional attributes to the response object from the parameters. This centralizes attribute setting, reducing redundancy and errors.Directly extracts values like round, version_num, additional_comment, and visibility from the parameters and assigns them to the response object.
[[File:Set response attributes.png|900px]]

*action_specific_validation(params, action): Directs the validation flow based on whether the action is to create or update a response, organizing the logic clearly and preventing condition sprawl in the main validation method.Calls specific validation methods based on the action type: validate_create_conditions for creation and validate_update_conditions for updates.
[[File:Action specific validation.png|900px]]

*validate_create_conditions: Ensures that a new response doesn't duplicate an existing one under the same response map, round, and version number.Searches for an existing response that matches the current map_id, round, and version_num. If such a response exists, it adds a validation error and prevents the creation of a duplicate response.
[[File:Validate create condition.png|900px]]

*validate_update_conditions(params): Ensures that updates to a response are valid, specifically checking that a response isn't already submitted and that its map_id remains unchanged.Checks the submission status and whether there's an attempt to change the map_id. If either condition is violated, it records an error.
[[File:Validate update conditions.png|900px]]

*validate_submission_status(params): Updates the submission status of the response during the update process, ensuring the attribute is correctly set based on the provided parameters.Extracts and sets the is_submitted status from the parameters, which is crucial for controlling the editability of the response.
[[File:Validate submission status .png|900px]]

==== serialize_response ====
Improved to efficiently serialize response data for API interactions, enhancing the clarity and usability of data exchanges.

=== Response Controller ===
The ResponseController, originally extensive with numerous functions beyond basic CRUD operations, has been streamlined for our API application. In this context, there's no need to manage data variables for view pages, simplifying the handling of request data solely through request methods.To enhance the architecture and efficiency of our application, we've eliminated redundant methods and consolidated functionalities across the model, controller, and helper files. This restructuring was essential for refining the response endpoints specifically tailored for an API application.

Before we added Basic CRUD like New, Create, Update, edit, destroy.

Removed Methods: Legacy methods like Questionnaire_from_response_map and Questionnaire_from_response were removed following the refactoring of set_content, which now handles its functionalities internally without the need for these methods.

==== Show_calibration_results_for_student ====
Before:

[[File:Show calibration results for student reimplimented.PNG|900px]]

The old implementation also made use of database queries in the view. This will not be possible in the reimplemented Expertiza, and the required data will need to be made available in the JSON response sent by the controller.
[[File:DB access in view.PNG|900px]]
[[File:DB access in view 2.PNG|900px]]

The new show_calibration_results_for_student method retrieves and displays calibration and review responses based on provided map IDs. It fetches responses using these IDs, retrieves associated questions and answers, and returns the data as a formatted JSON object. If a response is not found, it returns an error indicating the missing response. The method handles any exceptions by returning a standard error message, ensuring robust error handling throughout the process.
Serves as an API endpoint to fetch detailed response data for a student's calibration and review tasks, providing all necessary details about the questions asked and the answers provided in both contexts

[[File:Show_calibration_results.png|900px]]

==== Init_answers ====

==== Save ====

=== Response Helper ===

The method create_update_answers(response, answers) was originally handling both the creation and updating of answer records within a single method:

[[File:Create_update_answers_before.png|900px]]

To improve code maintainability and adhere to the Single Responsibility Principle, this method has been divided into two distinct methods:

==== Create_answers ====
This method focuses solely on creating new answer records. It iterates over the answers provided, checking if each answer does not already exist in the database. If the answer does not exist, it creates a new record for that answer. This ensures that each answer is unique and prevents duplication.
[[File:Create_answers_after.png|900px]]

==== Update_answers ====
This method is responsible for updating existing answer records. It searches for existing answers in the database based on the response and question identifiers. If an answer is found, it updates the existing record with the new information provided. This method ensures that all modifications to answers are captured accurately and that the database is kept up-to-date.

[[File:Update_answers_after.png|900px]]

==Files Modified/Added==
List of primary files modified or created includes:
* responses_controller.rb
* response_helper.rb
* response.rb

==Test Plan==

The Model and Controller functions will be tested throughoughly.

Rspec unit tests will be used to test each function of the refactored and reimplemented functions to verify the expected responses are received for given inputs.

Unit tests will be written for the following model functions:

Unit tests will also be written for the controller functions:

The Swagger UI will be utilized to make the controller functions accessible VIA API calls. This will allow for testing of the input and outputs of the API calls to the methods, and will function as integration tests.

==Team==
===== Mentor=====
*Ameya Vaichalkar

=====Members=====
* Jeff Riehle
* Maday Moya
* Shardul Ladekar

==Links==
Swagger Video Link:

Pull request: https://github.com/expertiza/reimplementation-back-end/pull/92

Model Tests Video:

Controller Tests Video:

==References==

*

CSC/ECE 517 Spring 2024 - E2415. Reimplement responses controller.rb (Design Document)

2024-04-23T05:14:14Z

Jriehle: /* Show_calibration_results_for_student */

CSC/ECE 517 Spring 2024 - E2415: Reimplementation of responses_controller.rb (Design Document)

==Expertiza==
The Expertiza project, an open-source endeavor rooted in Ruby on Rails, embarks on continuous improvement to adapt and integrate modern software engineering practices. The Responses Controller is engineered to assist reviewers in submitting structured data that is specifically aligned with an assignment's rubrics, ensuring the provision of relevant questions for each round within the correct due date period. It enables a reviewer to evaluate and score the rubric questions pertinent to the assignment's topics. Furthermore, it ensures the delivery of appropriate questions for each assignment round, allowing reviewers to create and modify scores and comments for each of the rubric questions associated with the assignment. After reviewers submit their scored questions and comments, the Responses Controller dispatches an email notification to the instructor and the reviewed team's members.

==Problem Statement==
The ResponseController in Expertiza, a legacy system with conventions predating Rails standards, is overly complex, encompassing functionalities beyond basic CRUD operations and needing adherence to modern Rails naming and design principles. Key issues include the direct implementation of functionalities like sorting reviews and checking reviewer roles within the controller, suggesting a shift towards polymorphism and a more structured approach to code organization. Furthermore, the controller's handling of email notifications and feedback mechanisms is inconsistent, indicating the necessity for a dedicated helper to streamline communication processes. The reimplementation effort must focus on simplifying the controller, adhering to Rails conventions, and improving code readability and maintainability by appropriately distributing responsibilities.

==Design Goal==
The redesign of the `responses_controller.rb` is guided by several key objectives to improve the code quality, system behavior, and developer interaction. The goals include:

* Maintainability and Scalability: Ensuring the code is easy to understand, modify, and extend. The reimplementation should simplify future updates and feature additions.

* Adherence to Rails Best Practices: Following Rails conventions for naming, structure, and coding practices to ensure code consistency and reliability.

* DRY Principle: "Don't Repeat Yourself" - removing redundant code and logic to create a more efficient and error-resistant codebase.

* Single Responsibility Principle: Restructuring the controller and associated models so that each class and method has one purpose and one purpose only, leading to easier testing and management.

* Improved Testing and Coverage: Enhancing test suites to cover more scenarios and edge cases, increasing confidence in the application's stability and performance.

* Performance Optimization: Identifying and optimizing slow or inefficient areas in the code to ensure the application runs smoothly.

* Clean Up Dead Methods: Audit the codebase for any unused ("dead") methods within the current controller and remove them to declutter the code.

* Reduced Controller Complexity: We already have streamline the `ResponseController` to focus primarily on CRUD operations and extract non-essential logic to appropriate models or helpers, now we aim to implement the rest operations.

By meeting these design goals, the project aims to produce a `responses_controller.rb` that is robust, efficient, and a pleasure to work with, both for the current development team and for those who will maintain the system in the future.

== Design Pattern ==

During the code refactoring process, we conscientiously followed various design patterns to enhance the overall structure.
When refactoring the Response model and associated controller and helper methods in the application, several key design patterns and principles were followed to ensure improved code quality, maintainability, and scalability. Here are the primary patterns and principles that were considered:

=== Single Responsibility Principle (SRP) ===
This principle was applied to break down complex methods into smaller, more focused functions that handle a specific part of the process

*In the Response Model:
Validate_params was broken down into multiple smaller methods, each handling a specific part of the validation process. This allows each method to manage one aspect of the validation, making the code easier to maintain and modify.
Creation and management of relationships and basic attributes were clearly defined, ensuring that the Response class isn't overloaded with logic that doesn't pertain to its direct attributes or relationships.

*In the ResponsesController:
The controller methods like create, update, show, etc., were defined to handle only HTTP requests and delegate business logic to the model or helper methods. This keeps the controller actions clean and focused on routing and basic request handling.

*In the ResponseHelper:
Methods such as create_answers and update_answers are good examples where each method is tasked with either creating or updating answers but not both. This follows SRP by dividing the responsibilities into more manageable, discrete operations.

===Factory Method===
The Factory Method pattern can be seen implicitly where object creation processes are encapsulated within the model or helper methods, such as creating a new ResponseMap or generating new Answer objects. This ensures that object creation is modular and separated from the main application logic.
===Strategy Pattern===
By defining a family of algorithms (in this case, validation rules for different actions like create or update), encapsulating each one, and making them interchangeable, the strategy pattern lets the algorithm vary independently from the clients that use it. For instance, separating the validation conditions for creating and updating responses allows for flexible swapping and extension of validation logic without modifying the controller or model directly.
===Observer Pattern===
Used typically in scenarios where changes to a particular object need to notify other dependent objects automatically. In the context of this application, this could relate to notifying instructors or peers upon the submission or update of responses, handled through the helper methods for sending emails.
===Template Method===
This pattern can be used in defining the skeleton of an operation in a method, deferring some steps to subclasses or other methods. It's seen in how validate_params uses a general structure for validation but defers the specifics to methods like validate_create_conditions and validate_update_conditions.

By integrating these design patterns and principles, the refactoring aims to achieve a more robust, maintainable, and scalable system. This approach not only addresses current complexities but also lays a foundation for easier future enhancements and modifications.

== Solutions/Details of Changes Made==
=== Response Model ===
Methods within the response model were refactored or introduced, including:
==== set_content ====
Redesigned to gather and prepare the required data for response objects, optimizing the interaction with associated models
==== validate_params ====
This is the original method that was 46 lines long:

[[File:Validate parameters before.png|900px]]

===This method was significantly refactored to improve parameter validation. It was split into multiple smaller, focused methods, each dedicated to handling a specific aspect of the validation process. Each new method does one thing only, which makes them easier to understand and maintain.===
* assign_map_id_from_params: Sets the map_id for the response based on the provided parameters, ensuring the correct map ID is used for both creating and updating responses.
[[File:Assign map id.png|900px]]

*set_and_validate_response_map: Establishes and validates the presence of the response_map based on map_id. It's crucial to ensure that any response being created or updated is linked to a valid response map.This method attempts to find a ResponseMap based on map_id. If it fails to find one, it records an error and halts further validation, signaling an issue early in the process.
[[File:Set and validte response.png|900px]]

*set_response_attributes(params):Assigns additional attributes to the response object from the parameters. This centralizes attribute setting, reducing redundancy and errors.Directly extracts values like round, version_num, additional_comment, and visibility from the parameters and assigns them to the response object.
[[File:Set response attributes.png|900px]]

*action_specific_validation(params, action): Directs the validation flow based on whether the action is to create or update a response, organizing the logic clearly and preventing condition sprawl in the main validation method.Calls specific validation methods based on the action type: validate_create_conditions for creation and validate_update_conditions for updates.
[[File:Action specific validation.png|900px]]

*validate_create_conditions: Ensures that a new response doesn't duplicate an existing one under the same response map, round, and version number.Searches for an existing response that matches the current map_id, round, and version_num. If such a response exists, it adds a validation error and prevents the creation of a duplicate response.
[[File:Validate create condition.png|900px]]

*validate_update_conditions(params): Ensures that updates to a response are valid, specifically checking that a response isn't already submitted and that its map_id remains unchanged.Checks the submission status and whether there's an attempt to change the map_id. If either condition is violated, it records an error.
[[File:Validate update conditions.png|900px]]

*validate_submission_status(params): Updates the submission status of the response during the update process, ensuring the attribute is correctly set based on the provided parameters.Extracts and sets the is_submitted status from the parameters, which is crucial for controlling the editability of the response.
[[File:Validate submission status .png|900px]]

==== serialize_response ====
Improved to efficiently serialize response data for API interactions, enhancing the clarity and usability of data exchanges.

=== Response Controller ===
The ResponseController, originally extensive with numerous functions beyond basic CRUD operations, has been streamlined for our API application. In this context, there's no need to manage data variables for view pages, simplifying the handling of request data solely through request methods.To enhance the architecture and efficiency of our application, we've eliminated redundant methods and consolidated functionalities across the model, controller, and helper files. This restructuring was essential for refining the response endpoints specifically tailored for an API application.

Before we added Basic CRUD like New, Create, Update, edit, destroy.

Removed Methods: Legacy methods like Questionnaire_from_response_map and Questionnaire_from_response were removed following the refactoring of set_content, which now handles its functionalities internally without the need for these methods.

==== Show_calibration_results_for_student ====
Before:

[[File:Show calibration results for student reimplemented.PNG|900px]]

The old implementation also made use of database queries in the view. This will not be possible in the reimplemented Expertiza, and the required data will need to be made available in the JSON response sent by the controller.
[[File:DB access in view.PNG|900px]]
[[File:DB access in view 2.PNG|900px]]

The new show_calibration_results_for_student method retrieves and displays calibration and review responses based on provided map IDs. It fetches responses using these IDs, retrieves associated questions and answers, and returns the data as a formatted JSON object. If a response is not found, it returns an error indicating the missing response. The method handles any exceptions by returning a standard error message, ensuring robust error handling throughout the process.
Serves as an API endpoint to fetch detailed response data for a student's calibration and review tasks, providing all necessary details about the questions asked and the answers provided in both contexts

[[File:Show_calibration_results.png|900px]]

==== Init_answers ====

==== Save ====

=== Response Helper ===

The method create_update_answers(response, answers) was originally handling both the creation and updating of answer records within a single method:

[[File:Create_update_answers_before.png|900px]]

To improve code maintainability and adhere to the Single Responsibility Principle, this method has been divided into two distinct methods:

==== Create_answers ====
This method focuses solely on creating new answer records. It iterates over the answers provided, checking if each answer does not already exist in the database. If the answer does not exist, it creates a new record for that answer. This ensures that each answer is unique and prevents duplication.
[[File:Create_answers_after.png|900px]]

==== Update_answers ====
This method is responsible for updating existing answer records. It searches for existing answers in the database based on the response and question identifiers. If an answer is found, it updates the existing record with the new information provided. This method ensures that all modifications to answers are captured accurately and that the database is kept up-to-date.

[[File:Update_answers_after.png|900px]]

==Files Modified/Added==
List of primary files modified or created includes:
* responses_controller.rb
* response_helper.rb
* response.rb

==Test Plan==

The Model and Controller functions will be tested throughoughly.

Rspec unit tests will be used to test each function of the refactored and reimplemented functions to verify the expected responses are received for given inputs.

Unit tests will be written for the following model functions:

Unit tests will also be written for the controller functions:

The Swagger UI will be utilized to make the controller functions accessible VIA API calls. This will allow for testing of the input and outputs of the API calls to the methods, and will function as integration tests.

==Team==
===== Mentor=====
*Ameya Vaichalkar

=====Members=====
* Jeff Riehle
* Maday Moya
* Shardul Ladekar

==Links==
Swagger Video Link:

Pull request: https://github.com/expertiza/reimplementation-back-end/pull/92

Model Tests Video:

Controller Tests Video:

==References==

*

CSC/ECE 517 Spring 2024 - E2415. Reimplement responses controller.rb (Design Document)

2024-04-23T05:13:54Z

Jriehle: /* Show_calibration_results_for_student */

CSC/ECE 517 Spring 2024 - E2415: Reimplementation of responses_controller.rb (Design Document)

==Expertiza==
The Expertiza project, an open-source endeavor rooted in Ruby on Rails, embarks on continuous improvement to adapt and integrate modern software engineering practices. The Responses Controller is engineered to assist reviewers in submitting structured data that is specifically aligned with an assignment's rubrics, ensuring the provision of relevant questions for each round within the correct due date period. It enables a reviewer to evaluate and score the rubric questions pertinent to the assignment's topics. Furthermore, it ensures the delivery of appropriate questions for each assignment round, allowing reviewers to create and modify scores and comments for each of the rubric questions associated with the assignment. After reviewers submit their scored questions and comments, the Responses Controller dispatches an email notification to the instructor and the reviewed team's members.

==Problem Statement==
The ResponseController in Expertiza, a legacy system with conventions predating Rails standards, is overly complex, encompassing functionalities beyond basic CRUD operations and needing adherence to modern Rails naming and design principles. Key issues include the direct implementation of functionalities like sorting reviews and checking reviewer roles within the controller, suggesting a shift towards polymorphism and a more structured approach to code organization. Furthermore, the controller's handling of email notifications and feedback mechanisms is inconsistent, indicating the necessity for a dedicated helper to streamline communication processes. The reimplementation effort must focus on simplifying the controller, adhering to Rails conventions, and improving code readability and maintainability by appropriately distributing responsibilities.

==Design Goal==
The redesign of the `responses_controller.rb` is guided by several key objectives to improve the code quality, system behavior, and developer interaction. The goals include:

* Maintainability and Scalability: Ensuring the code is easy to understand, modify, and extend. The reimplementation should simplify future updates and feature additions.

* Adherence to Rails Best Practices: Following Rails conventions for naming, structure, and coding practices to ensure code consistency and reliability.

* DRY Principle: "Don't Repeat Yourself" - removing redundant code and logic to create a more efficient and error-resistant codebase.

* Single Responsibility Principle: Restructuring the controller and associated models so that each class and method has one purpose and one purpose only, leading to easier testing and management.

* Improved Testing and Coverage: Enhancing test suites to cover more scenarios and edge cases, increasing confidence in the application's stability and performance.

* Performance Optimization: Identifying and optimizing slow or inefficient areas in the code to ensure the application runs smoothly.

* Clean Up Dead Methods: Audit the codebase for any unused ("dead") methods within the current controller and remove them to declutter the code.

* Reduced Controller Complexity: We already have streamline the `ResponseController` to focus primarily on CRUD operations and extract non-essential logic to appropriate models or helpers, now we aim to implement the rest operations.

By meeting these design goals, the project aims to produce a `responses_controller.rb` that is robust, efficient, and a pleasure to work with, both for the current development team and for those who will maintain the system in the future.

== Design Pattern ==

During the code refactoring process, we conscientiously followed various design patterns to enhance the overall structure.
When refactoring the Response model and associated controller and helper methods in the application, several key design patterns and principles were followed to ensure improved code quality, maintainability, and scalability. Here are the primary patterns and principles that were considered:

=== Single Responsibility Principle (SRP) ===
This principle was applied to break down complex methods into smaller, more focused functions that handle a specific part of the process

*In the Response Model:
Validate_params was broken down into multiple smaller methods, each handling a specific part of the validation process. This allows each method to manage one aspect of the validation, making the code easier to maintain and modify.
Creation and management of relationships and basic attributes were clearly defined, ensuring that the Response class isn't overloaded with logic that doesn't pertain to its direct attributes or relationships.

*In the ResponsesController:
The controller methods like create, update, show, etc., were defined to handle only HTTP requests and delegate business logic to the model or helper methods. This keeps the controller actions clean and focused on routing and basic request handling.

*In the ResponseHelper:
Methods such as create_answers and update_answers are good examples where each method is tasked with either creating or updating answers but not both. This follows SRP by dividing the responsibilities into more manageable, discrete operations.

===Factory Method===
The Factory Method pattern can be seen implicitly where object creation processes are encapsulated within the model or helper methods, such as creating a new ResponseMap or generating new Answer objects. This ensures that object creation is modular and separated from the main application logic.
===Strategy Pattern===
By defining a family of algorithms (in this case, validation rules for different actions like create or update), encapsulating each one, and making them interchangeable, the strategy pattern lets the algorithm vary independently from the clients that use it. For instance, separating the validation conditions for creating and updating responses allows for flexible swapping and extension of validation logic without modifying the controller or model directly.
===Observer Pattern===
Used typically in scenarios where changes to a particular object need to notify other dependent objects automatically. In the context of this application, this could relate to notifying instructors or peers upon the submission or update of responses, handled through the helper methods for sending emails.
===Template Method===
This pattern can be used in defining the skeleton of an operation in a method, deferring some steps to subclasses or other methods. It's seen in how validate_params uses a general structure for validation but defers the specifics to methods like validate_create_conditions and validate_update_conditions.

By integrating these design patterns and principles, the refactoring aims to achieve a more robust, maintainable, and scalable system. This approach not only addresses current complexities but also lays a foundation for easier future enhancements and modifications.

== Solutions/Details of Changes Made==
=== Response Model ===
Methods within the response model were refactored or introduced, including:
==== set_content ====
Redesigned to gather and prepare the required data for response objects, optimizing the interaction with associated models
==== validate_params ====
This is the original method that was 46 lines long:

[[File:Validate parameters before.png|900px]]

===This method was significantly refactored to improve parameter validation. It was split into multiple smaller, focused methods, each dedicated to handling a specific aspect of the validation process. Each new method does one thing only, which makes them easier to understand and maintain.===
* assign_map_id_from_params: Sets the map_id for the response based on the provided parameters, ensuring the correct map ID is used for both creating and updating responses.
[[File:Assign map id.png|900px]]

*set_and_validate_response_map: Establishes and validates the presence of the response_map based on map_id. It's crucial to ensure that any response being created or updated is linked to a valid response map.This method attempts to find a ResponseMap based on map_id. If it fails to find one, it records an error and halts further validation, signaling an issue early in the process.
[[File:Set and validte response.png|900px]]

*set_response_attributes(params):Assigns additional attributes to the response object from the parameters. This centralizes attribute setting, reducing redundancy and errors.Directly extracts values like round, version_num, additional_comment, and visibility from the parameters and assigns them to the response object.
[[File:Set response attributes.png|900px]]

*action_specific_validation(params, action): Directs the validation flow based on whether the action is to create or update a response, organizing the logic clearly and preventing condition sprawl in the main validation method.Calls specific validation methods based on the action type: validate_create_conditions for creation and validate_update_conditions for updates.
[[File:Action specific validation.png|900px]]

*validate_create_conditions: Ensures that a new response doesn't duplicate an existing one under the same response map, round, and version number.Searches for an existing response that matches the current map_id, round, and version_num. If such a response exists, it adds a validation error and prevents the creation of a duplicate response.
[[File:Validate create condition.png|900px]]

*validate_update_conditions(params): Ensures that updates to a response are valid, specifically checking that a response isn't already submitted and that its map_id remains unchanged.Checks the submission status and whether there's an attempt to change the map_id. If either condition is violated, it records an error.
[[File:Validate update conditions.png|900px]]

*validate_submission_status(params): Updates the submission status of the response during the update process, ensuring the attribute is correctly set based on the provided parameters.Extracts and sets the is_submitted status from the parameters, which is crucial for controlling the editability of the response.
[[File:Validate submission status .png|900px]]

==== serialize_response ====
Improved to efficiently serialize response data for API interactions, enhancing the clarity and usability of data exchanges.

=== Response Controller ===
The ResponseController, originally extensive with numerous functions beyond basic CRUD operations, has been streamlined for our API application. In this context, there's no need to manage data variables for view pages, simplifying the handling of request data solely through request methods.To enhance the architecture and efficiency of our application, we've eliminated redundant methods and consolidated functionalities across the model, controller, and helper files. This restructuring was essential for refining the response endpoints specifically tailored for an API application.

Before we added Basic CRUD like New, Create, Update, edit, destroy.

Removed Methods: Legacy methods like Questionnaire_from_response_map and Questionnaire_from_response were removed following the refactoring of set_content, which now handles its functionalities internally without the need for these methods.

==== Show_calibration_results_for_student ====
Before:

[[File:Show calibration results for student reimplementation.PNG|900px]]

The old implementation also made use of database queries in the view. This will not be possible in the reimplemented Expertiza, and the required data will need to be made available in the JSON response sent by the controller.
[[File:DB access in view.PNG|900px]]
[[File:DB access in view 2.PNG|900px]]

The new show_calibration_results_for_student method retrieves and displays calibration and review responses based on provided map IDs. It fetches responses using these IDs, retrieves associated questions and answers, and returns the data as a formatted JSON object. If a response is not found, it returns an error indicating the missing response. The method handles any exceptions by returning a standard error message, ensuring robust error handling throughout the process.
Serves as an API endpoint to fetch detailed response data for a student's calibration and review tasks, providing all necessary details about the questions asked and the answers provided in both contexts

[[File:Show_calibration_results.png|900px]]

==== Init_answers ====

==== Save ====

=== Response Helper ===

The method create_update_answers(response, answers) was originally handling both the creation and updating of answer records within a single method:

[[File:Create_update_answers_before.png|900px]]

To improve code maintainability and adhere to the Single Responsibility Principle, this method has been divided into two distinct methods:

==== Create_answers ====
This method focuses solely on creating new answer records. It iterates over the answers provided, checking if each answer does not already exist in the database. If the answer does not exist, it creates a new record for that answer. This ensures that each answer is unique and prevents duplication.
[[File:Create_answers_after.png|900px]]

==== Update_answers ====
This method is responsible for updating existing answer records. It searches for existing answers in the database based on the response and question identifiers. If an answer is found, it updates the existing record with the new information provided. This method ensures that all modifications to answers are captured accurately and that the database is kept up-to-date.

[[File:Update_answers_after.png|900px]]

==Files Modified/Added==
List of primary files modified or created includes:
* responses_controller.rb
* response_helper.rb
* response.rb

==Test Plan==

The Model and Controller functions will be tested throughoughly.

Rspec unit tests will be used to test each function of the refactored and reimplemented functions to verify the expected responses are received for given inputs.

Unit tests will be written for the following model functions:

Unit tests will also be written for the controller functions:

The Swagger UI will be utilized to make the controller functions accessible VIA API calls. This will allow for testing of the input and outputs of the API calls to the methods, and will function as integration tests.

==Team==
===== Mentor=====
*Ameya Vaichalkar

=====Members=====
* Jeff Riehle
* Maday Moya
* Shardul Ladekar

==Links==
Swagger Video Link:

Pull request: https://github.com/expertiza/reimplementation-back-end/pull/92

Model Tests Video:

Controller Tests Video:

==References==

*

File:Show calibration results for student reimplimented.PNG

2024-04-23T04:50:21Z

Jriehle:

File:DB access in view 2.PNG

2024-04-23T04:48:53Z

Jriehle:

File:DB access in view.PNG

2024-04-23T04:48:36Z

Jriehle:

File:Show calibration results for student.PNG

2024-04-23T04:48:25Z

Jriehle:

CSC/ECE 517 Spring 2024 - E2415. Reimplement responses controller.rb (Design Document)

2024-04-23T04:27:48Z

Jriehle:

CSC/ECE 517 Spring 2024 - E2415: Reimplementation of responses_controller.rb (Design Document)

==Expertiza==
The Expertiza project, an open-source endeavor rooted in Ruby on Rails, embarks on continuous improvement to adapt and integrate modern software engineering practices. The Responses Controller is engineered to assist reviewers in submitting structured data that is specifically aligned with an assignment's rubrics, ensuring the provision of relevant questions for each round within the correct due date period. It enables a reviewer to evaluate and score the rubric questions pertinent to the assignment's topics. Furthermore, it ensures the delivery of appropriate questions for each assignment round, allowing reviewers to create and modify scores and comments for each of the rubric questions associated with the assignment. After reviewers submit their scored questions and comments, the Responses Controller dispatches an email notification to the instructor and the reviewed team's members.

==Problem Statement==
The ResponseController in Expertiza, a legacy system with conventions predating Rails standards, is overly complex, encompassing functionalities beyond basic CRUD operations and needing adherence to modern Rails naming and design principles. Key issues include the direct implementation of functionalities like sorting reviews and checking reviewer roles within the controller, suggesting a shift towards polymorphism and a more structured approach to code organization. Furthermore, the controller's handling of email notifications and feedback mechanisms is inconsistent, indicating the necessity for a dedicated helper to streamline communication processes. The reimplementation effort must focus on simplifying the controller, adhering to Rails conventions, and improving code readability and maintainability by appropriately distributing responsibilities.

==Design Goal==
The redesign of the `responses_controller.rb` is guided by several key objectives to improve the code quality, system behavior, and developer interaction. The goals include:

* Maintainability and Scalability: Ensuring the code is easy to understand, modify, and extend. The reimplementation should simplify future updates and feature additions.

* Adherence to Rails Best Practices: Following Rails conventions for naming, structure, and coding practices to ensure code consistency and reliability.

* DRY Principle: "Don't Repeat Yourself" - removing redundant code and logic to create a more efficient and error-resistant codebase.

* Single Responsibility Principle: Restructuring the controller and associated models so that each class and method has one purpose and one purpose only, leading to easier testing and management.

* Improved Testing and Coverage: Enhancing test suites to cover more scenarios and edge cases, increasing confidence in the application's stability and performance.

* Performance Optimization: Identifying and optimizing slow or inefficient areas in the code to ensure the application runs smoothly.

* Clean Up Dead Methods: Audit the codebase for any unused ("dead") methods within the current controller and remove them to declutter the code.

* Reduced Controller Complexity: We already have streamline the `ResponseController` to focus primarily on CRUD operations and extract non-essential logic to appropriate models or helpers, now we aim to implement the rest operations.

By meeting these design goals, the project aims to produce a `responses_controller.rb` that is robust, efficient, and a pleasure to work with, both for the current development team and for those who will maintain the system in the future.

== Design Pattern ==

During the code refactoring process, we conscientiously followed various design patterns to enhance the overall structure.
When refactoring the Response model and associated controller and helper methods in the application, several key design patterns and principles were followed to ensure improved code quality, maintainability, and scalability. Here are the primary patterns and principles that were considered:

=== Single Responsibility Principle (SRP) ===
This principle was applied to break down complex methods into smaller, more focused functions that handle a specific part of the process

*In the Response Model:
Validate_params was broken down into multiple smaller methods, each handling a specific part of the validation process. This allows each method to manage one aspect of the validation, making the code easier to maintain and modify.
Creation and management of relationships and basic attributes were clearly defined, ensuring that the Response class isn't overloaded with logic that doesn't pertain to its direct attributes or relationships.

*In the ResponsesController:
The controller methods like create, update, show, etc., were defined to handle only HTTP requests and delegate business logic to the model or helper methods. This keeps the controller actions clean and focused on routing and basic request handling.

*In the ResponseHelper:
Methods such as create_answers and update_answers are good examples where each method is tasked with either creating or updating answers but not both. This follows SRP by dividing the responsibilities into more manageable, discrete operations.

===Factory Method===
The Factory Method pattern can be seen implicitly where object creation processes are encapsulated within the model or helper methods, such as creating a new ResponseMap or generating new Answer objects. This ensures that object creation is modular and separated from the main application logic.
===Strategy Pattern===
By defining a family of algorithms (in this case, validation rules for different actions like create or update), encapsulating each one, and making them interchangeable, the strategy pattern lets the algorithm vary independently from the clients that use it. For instance, separating the validation conditions for creating and updating responses allows for flexible swapping and extension of validation logic without modifying the controller or model directly.
===Observer Pattern===
Used typically in scenarios where changes to a particular object need to notify other dependent objects automatically. In the context of this application, this could relate to notifying instructors or peers upon the submission or update of responses, handled through the helper methods for sending emails.
===Template Method===
This pattern can be used in defining the skeleton of an operation in a method, deferring some steps to subclasses or other methods. It's seen in how validate_params uses a general structure for validation but defers the specifics to methods like validate_create_conditions and validate_update_conditions.

By integrating these design patterns and principles, the refactoring aims to achieve a more robust, maintainable, and scalable system. This approach not only addresses current complexities but also lays a foundation for easier future enhancements and modifications.

== Solutions/Details of Changes Made==
=== Response Model ===
Methods within the response model were refactored or introduced, including:
==== set_content ====
Redesigned to gather and prepare the required data for response objects, optimizing the interaction with associated models
==== validate_params ====
This is the original method that was 46 lines long:

[[File:Validate parameters before.png|900px]]

===This method was significantly refactored to improve parameter validation. It was split into multiple smaller, focused methods, each dedicated to handling a specific aspect of the validation process. Each new method does one thing only, which makes them easier to understand and maintain.===
* assign_map_id_from_params: Sets the map_id for the response based on the provided parameters, ensuring the correct map ID is used for both creating and updating responses.
[[File:Assign map id.png|900px]]

*set_and_validate_response_map: Establishes and validates the presence of the response_map based on map_id. It's crucial to ensure that any response being created or updated is linked to a valid response map.This method attempts to find a ResponseMap based on map_id. If it fails to find one, it records an error and halts further validation, signaling an issue early in the process.
[[File:Set and validte response.png|900px]]

*set_response_attributes(params):Assigns additional attributes to the response object from the parameters. This centralizes attribute setting, reducing redundancy and errors.Directly extracts values like round, version_num, additional_comment, and visibility from the parameters and assigns them to the response object.
[[File:Set response attributes.png|900px]]

*action_specific_validation(params, action): Directs the validation flow based on whether the action is to create or update a response, organizing the logic clearly and preventing condition sprawl in the main validation method.Calls specific validation methods based on the action type: validate_create_conditions for creation and validate_update_conditions for updates.
[[File:Action specific validation.png|900px]]

*validate_create_conditions: Ensures that a new response doesn't duplicate an existing one under the same response map, round, and version number.Searches for an existing response that matches the current map_id, round, and version_num. If such a response exists, it adds a validation error and prevents the creation of a duplicate response.
[[File:Validate create condition.png|900px]]

*validate_update_conditions(params): Ensures that updates to a response are valid, specifically checking that a response isn't already submitted and that its map_id remains unchanged.Checks the submission status and whether there's an attempt to change the map_id. If either condition is violated, it records an error.
[[File:Validate update conditions.png|900px]]

*validate_submission_status(params): Updates the submission status of the response during the update process, ensuring the attribute is correctly set based on the provided parameters.Extracts and sets the is_submitted status from the parameters, which is crucial for controlling the editability of the response.
[[File:Validate submission status .png|900px]]

==== serialize_response ====
Improved to efficiently serialize response data for API interactions, enhancing the clarity and usability of data exchanges.

=== Response Controller ===
Controller methods for CRUD operations were enhanced, comprising:
==== Create ====
==== Show ====
==== Update ====
==== Delete ====
==== Questionnaire_from_response_map and Questionnaire_from_response ====
Removed Methods: Legacy methods like Questionnaire_from_response_map and Questionnaire_from_response were removed following the refactoring of set_content, which now handles its functionalities internally without the need for these methods.
==== Show_calibration_results_for_student ====
==== Init_answers ====
==== Save ====

=== Response Helper ===
==== Create_answers ====
==== Update_answers ====

==Files Modified/Added==
List of primary files modified or created includes:
* responses_controller.rb
* response_helper.rb
* response.rb

==Test Plan==

The Model and Controller functions will be tested throughoughly.

Rspec unit tests will be used to test each function of the refactored and reimplemented functions to verify the expected responses are received for given inputs.

Unit tests will be written for the following model functions:
*set_content
*validate_params
*serialize_response

Unit tests will also be written for the controller functions:
*Create
*Show
*Update
*Delete
*Questionnaire_from_response_map
*Questionnaire_from_response
*Create_answers
*Show_calibration_results_for_student
*Init_answers
*Save

The Swagger UI will be utilized to make the controller functions accessible VIA API calls. This will allow for testing of the input and outputs of the API calls to the methods, and will function as integration tests.

==Team==
===== Mentor=====
*Ameya Vaichalkar

=====Members=====
* Jeff Riehle
* Maday Moya
* Shardul Ladekar

==Links==
Swagger Video Link:

Pull request: https://github.com/expertiza/reimplementation-back-end/pull/92

Model Tests Video:

Controller Tests Video:

==References==

*

CSC/ECE 517 Spring 2024 - E2415. Reimplement responses controller.rb (Design Document)

2024-04-09T00:56:40Z

Jriehle: /* 8. Links */

CSC/ECE 517 Spring 2024 - E2415: Reimplementation of responses_controller.rb (Design Document)

==1.Expertiza==
The Expertiza project, an open-source endeavor rooted in Ruby on Rails, embarks on continuous improvement to adapt and integrate modern software engineering practices. The Responses Controller is engineered to assist reviewers in submitting structured data that is specifically aligned with an assignment's rubrics, ensuring the provision of relevant questions for each round within the correct due date period. It enables a reviewer to evaluate and score the rubric questions pertinent to the assignment's topics. Furthermore, it ensures the delivery of appropriate questions for each assignment round, allowing reviewers to create and modify scores and comments for each of the rubric questions associated with the assignment. After reviewers submit their scored questions and comments, the Responses Controller dispatches an email notification to the instructor and the reviewed team's members.

==2.Problem Statement==
The ResponseController in Expertiza, a legacy system with conventions predating Rails standards, is overly complex, encompassing functionalities beyond basic CRUD operations and needing adherence to modern Rails naming and design principles. Key issues include the direct implementation of functionalities like sorting reviews and checking reviewer roles within the controller, suggesting a shift towards polymorphism and a more structured approach to code organization. Furthermore, the controller's handling of email notifications and feedback mechanisms is inconsistent, indicating the necessity for a dedicated helper to streamline communication processes. The reimplementation effort must focus on simplifying the controller, adhering to Rails conventions, and improving code readability and maintainability by appropriately distributing responsibilities.

==3.Design Goal==
The redesign of the `responses_controller.rb` is guided by several key objectives to improve the code quality, system behavior, and developer interaction. The goals include:

* Maintainability and Scalability: Ensuring the code is easy to understand, modify, and extend. The reimplementation should simplify future updates and feature additions.

* Adherence to Rails Best Practices: Following Rails conventions for naming, structure, and coding practices to ensure code consistency and reliability.

* DRY Principle: "Don't Repeat Yourself" - removing redundant code and logic to create a more efficient and error-resistant codebase.

* Single Responsibility Principle: Restructuring the controller and associated models so that each class and method has one purpose and one purpose only, leading to easier testing and management.

* Improved Testing and Coverage: Enhancing test suites to cover more scenarios and edge cases, increasing confidence in the application's stability and performance.

* Performance Optimization: Identifying and optimizing slow or inefficient areas in the code to ensure the application runs smoothly.

* Clean Up Dead Methods: Audit the codebase for any unused ("dead") methods within the current controller and remove them to declutter the code.

* Reduced Controller Complexity: We already have streamline the `ResponseController` to focus primarily on CRUD operations and extract non-essential logic to appropriate models or helpers, now we aim to implement the rest operations.

By meeting these design goals, the project aims to produce a `responses_controller.rb` that is robust, efficient, and a pleasure to work with, both for the current development team and for those who will maintain the system in the future.

== 4. Implementation==
===4.1 Model ===
Methods within the model were refactored or introduced, including:
* 4.1.1 set_content
* 4.1.2 validate_params
* 4.1.3 serialize_response

=== 4.2 Controller ===
Controller methods for CRUD operations were enhanced, comprising:
* 4.2.1 Create
* 4.2.2 Show
* 4.2.3 Update
* 4.2.4 Delete
* 4.2.5 Questionnaire_from_response_map
* 4.2.6 Questionnaire_from_response
* 4.2.7 Create_answers
* 4.2.8 Show_calibration_results_for_student
* 4.2.9 Init_answers
* 4.2.10 Save

==5. Files Modified/Added==
List of primary files modified or created includes:
* responses_controller.rb
* response_helper.rb
* response.rb

==6. Test Plan==

The Model and Controller functions will be tested throughoughly.

1. Rspec unit tests will be used to test each function of the refactored and reimplemented functions to verify the expected responses are received for given inputs.

Unit tests will be written for the following model functions:
* set_content
* validate_params
* serialize_response

Unit tests will also be written for the controller functions:
* Create
* Show
* Update
* Delete
* Questionnaire_from_response_map
* Questionnaire_from_response
* Create_answers
* Show_calibration_results_for_student
* Init_answers
* Save

2. The Swagger UI will be utilized to make the controller functions accessible VIA API calls. This will allow for testing of the input and outputs of the API calls to the methods, and will function as integration tests.

==7. Team==
=====7.1 Mentor=====
*Ameya Vaichalkar

=====7.2 Members=====
* Jeff Riehle
* Maday Moya
* Jacob Leavitt

==8. Links==
Swagger Video Link:

Pull request: https://github.com/expertiza/reimplementation-back-end/pull/92

Model Tests Video:

Controller Tests Video:

==References==

*

CSC/ECE 517 Spring 2024 - E2415. Reimplement responses controller.rb (Design Document)

2024-04-09T00:50:44Z

Jriehle:

CSC/ECE 517 Spring 2024 - E2415: Reimplementation of responses_controller.rb (Design Document)

==1.Expertiza==
The Expertiza project, an open-source endeavor rooted in Ruby on Rails, embarks on continuous improvement to adapt and integrate modern software engineering practices. The Responses Controller is engineered to assist reviewers in submitting structured data that is specifically aligned with an assignment's rubrics, ensuring the provision of relevant questions for each round within the correct due date period. It enables a reviewer to evaluate and score the rubric questions pertinent to the assignment's topics. Furthermore, it ensures the delivery of appropriate questions for each assignment round, allowing reviewers to create and modify scores and comments for each of the rubric questions associated with the assignment. After reviewers submit their scored questions and comments, the Responses Controller dispatches an email notification to the instructor and the reviewed team's members.

==2.Problem Statement==
The ResponseController in Expertiza, a legacy system with conventions predating Rails standards, is overly complex, encompassing functionalities beyond basic CRUD operations and needing adherence to modern Rails naming and design principles. Key issues include the direct implementation of functionalities like sorting reviews and checking reviewer roles within the controller, suggesting a shift towards polymorphism and a more structured approach to code organization. Furthermore, the controller's handling of email notifications and feedback mechanisms is inconsistent, indicating the necessity for a dedicated helper to streamline communication processes. The reimplementation effort must focus on simplifying the controller, adhering to Rails conventions, and improving code readability and maintainability by appropriately distributing responsibilities.

==3.Design Goal==
The redesign of the `responses_controller.rb` is guided by several key objectives to improve the code quality, system behavior, and developer interaction. The goals include:

* Maintainability and Scalability: Ensuring the code is easy to understand, modify, and extend. The reimplementation should simplify future updates and feature additions.

* Adherence to Rails Best Practices: Following Rails conventions for naming, structure, and coding practices to ensure code consistency and reliability.

* DRY Principle: "Don't Repeat Yourself" - removing redundant code and logic to create a more efficient and error-resistant codebase.

* Single Responsibility Principle: Restructuring the controller and associated models so that each class and method has one purpose and one purpose only, leading to easier testing and management.

* Improved Testing and Coverage: Enhancing test suites to cover more scenarios and edge cases, increasing confidence in the application's stability and performance.

* Performance Optimization: Identifying and optimizing slow or inefficient areas in the code to ensure the application runs smoothly.

* Clean Up Dead Methods: Audit the codebase for any unused ("dead") methods within the current controller and remove them to declutter the code.

* Reduced Controller Complexity: We already have streamline the `ResponseController` to focus primarily on CRUD operations and extract non-essential logic to appropriate models or helpers, now we aim to implement the rest operations.

By meeting these design goals, the project aims to produce a `responses_controller.rb` that is robust, efficient, and a pleasure to work with, both for the current development team and for those who will maintain the system in the future.

== 4. Implementation==
===4.1 Model ===
Methods within the model were refactored or introduced, including:
* 4.1.1 set_content
* 4.1.2 validate_params
* 4.1.3 serialize_response

=== 4.2 Controller ===
Controller methods for CRUD operations were enhanced, comprising:
* 4.2.1 Create
* 4.2.2 Show
* 4.2.3 Update
* 4.2.4 Delete
* 4.2.5 Questionnaire_from_response_map
* 4.2.6 Questionnaire_from_response
* 4.2.7 Create_answers
* 4.2.8 Show_calibration_results_for_student
* 4.2.9 Init_answers
* 4.2.10 Save

==5. Files Modified/Added==
List of primary files modified or created includes:
* responses_controller.rb
* response_helper.rb
* response.rb

==6. Test Plan==

The Model and Controller functions will be tested throughoughly.

1. Rspec unit tests will be used to test each function of the refactored and reimplemented functions to verify the expected responses are received for given inputs.

Unit tests will be written for the following model functions:
* set_content
* validate_params
* serialize_response

Unit tests will also be written for the controller functions:
* Create
* Show
* Update
* Delete
* Questionnaire_from_response_map
* Questionnaire_from_response
* Create_answers
* Show_calibration_results_for_student
* Init_answers
* Save

2. The Swagger UI will be utilized to make the controller functions accessible VIA API calls. This will allow for testing of the input and outputs of the API calls to the methods, and will function as integration tests.

==7. Team==
=====7.1 Mentor=====
*Ameya Vaichalkar

=====7.2 Members=====
* Jeff Riehle
* Maday Moya
* Jacob Leavitt

==8. Links==
Swagger Video Link:

Pull request:

Model Tests Video:

Controller Tests Video:

==References==

*

CSC/ECE 517 Spring 2024

2024-04-09T00:49:55Z

Jriehle:

* [[CSC/ECE 517 Spring 2024 - E2401 Implementing and testing import & export controllers]]
* [[CSC/ECE 517 Spring 2024 - E2405 Refactor review_mapping_helper.rb]]
* [[CSC/ECE 517 Spring 2024 - E2407 Refactor review_mapping_controller.rb]]
* [[CSC/ECE 517 Spring 2024 - E2428 Replicate Roles and Institution UIs ReactJS]]
* [[CSC/ECE 517 Spring 2024 - E2429 Reimplement student_task list]]
* [[CSC/ECE 517 Spring 2024 - E2430 Reimplement student_task view]]
* [[CSC/ECE 517 Spring 2024 - E2410. View for Results of Bidding ]]
* [[CSC/ECE 517 Spring 2024 - E2414 Grading Audit Trail]]
* [[CSC/ECE 517 Spring 2024 - NTNX-1 : Extend NDB Operator to Support Postgres HA]]
* [[CSC/ECE 517 Spring 2024 - ‬NTNX-2‬‭ : Snapshot Functionality for provisioned databases]]
* [[CSC/ECE 517 Spring 2024 - E2411 : Fix "Back" link on “New Late Policy” page]]
* [[CSC/ECE 517 Spring 2024 - E2416. Reimplement the Question hierarchy]]
* [[CSC/ECE 517 Spring 2024 - E2420. Reimplement student_quizzes_controller]]
* [[CSC/ECE 517 Spring 2024 - E2424. Reimplement the Bookmarks Controller]]
* [[CSC/ECE 517 Spring 2024 - E2426. Create a UI for Assignment Edit page "Etc" tab in ReactJS]]
* [[CSC/ECE 517 Spring 2024 - E2417. Reimplement submitted content controller.rb]]
* [[CSC/ECE 517 Spring 2024 - E2417. Reimplement submitted content controller.rb (Phase 2)]]
* [[CSC/ECE 517 Spring 2024 - E2425. Create a Courses user interface in ReactJS]]
* [[CSC/ECE 517 Spring 2024 - E2431. Reimplement grades/view_team]]
* [[CSC/ECE 517 Spring 2024 - E2404 Refactor student teams functionality]]
* [[CSC/ECE 517 Spring 2024 - E2406 Refactor review_mapping_helper.rb]]
* [[CSC/ECE 517 Spring 2024 - E2403 Mentor-Meeting Management]]
* [[CSC/ECE 517 Spring 2024 - E2421. Reimplement impersonating users (within impersonate controller.rb)]]
* [[CSC/ECE 517 Spring 2024 - E2413. Testing - Answer Tagging]]
* [[CSC/ECE 517 Spring 2024 - E2412. Testing for hamer.rb]]
* [[CSC/ECE 517 Spring 2024 - E2427. UI for questionnaire.rb]]
* [[CSC/ECE 517 Spring 2024 - E2419. Reimplement duties controller.rb and badges controller.rb]]
* [[CSC/ECE 517 Spring 2024 - E2432. UI for Participants.rb]]
* [[CSC/ECE 517 Spring 2024 - G2402 Implement REST client, REST API, and Graphql API endpoint for repositories]]
* [[CSC/ECE 517 Spring 2024 - G2400 DevOp for GitHub Miner app]]
* [[CSC/ECE 517 Spring 2024 - E2439 Testing for view_translation_substitutor.rb]]
* [[CSC/ECE 517 Spring 2024 - E2443 Reimplement grades_controller]]
* [[CSC/ECE 517 Spring 2024 - E2434 Reimplement Frontend for the Grades view]]
* [[CSC/ECE 517 Spring 2024 - E2435 Implement Frontend for the My Profile]]
* [[CSC/ECE 517 Spring 2024 - E2446 Implement Front End for Student Task List]]
* [[CSC/ECE 517 Spring 2024 - E2444 Implement Frontend for the Review]]
* [[CSC/ECE 517 Spring 2024 - E2440 Testing for questionnaire_helper, review_bids_helper]]
* [[CSC/ECE 517 Spring 2024 - E2433 Implement UI for the Student Teams]]
* [[CSC/ECE 517 Spring 2024 - E2415. Reimplement responses controller.rb (Design Document)]]

CSC/ECE 517 Spring 2024 - E2415. Reimplement responses controller.rb (Design Document)

2024-04-09T00:46:51Z

Jriehle:

CSC/ECE 517 Spring 2024 - E2415: Reimplementation of responses_controller.rb (Design Document)

==1.Expertiza==
The Expertiza project, an open-source endeavor rooted in Ruby on Rails, embarks on continuous improvement to adapt and integrate modern software engineering practices. The Responses Controller is engineered to assist reviewers in submitting structured data that is specifically aligned with an assignment's rubrics, ensuring the provision of relevant questions for each round within the correct due date period. It enables a reviewer to evaluate and score the rubric questions pertinent to the assignment's topics. Furthermore, it ensures the delivery of appropriate questions for each assignment round, allowing reviewers to create and modify scores and comments for each of the rubric questions associated with the assignment. After reviewers submit their scored questions and comments, the Responses Controller dispatches an email notification to the instructor and the reviewed team's members.

==2.Problem Statement==
The ResponseController in Expertiza, a legacy system with conventions predating Rails standards, is overly complex, encompassing functionalities beyond basic CRUD operations and needing adherence to modern Rails naming and design principles. Key issues include the direct implementation of functionalities like sorting reviews and checking reviewer roles within the controller, suggesting a shift towards polymorphism and a more structured approach to code organization. Furthermore, the controller's handling of email notifications and feedback mechanisms is inconsistent, indicating the necessity for a dedicated helper to streamline communication processes. The reimplementation effort must focus on simplifying the controller, adhering to Rails conventions, and improving code readability and maintainability by appropriately distributing responsibilities.

==3.Design Goal==
The redesign of the `responses_controller.rb` is guided by several key objectives to improve the code quality, system behavior, and developer interaction. The goals include:

* Maintainability and Scalability: Ensuring the code is easy to understand, modify, and extend. The reimplementation should simplify future updates and feature additions.

* Adherence to Rails Best Practices: Following Rails conventions for naming, structure, and coding practices to ensure code consistency and reliability.

* DRY Principle: "Don't Repeat Yourself" - removing redundant code and logic to create a more efficient and error-resistant codebase.

* Single Responsibility Principle: Restructuring the controller and associated models so that each class and method has one purpose and one purpose only, leading to easier testing and management.

* Improved Testing and Coverage: Enhancing test suites to cover more scenarios and edge cases, increasing confidence in the application's stability and performance.

* Performance Optimization: Identifying and optimizing slow or inefficient areas in the code to ensure the application runs smoothly.

* Clean Up Dead Methods: Audit the codebase for any unused ("dead") methods within the current controller and remove them to declutter the code.

* Reduced Controller Complexity: We already have streamline the `ResponseController` to focus primarily on CRUD operations and extract non-essential logic to appropriate models or helpers, now we aim to implement the rest operations.

By meeting these design goals, the project aims to produce a `responses_controller.rb` that is robust, efficient, and a pleasure to work with, both for the current development team and for those who will maintain the system in the future.

== 4. Implementation==
===4.1 Model ===
Methods within the model were refactored or introduced, including:
* 4.1.1 set_content
* 4.1.2 validate_params
* 4.1.3 serialize_response

=== 4.2 Controller ===
Controller methods for CRUD operations were enhanced, comprising:
* 4.2.1 Create
* 4.2.2 Show
* 4.2.3 Update
* 4.2.4 Delete
* 4.2.5 Questionnaire_from_response_map
* 4.2.6 Questionnaire_from_response
* 4.2.7 Create_answers
* 4.2.8 Show_calibration_results_for_student
* 4.2.9 Init_answers
* 4.2.10 Save

==5. Files Modified/Added==
List of primary files modified or created includes:
* responses_controller.rb
* response_helper.rb
* response.rb

==6. Test Plan==

The Model and Controller functions will be tested throughoughly.

1. Rspec unit tests will be used to test each function of the refactored and reimplemented functions to verify the expected responses are received for given inputs.

Unit tests will be written for the following model functions:
* set_content
* validate_params
* serialize_response

Unit tests will also be written for the controller functions:
* Create
* Show
* Update
* Delete
* Questionnaire_from_response_map
* Questionnaire_from_response
* Create_answers
* Show_calibration_results_for_student
* Init_answers
* Save

2. The Swagger UI will be utilized to make the controller functions accessible VIA API calls. This will allow for testing of the input and outputs of the API calls to the methods, and will function as integration tests.

==Test Coverage==

==7. Team==
=====7.1 Mentor=====
*Ameya Vaichalkar

=====7.2 Members=====
* Jeff Riehle
* Maday Moya
* Jacob Leavitt

==8. Links==
Swagger Video Link:

Pull request:

Model Tests Video:

Controller Tests Video:

==References==

*

CSC/ECE 517 Spring 2024 - E2415. Reimplement responses controller.rb (Design Document)

2024-04-08T22:28:39Z

Jriehle: /* 7. Test Plan */

CSC/ECE 517 Spring 2024 - E2415: Reimplementation of responses_controller.rb (Design Document)

==1.Expertiza==
The Expertiza project, an open-source endeavor rooted in Ruby on Rails, embarks on continuous improvement to adapt and integrate modern software engineering practices. The Responses Controller is engineered to assist reviewers in submitting structured data that is specifically aligned with an assignment's rubrics, ensuring the provision of relevant questions for each round within the correct due date period. It enables a reviewer to evaluate and score the rubric questions pertinent to the assignment's topics. Furthermore, it ensures the delivery of appropriate questions for each assignment round, allowing reviewers to create and modify scores and comments for each of the rubric questions associated with the assignment. After reviewers submit their scored questions and comments, the Responses Controller dispatches an email notification to the instructor and the reviewed team's members.

==2.Problem Statement==
The ResponseController in Expertiza, a legacy system with conventions predating Rails standards, is overly complex, encompassing functionalities beyond basic CRUD operations and needing adherence to modern Rails naming and design principles. Key issues include the direct implementation of functionalities like sorting reviews and checking reviewer roles within the controller, suggesting a shift towards polymorphism and a more structured approach to code organization. Furthermore, the controller's handling of email notifications and feedback mechanisms is inconsistent, indicating the necessity for a dedicated helper to streamline communication processes. The reimplementation effort must focus on simplifying the controller, adhering to Rails conventions, and improving code readability and maintainability by appropriately distributing responsibilities.

==3.Design Goal==
The redesign of the `responses_controller.rb` is guided by several key objectives to improve the code quality, system behavior, and developer interaction. The goals include:

* Maintainability and Scalability: Ensuring the code is easy to understand, modify, and extend. The reimplementation should simplify future updates and feature additions.

* Adherence to Rails Best Practices: Following Rails conventions for naming, structure, and coding practices to ensure code consistency and reliability.

* DRY Principle: "Don't Repeat Yourself" - removing redundant code and logic to create a more efficient and error-resistant codebase.

* Single Responsibility Principle: Restructuring the controller and associated models so that each class and method has one purpose and one purpose only, leading to easier testing and management.

* Improved Testing and Coverage: Enhancing test suites to cover more scenarios and edge cases, increasing confidence in the application's stability and performance.

* Performance Optimization: Identifying and optimizing slow or inefficient areas in the code to ensure the application runs smoothly.

* Clean Up Dead Methods: Audit the codebase for any unused ("dead") methods within the current controller and remove them to declutter the code.

* Reduced Controller Complexity: We already have streamline the `ResponseController` to focus primarily on CRUD operations and extract non-essential logic to appropriate models or helpers, now we aim to implement the rest operations.

By meeting these design goals, the project aims to produce a `responses_controller.rb` that is robust, efficient, and a pleasure to work with, both for the current development team and for those who will maintain the system in the future.

==4.Class UML Diagram==

== 5. Implementation==
===5.1 Model ===
Methods within the model were refactored or introduced, including:
* 5.1.1 set_content
* 5.1.2 validate_params
* 5.1.3 serialize_response

=== 5.2 Controller ===
Controller methods for CRUD operations were enhanced, comprising:
* 5.2.1 Create
* 5.2.2 Show
* 5.2.3 Update
* 5.2.4 Delete
* 5.2.5 Questionnaire_from_response_map
* 5.2.6 Questionnaire_from_response
* 5.2.7 Create_answers
* 5.2.8 Show_calibration_results_for_student
* 5.2.9 Init_answers
* 5.2.10 Save

==6. Files Modified/Added==
List of primary files modified or created includes:
* responses_controller.rb
* response_helper.rb
* response.rb

==7. Test Plan==

The Model and Controller functions will be tested throughoughly.

1. Rspec unit tests will be used to test each function of the refactored and reimplemented functions to verify the expected responses are received for given inputs.

Unit tests will be written for the following model functions:
set_content
validate_params
serialize_response

Unit tests will also be written for the controller functions:
Create
Show
Update
Delete
Questionnaire_from_response_map
Questionnaire_from_response
Create_answers
Show_calibration_results_for_student
Init_answers
Save

2. The Swagger UI will be utilized to make the controller functions accessible VIA API calls. This will allow for testing of the input and outputs of the API calls to the methods, and will function as integration tests.

==Test Coverage==

==8. Team==
=====8.1 Mentor=====
*Ameya Vaichalkar

=====8.2 Members=====
* Jeff Riehle
* Maday Moya
* Jacob Leavitt

==9. Links==
Swagger Video Link:

Pull request:

Model Tests Video:

Controller Tests Video:

==References==

*

CSC/ECE 517 Spring 2024 - E2415. Reimplement responses controller.rb (Design Document)

2024-04-08T02:42:12Z

Jriehle: /* 1.Expertiza */

CSC/ECE 517 Spring 2024 - E2415. Reimplement responses controller.rb (Design Document)

2024-04-08T02:41:22Z

Jriehle: /* 2.Problem Statement */

CSC/ECE 517 Spring 2024 - E2415: Reimplementation of responses_controller.rb (Design Document)

==1.Expertiza==

==2.Problem Statement==
The ResponseController in Expertiza, a legacy system with conventions predating Rails standards, is overly complex, encompassing functionalities beyond basic CRUD operations and needing adherence to modern Rails naming and design principles. Key issues include the direct implementation of functionalities like sorting reviews and checking reviewer roles within the controller, suggesting a shift towards polymorphism and a more structured approach to code organization. Furthermore, the controller's handling of email notifications and feedback mechanisms is inconsistent, indicating the necessity for a dedicated helper to streamline communication processes. The reimplementation effort must focus on simplifying the controller, adhering to Rails conventions, and improving code readability and maintainability by appropriately distributing responsibilities.

==3.Design Goal==

==4.Class UML Diagram==

== 5. Implementation==
===5.1 Model ===
Methods within the model were refactored or introduced, including:
* 5.1.1 set_content
* 5.1.2 validate_params
* 5.1.3 serialize_response

=== 5.2 Controller ===
Controller methods for CRUD operations were enhanced, comprising:
* 5.2.1 Create
* 5.2.2 Show
* 5.2.3 Update
* 5.2.4 Delete

==6. Files Modified/Added==
List of primary files modified or created includes:
* responses_controller.rb
* response_helper.rb
* response.rb

==7. Test Plan==

===Testing model methods===

==Test Coverage==

==8. Team==
=====8.1 Mentor=====
*Ameya Vaichalkar

=====8.2 Members=====
* Jeff Riehle
* Maday Moya
* Jacob Leavitt

==9. Links==
Swagger Video Link:

Pull request:

Model Tests Video:

Controller Tests Video:

==References==

*

CSC/ECE 517 Spring 2024 - E2427. UI for questionnaire.rb

2024-03-25T01:38:10Z

Jriehle: /* Contributors to this project */

== Overview of Expertiza ==
Expertiza, constructed using Ruby on Rails, is an open-source learning management system that offers a diverse array of features. These include the ability to generate assignments, tests, assignment teams, and courses. Notably, it excels in providing a comprehensive peer review system, fostering thorough feedback within teams and among group members. The central focus of the project revolves around enhancing the frontend components related to the Questionnaire. A specific challenge being tackled involves restructuring the current non-Typescript questionnaire UI to incorporate Typescript. Consequently, the team's task is to craft the User Interface for these components using React.js and Typescript.

== Description of the Project ==

* Objective: Refactor the non-Typescript frontend questionnaire UI of Expertiza to use Typescript and develop the User Interface using React.js and Typescript.

* Key Tasks:
** Log in as a Super Admin.
** Replicate the 'Administration' and 'Institution' UIs using ReactJS, ensuring they retain full functionality within the new TypeScript and ReactJS framework.

* Development Process:
** Understand the Existing System: Analyze the current Ruby on Rails implementation of Questionnaire UIs, including data models, controllers, and views.
** Setup Development Environment: Establish a TypeScript and ReactJS environment for developing the new UIs.
** Design Components: Create React components corresponding to UI parts, focusing on state and props management.
** Implement Components: Develop these components in TypeScript, mirroring the existing UIs' functionality.
** Integrate Components: Incorporate the new components into the main application, ensuring compatibility and functionality with the backend.
** Review and Refactor: Enhance code quality through reviews and refactoring, emphasizing readability and efficiency.

* Additional Features and Improvements:
** Enhance UI with tooltips, improved table positioning, and pagination.
** Introduce a new search functionality to search for questionnaires based on the query.
** Introduce the sorting functionality to sort questionnaires based on the query.
** Enhance code quality by adding comments, removing obsolete code, and implementing form validations.

* Outcome: The project aims to transition the Expertiza UI component for 'Questionnaire' from Ruby on Rails to a more modern, efficient TypeScript and ReactJS-based implementation, incorporating user role restrictions and various UI improvements for a better user experience.

== Technologies Used ==

* '''React.js''': A JavaScript library for building user interfaces, particularly single-page applications. React will be used to develop dynamic and responsive UI components.

* '''TypeScript''': An open-source language that builds on JavaScript by adding static type definitions. TypeScript allows for writing clearer and more robust code, facilitating easier debugging and maintenance.

* '''Ruby on Rails''': Although the focus is on refactoring the front end, understanding the existing Ruby on Rails backend is crucial. Rails is a server-side web application framework written in Ruby, following the model-view-controller (MVC) framework.

== Changes Made ==

1. '''Refactored the Questionnaire UI''': The transition of the questionnaire UI frontend from its original non-TypeScript state to now fully incorporating TypeScript has been completed successfully, enhancing the code's reliability and ease of maintenance.

2. '''Developed with React.js and Typescript''': The 'Questionnarie' user interface have been rebuilt using React.js and Typescript, ensuring dynamic and responsive behavior. The React components created are modular, reusable, and effectively manage state.

3. '''Analyzed Existing Backend''': An in-depth analysis and comprehension of the current Ruby on Rails backend were attained to ensure the seamless integration and functionality with the new TypeScript and React.js frontend.

4. '''UI Enhancements Implemented''':
a. The UI has been updated to match the rest of the Expertiza APP.
b. Buttons to edit and delete table entries are included inline.
c. A button to add new entries is added above and on the right of the table.
d. Pagination is included for the table to accommodate multiple questionnaires.
e. Added the search functionality on top of the table to search for a particular Questionnarie.
f. Clicking the button to add a new questionnaire opens a pop up box to fill in the name of the new Questionnarie.
g. Added the functionality to sort the surveys alphabetically (Name wise) in ascending or descending order.

6. '''Enhancements in Code Quality and Maintenance''':
Thorough documentation and detailed comments have been incorporated into the new codebase to enhance readability and facilitate ongoing maintenance.
Obsolete or redundant code segments have been systematically removed, optimizing the application's efficiency.
Validators and robust error-handling mechanisms have been integrated to fortify the UI's resilience.

7. '''Comprehensive Testing and Seamless Integration''':
The new UI components underwent rigorous testing, both in isolation and within the application's operational framework, ensuring precise functionality across diverse scenarios and datasets.
Seamless integration of the new components into the existing application infrastructure was meticulously executed to uphold compatibility and operational coherence.

8. '''Review and Deployment Accomplished''':
Collaborative code reviews were conducted with the development team to identify and implement potential enhancements or essential adjustments.
The deployment of the updated application was meticulously prepared and executed, guaranteeing a seamless transition devoid of disruptions to the existing user base.

== UI Enhancements and Features in Screenshots ==

The UI has been updated to match the rest of the Expertiza APP.
[[File:UI.jpeg |1000px|center]]
UI looks similar to Expertiza with Pagination at bottom

Button to 'Edit' and 'Delete' were added inline. Also Added 'Tooltips' to 'Edit' and 'Delete' as well as 'Create New Questionnarie' Buttons.

[[File:Edit-questionnarie.jpeg |1000px|center]]
Edit Button Tooltip

[[File:Delete-questionnarie.jpeg |1000px|center]]
Delete Button Tooltip

[[File:Questionnarie.jpeg |1000px|center]]
New Questionnarie Button Tooltip

Adding a new questionnaire, editing an existing questionnaire ,or deleting a questionnaire results in a pop-up box to perform respective individual functionality
[[File:new-survey.jpeg |500px|center]]
New questionnaire Pop-up Box

[[File:edit-survey.jpeg |500px|center]]
Edit questionnaire Pop-up Box

[[File:delete-survey.jpeg |500px|center]]
Delete questionnaire Pop-up Box

Added the search functionality on top of the table to search for a particular questionnaire.
[[File:Search-bar.jpeg |1000px|center]]
Search Bar search for matching questionnaire

Sorting the Questionnaires Alphabetically (Ascending as well as Descending)
[[File:sort.jpeg |300px|center]]
Sorting questionnaire functionality

== Testing ==

Testing was initially excluded from the project's scope, as the focus was on frontend development. Nevertheless, ensuring the functionality and user experience of a website's interface is crucial. Therefore, manual testing procedures will be used to validate the correct operation of the UI components. These procedures include:

# Verifying all the added button links to ensure they function correctly.
# Testing whether the Search Bar accurately searches the matching questionnaire.
# Testing whether sorting functionality displays the result in correct ascending and descending order.

== Contributors to this project ==
* '''Mitesh Agarwal''' (unityid: magarwa3, github: mitesh24100)
* '''Jeff Riehle''' (unityid: jriehle, github: jriehle)
* '''Shubham Loya''' (unityid: ssloya, github: crmgogo)
* '''Github repo''' https://github.com/jriehle/reimplementation-front-end
* '''Link to PR''' https://github.com/expertiza/reimplementation-front-end/pull/41