Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Spring 2022 - E2238. Implementing and testing Import & Export controllers

2022-04-26T00:04:53Z

Pvemuri: /* Proposed Design Change */

== Team==
=== Mentor ===

* Vinay Deshmukh

=== Team Members ===

*Bollineni, Rachana Sri rbollin@ncsu.edu
*Nangia, Chirrag - cnangia@ncsu.edu
*Priyadarshan, Saswat - spriyad2@ncsu.edu
*Vemuri, Pradyumna pvemuri@ncsu.edu

== Project Purpose & Description ==

The export/import feature is the most helpful feature for instructors to set up assignments. The instructors usually have a list of students, teams, etc from their learning management system. Being able to export/import these into expertiza saves a lot of time when setting up an assignment.

Expertiza provides multiple export and import features for eg. export students, teams etc. Essentially what it does is it fetches some data from the database and saves it as a file in the desired format. However, the same functionality is implemented multiple times for exporting and importing different things. The aim of this project is to design a generic export/import feature that can be used across the application. This will help in maintaining the codebase and keep things consistent throughout.

== Current Project Scope ==

A generic import_file_controller has already been experimented with in Project E1923: https://github.com/expertiza/expertiza/pull/1438
But as discussed with the professor and the mentors, the PR hasn’t been merged, and it’s not known whether the code was correct or it had issues. And given the existing code has lots of if-else, it would be better to rewrite it from scratch.

'''Below listed are our primary goals for this project:'''
* Redo the code for import_file_controller.rb and export_file_controller.rb, by referring to the code in the pull request. Our plan of action is to rewrite the code than try to refactor it, as it’s not known whether the code in the PR is correct.
* Write test cases for the new import_file_controller and the existing export_file_controller.
* Find and fix the existing bugs in the import and export process flows.

== Extended Project Scope ==

'''Below listed is the stretch goal for this project. We'll try to pick it only if the time permits.'''

* After the functionality is fixed, the next step is to leverage the import and export controllers for importing/exporting users, topics, teams, questionnaires, and grades. Initially, High Priority modules are users, topics, and grades, and then move on to the other modules.

== Existing Import/Export Controller design ==

The existing import and export functionality primarily uses the '''import_file_controller''' and '''export_file_controller'''.

SignUpTopic and User, rely on helper classes that extract attributes from a hash and create an ActiveRecord object.

The questionnaire relies on a helper method that can import Question objects (objects that make up a Questionnaire) from a CSV and adjust the size of the associated QuestionAdvice (the words that pop up after you pick a certain number of stars). However, these functions might be deprecated, as it appears that Question importing is now routed through the ImportFileController unsuccessfully. More detail about specific functions is provided below.

=== Controllers ===

*'''import_file_controller''', the list of methods in the controller are the following:
** File processing methods:
*** #get_delimiter - Sets proper delimiter for filetype
*** #parse_line - Processes line (row) of the file
*** #parse_to_grid - Turns file into 2D array
*** #parse_to_hash - Turns file into hash where 'header' stores header row and 'body' stores all contents.
*** #hash_rows_with_headers - Creates hash for each row of file. Keys are headers, values are row values.
** Import methods:
*** #import_from_hash - Primary import functionality. Creates objects for hashed rows (from #hash_rows_with_headers).
*** #import - Larger controller of import, sets error messages and displays.

*'''questionnaires_controller''', the list of methods in the controller are the following:
** ::import - Allows import from CSV using QuestionnaireHelper (Appears to be deprecated/unused)

*'''export_file_controller''', the list of methods in the controller are the following:
** ::find_delim_filename - Sets and returns attributes for User object from hash.
** ::exportdetails - Generates the metadata for the data that needs to be exported.
** ::export - Converts the data into CSV format files.
** ::export_advices - Export question advice data to CSV file.
** ::export_tags - Export the tags.

=== Helpers ===
*'''import_file_helper''', the list of methods in the file are the following:
** ::create_new_user - Makes a user object in the database.

*'''import_topics_helper''', the list of methods in the file are the following:
** ::define_attributes - Find the filename and delimiter.

*'''questionnaire_helper''' (Appears to be deprecated/unused), the list of methods in the file are the following:
** ::get_questions_from_csv - Allows Question and QuestionAdvice import/creation with CSV file.

== Proposed Design Change ==
* Search for occurrences of “import” and “export” to find all the valid models that can be imported or exported.
* Identify the flow of import/export functionality involving those models and figure out whether they are using import_file_controller/export_file_controller or using their own logic to perform these actions.
* Once all the involved pieces are identified, we will change the code to ensure that all the involved modules make use of the new import_file_controller/export_file_controller.
* Once everything is in working condition, we will proceed with testing.

Everything should work as expected based on our analysis so far. However, there are a few models which use the import/export functionality and have very different structures. We need to create helper methods for them to make the imports and exports specific to those models leveraging the common controllers created.

'''In a more generic way, this is how the import functionality is working as of now (taking one example for simplicity):'''

[[Image: badUML.png]]

Import_file_controller is used for importing the data of team and course_participant models in a CSV. Questionnaires_controller is being used to import data of the question model.

'''What we want it to look like: UML Diagram'''

[[Image: Ic usecase.png|600px]]

[[Image: EC usecase.png|600px]]

A generic import_file_controller/export_file_controller should be used for importing/exporting the data of all modules i.e., team, course_participant and questions model.

Refer to the above PR (https://github.com/expertiza/expertiza/pull/1438) for reference.
The major part of our effort will be targeted at rewriting this import_file_controller controller and removing the pieces which are breaking. Once we achieve that, we will create helper methods specific to each method and leverage the controllers to do the import and export in a consistent fashion across the application.

== Actual Changes Made ==

* ''' Analyzing Export Functionality code flow ''' - We started by analyzing the code flow of export_file_controller.rb and whether it is being used by different models to export data or not. '''The models we focussed on are Users, Grades and Topics'''. On analyzing the code we found that all these three models are using the export_file_controller.rb to generate the respective CSVs. However, there were a few bugs that we found in the existing ''' Export Grades ''' functionality. We debugged this flow completely and fixed those bugs. The bugs and their corresponding fixes are mentioned below in the ''' Bug Fixes ''' section. Apart from that, there was no ''' Export Topics ''' functionality present in the system. We created a completely new flow for exporting the topics leveraging the existing export_file_controller logic to keep the modules consistent. More information about the new features added can be found in the ''' New Features Added ''' section.

* ''' Analyzing Import Functionality code flow ''' - We analyzed the code flow of import_file_controller.rb and whether it is being used by different models to export data or not. '''The models we focussed on are Users, and Topics'''. On analyzing the code we found that these two models are using the export_file_controller.rb to import the respective CSVs with required data. However, we found a few bugs in the Import Topics functionality and we fixed those. The bugs and their corresponding fixes are mentioned below in the ''' Bug Fixes ''' section.

Analysis of these two workflows (Export and Import) took a considerable amount of our time since there were a lot of moving pieces present in these controllers. We had to manually test these flows for different models because of the different data and customizations present.

* '''Test Cases for export_file_controller''' - After we finished the analysis and development of the required features for the export functionality, we proceeded with writing the test cases for the export_file_controller.rb file. There were no test cases present for this file and we wrote all the test cases from scratch. Our test cases revolve around these '''models (Users, Grades and Topics)''' since the methods inside these controllers are pretty big and contain a lot of if-else for different models.

* '''Test Cases for import_file_controller''' - After we finished the analysis and development of the required features for the import functionality, we proceeded with writing the test cases for the import_file_controller.rb file. There were no test cases present for this file and we wrote all the test cases from scratch. Our test cases revolve around these '''models (Users and Topics)''' since the methods inside these controllers are pretty big and contain a lot of if-else for different models.

== New Features Added ==

*'''Export Topics''' - The Export Topics Feature was not present in the application. You can navigate to Export Topics by going to '''Assignments > Click on Edit (pencil icon) > Click on Topics menu'''. Once you click the Export Topics button, you will be taken to a customizations page where you can select what columns you want in your CSV file. You can select/deselect the options by clicking on the checkboxes provided. Once you select the desired cloumns, click on the export button to generate the CSV file. The Export Topics and Customizations pages are attached below.

[[File:Export Topics.png|800x520px]]

[[File:Customization.png|800x520px]]

*'''''Code Changes for Export Topics'''''

[[File:C1.png|800x520px]]

[[File:C2.png|800x520px]]

[[File:C3.png|800x520px]]

[[File:C4.png|800x520px]]

[[File:C5.png|800x520px]]

[[File:C6.png|800x520px]]

== Bug Fixes ==

On analyzing the code flow for import and export functionality we found that the '''Export Grades''' functionality was broken. There were a few things that were creating problems in this flow. Mentioned below are the fixes that we made in this flow:

*'''Fix 1: Export grades into a file successfully''' - When exporting grades, self.export method of Assignment.rb is called. This internally calls review_grades method in Scoring.rb. But review_grades method was not being invoked because it was being called from a class method but was imported as an instance method. Then self.export method internally invokes self.export_data method. Some lines related to the business logic were missing here.

[[File:Bug1.png|800x520px]]

*'''''Code Changes for Fix 1: Export grades into a file successfully'''''

[[File:Fix1 code.png|800x520px]]

*'''Fix 2: Incorrect headers in the exported file''' - During the export, the generated CSV had some issues with the headers. A few headers were not separated into multiple columns which was not the desired result. We fixed those as well.
[[File:Incorrect grouped column.jpeg|800x520px]]

*'''''Code Changes for Fix 2: Incorrect headers in the exported file'''''

[[File:Fix2 code.png|800x520px]]

*'''Fix 3: Only export selected columns from the UI''' - Removed author feedback score from being exported. What happens in the file?
** Problem 1: The meta-review feedback column is removed but the author feedback header still shows up.
** Problem 2: Also only the headers have changed but all values of all columns are still being exported.

[[File:E3.png|800x520px]]

[[File:E3 1.png|800x520px]]

*'''''Code Changes for Fix 3: Only export selected columns from the UI'''''

[[File:Fix3 code.png|800x520px]]

*'''Fix 4: Category, Description, and Link were not being updated in the database while importing the CSV using the Import Topics button''' - We tried importing the topics.csv and it imported all the data except the Category, Description, and Link columns. These columns were optional columns and when we selected the checkboxes for these, the data was not persisted in the database. We debugged this workflow and fixed this bug.

*'''''Code Changes for Fix 4: Category, Description, and Link were not being updated in the database while importing the CSV using the Import Topics button'''''

[[File:Fix 4.png|800x520px]]

== Test Plan ==

Writing test cases for '''import_file_controller''' and '''export_file_controller'''. We would be focussing on writing test cases for the controllers and the helpers that we will create specific to the models.

Now we have only 5 methods in the export_file_controller class that we need to test. Five methods in the export_file_controller class that needed to be tested were:
*'''action_allowed''' - This is a method that calls "current_user_has_ta_privileges?" to ensure that the current user has the proper privileges to perform the export operation. We write a test for this method expecting that a user calling the method has required permissions.
*'''exportdetails'' - This method fetches the delimiter and the file name required to perform the export operation. It also stores additional metadata from the Assignments class in a CSV file. We will test this method by verifying whether the export process works with supported model types.
*'''export''' - This is the main method that does the actual exporting task. It gathers all the necessary data such as - assignment, course, participant id, team, questions, answers, reviews, etc, and saves the data unless the model is not supported. We will test this method by verifying whether the export process works with supported model types.
*'''export_advices''' - This method is similar to export but only exports "Question" type models along with "QuestionAdvice". We will test this method by checking if the correct data is being exported.
*'''export_tags''' - This method exports the user's answers with their respective tags and comments. We will test this method by checking if the correct data is being exported.

For the import_file_controller class, we identified the following methods to be tested:
*'''action_allowed''' - Similar to the one in export_file_controller, this is a method that in turn calls "current_user_has_ta_privileges?" to ensure that the current user has the proper privileges to perform the import operation. We write a test for this method expecting that a user calling the method has required permissions.
*'''show''' - This method stores necessary metadata required to perform import operations such as - user id, delimiters, header, and also additional information such as the assignment id and team number. We write a test to check whether the necessary variables in the method are populated.
*'''import''' - The import method is used to verify the hash header or body, and generate error messages if needed. We will be writing a test to verify if this method can throw an error if something goes wrong with the import process.

== Execution of Test Plan ==

To run the test cases for '''export_file_controller''' use the command - '''''rspec spec/controllers/export_file_controller_spec.rb'''''

To run the test cases for '''import_file_controller''' use the command - '''''rspec spec/controllers/import_file_controller_spec.rb'' ''''

We wrote the test cases for the above-mentioned methods focussing on the ''' models (Users, Topics and Grades) ''' since these were the high priority models assigned to us. Our Test Coverage so far is as follows:

*'''''export_file_controller test coverage - 54.84%'''''

[[File:Export test coverage.png|800x520px]]

*'''''import_file_controller test coverage - 52.43%'''''

[[File:Import test coverage.png|800x520px]]

We also implemented '''''fixtures''''' for testing the generated CSVs. This is a new concept that was not implemented earlier in this project and can be leveraged in future to test the CSVs. This provides the developers ability to test the Export and Import functionalities for CSV files.

We did not attach the code difference screenshots for the test cases because it was quite big. Kindly refer to the PR to view the code changes for the test cases corresponding to '''export_file_controller''' and '''import_file_controller'''.

== '''''Link to Pull Request:''''' https://github.com/expertiza/expertiza/pull/2396 ==

File:EC usecase.png

2022-04-26T00:03:23Z

Pvemuri:

File:Ic usecase.png

2022-04-26T00:02:41Z

Pvemuri:

CSC/ECE 517 Spring 2022 - E2238. Implementing and testing Import & Export controllers

2022-04-12T02:07:56Z

Pvemuri: /* Proposed Design Change */

File:Export usecase.png

2022-04-12T02:05:15Z

Pvemuri:

File:Import usecase.png

2022-04-12T02:01:01Z

Pvemuri:

CSC/ECE 517 Spring 2022 - E2238. Implementing and testing Import & Export controllers

2022-04-12T01:18:31Z

Pvemuri: /* Test Plan */

CSC/ECE 517 Spring 2022 - E2238. Implementing and testing Import & Export controllers

2022-04-12T01:00:53Z

Pvemuri: /* Test Plan */

CSC/ECE 517 Spring 2022 - E2238. Implementing and testing Import & Export controllers

2022-04-12T01:00:23Z

Pvemuri: /* Test Plan */

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-28T02:14:27Z

Pvemuri: /* Pull Request */

==About Expertiza==
Expertiza is a multi-purpose web application built using Ruby on Rails for Students and Instructors. Instructors enrolled in Expertiza can create and customize classes, teams, assignments, quizzes, and many more. On the other hand, Students are also allowed to form teams, attempt quizzes, and complete assignments. Apart from that, Expertiza also allows students to provide peer reviews enabling them to work together to improve others' learning experiences. It is an open-source application and its Github repository is [https://github.com/expertiza/expertiza Expertiza].
==E2215. Refactoring student_quizzes_controller.rb in Expertiza==
This page is a description of Expertiza OSS project E2215, which is refactoring the student_quizzes_controller.rb file.

==Controller Description==
The student_quizzes_controller consists of methods involved in creating, scoring & recording responses of the quizzes taken by reviewers or students of the other teams with the same assignment. This controller has some issues that violate essential Rails design principles such as the DRY principle. There are a few methods in this controller that should have been in model classes. Some methods share code, which creates code repetition. Some method comments need to be rewritten.

==Files Modified==
1. app/controllers/'''student_quizzes_controller.rb''' 2. app/views/student_quizzes/f'''inished_quiz.html''' 3. app/helpers/'''student_quizzes_helper.rb'''

==Modifications made to the existing code==
'''1. Modification - ''' Added comments for custom methods in this controller explaining the purpose. 

<pre>
# Based on the logged in user, verifies user's authourizations and privileges
def action_allowed?
</pre>
<pre>
# Initializes instance variables needed to fetch the necessary details of the quizzes.
def index
</pre>
<pre>
# For the response provided, this methods displays the questions, right/wrong answers and the final score.
def finished_quiz
</pre>
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
def self.take_quiz(assignment_id, reviewer_id)
</pre>
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
def record_response
</pre>
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
def review_questions
</pre>
<pre>
# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
</pre>
<pre>
# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>
<pre>
# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>

'''2. Modification - ''' Line 29 - .first has been changed to .last to count the score of the most recent attempt of the quiz. 
student_quizzes_controller.rb: 
Old:
<pre>
@response = Response.where(map_id: params[:map_id]).first
</pre>
New:
<pre>
@response = Response.where(map_id: params[:map_id]).last
</pre>

'''3. Modification - ''' Line 33 - @map has been renamed to @quiz_response_map to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@map = ResponseMap.find(params[:map_id])
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
@quiz_response_map = ResponseMap.find(params[:map_id])
@quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>

'''4. Modification - ''' Line 34 - @participant has been changed to @quiz_taker to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>
finished_quiz.html.erb: 
Old:
<pre>
<% @assignment = Assignment.find(@participant.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @participant, :stage => ""} %>
</pre>
New:
<pre>
<% @assignment = Assignment.find(@quiz_taker.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @quiz_taker, :stage => ""} %>
</pre>

'''5. Modification - ''' Line 39 - The method comment of self.take_quiz has been updated to describe its function 
student_quizzes_controller.rb: 
Old:
<pre>
# Gives details of the list of quizzes created by other teams for current project that a reviewer can take
</pre>
New:
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
</pre>

'''6. Modification - ''' Controller Method calculate_score has been split into three separate functions since the original method is too big and is split to use the other methods to handle score calculation for Single choice / True or False questions and Multiple answer questions separately. Then all three methods have been moved to student_quizzes_helper.rb file since they are being reused. 
student_quizzes_helper.rb: 
New:
<pre>
module StudentQuizzesHelper

# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
questionnaire = Questionnaire.find(map.reviewed_object_id)
answers = []
has_response = true
questions = Question.where(questionnaire_id: questionnaire.id)
questions.each do |question|
correct_answers = QuizQuestionChoice.where(question_id: question.id, iscorrect: true)
ques_type = question.type
if ques_type.eql? 'MultipleChoiceCheckbox'
has_response = multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
# TrueFalse and MultipleChoiceRadio
else
has_response = single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
end
end
if has_response
answers.each(&:save)
redirect_to controller: 'student_quizzes', action: 'finished_quiz', map_id: map.id
else
response.destroy
flash[:error] = 'Please answer every question.'
redirect_to action: :take_quiz, assignment_id: params[:assignment_id], questionnaire_id: questionnaire.id, map_id: map.id
end
end

# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
score = 0
if params[question.id.to_s].nil?
has_response = false
else
params[question.id.to_s].each do |choice|
# loop the quiz taker's choices and see if 1)all the correct choice are checked and 2) # of quiz taker's choice matches the # of the correct choices
correct_answers.each do |correct|
score += 1 if choice.eql? correct.txt
end
end
score = score == correct_answers.count && score == params[question.id.to_s].count ? 1 : 0
# for MultipleChoiceCheckbox, score =1 means the quiz taker have done this question correctly, not just make select this choice correctly.
params[question.id.to_s].each do |choice|
new_answer = Answer.new comments: choice, question_id: question.id, response_id: response.id, answer: score

has_response = false unless new_answer.valid?
answers.push(new_answer)
end
end
return has_response
end

# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
correct_answer = correct_answers.first
score = correct_answer.txt == params[question.id.to_s] ? 1 : 0
new_score = Answer.new comments: params[question.id.to_s], question_id: question.id, response_id: response.id, answer: score
has_response = false if new_score.nil? || new_score.comments.nil? || new_score.comments.empty?
answers.push(new_score)
return has_response
end

end
</pre>

'''7. Modification - ''' Line 60 - A method comment has been added for record_response to describe its function 
student_quizzes_controller.rb: 
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
</pre>

'''8. Modification - ''' -graded? has been removed as it is no longer necessary. 

'''9. Modification - ''' Line 72 - The Flash message has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
flash[:error] = 'You have already taken this quiz, below are the records for your response.'
</pre>
New:
<pre>
flash[:error] = 'You have already taken this quiz. Below are the responses of your previous attempt.'
</pre>

'''10. Modification - ''' Line 77 - The method comment for review_questions has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
</pre>
New:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
</pre>

==Test Plan==
===Manual Testing===
Follow these instructions to manually test the functionality of student_quizzes_controller. 
'''1'''. Login as instructor using the credentials, username: instructor6, password: password. 
'''2'''. Select the '''Assignments''' subheading. Here, create a new assignment by entering the necessary details. Enable the '''Has Teams?''' checkbox and create. Also enable the '''Has quiz?''' checkbox. 
'''3'''. Navigate to the Due Dates tab and set appropriate due dates for submission and review. For Round 1: Review, enable Has Quiz using the dropdown Menu. Once you save, A '''Number of Quiz questions''' field will be visible on the Assignments page. Set this to 2 and save. 
'''4'''. At the top of the page, there will be a notice asking you to add participants. Using the link provided, add a few students to the assignment. 
'''5'''. Logout as the Instructor and Login as the students. Make submissions for the assignment before the submission deadline. 
Note: You must create a team and set team name to be able to make a submission. 
'''6'''. At the bottom of the submission page, you will see a '''Create a Quiz''' link. Select that link. 
'''7'''. This takes you to the quiz creation page. Here you can set Radio Button MCQs, Checkbox MCQs and True/False Questions and set the correct answers. 
Then select '''Create Quiz'''. This creates the quiz. 
'''8'''. Logout and login as another student registered in the assignment. Make a submission as this student. Once the submission deadline has passed, review the first student's work and return to the main menu. 
'''9'''. You will see the option to '''Take quizzes'''. Here, select the quiz you have created and select '''Request'''. Here, you can take the quiz created by the other student.

===Manual Testing Walkthorugh===
The video below shows the steps for manually testing the controller functionality.
 
[https://drive.google.com/file/d/1b78JR5vAPQfzn569rciZ603gRJ8eIQnS/view?usp=sharing Manual testing video]

===Testing Video===
Originally the student_quizzes_controller did not have any test cases, so according to the documentation, we wrote some to check if the changes we introduced have broken the functionality. Our test cases have run successfully. Here is the video for the same. 
[https://drive.google.com/file/d/1Kl8f71sylFVBIKymvjWN9A_69jbwoDdP/view?usp=sharing Test Video link]

==Pull Request==
The link for our pull request - [https://github.com/expertiza/expertiza/pull/2340 https://github.com/expertiza/expertiza/pull/2340]

==Team members==
Jyothi Sumer Goud Maduru (jmaduru@ncsu.edu) 
Pradyumna Vemuri (pvemuri@ncsu.edu) 
Karthik Narayanan Gopala Sundaresan (kgopala3@ncsu.edu)

==Team Mentor==
Divyang Doshi (ddoshi2@ncsu.edu)

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-28T02:14:15Z

Pvemuri:

==About Expertiza==
Expertiza is a multi-purpose web application built using Ruby on Rails for Students and Instructors. Instructors enrolled in Expertiza can create and customize classes, teams, assignments, quizzes, and many more. On the other hand, Students are also allowed to form teams, attempt quizzes, and complete assignments. Apart from that, Expertiza also allows students to provide peer reviews enabling them to work together to improve others' learning experiences. It is an open-source application and its Github repository is [https://github.com/expertiza/expertiza Expertiza].
==E2215. Refactoring student_quizzes_controller.rb in Expertiza==
This page is a description of Expertiza OSS project E2215, which is refactoring the student_quizzes_controller.rb file.

==Controller Description==
The student_quizzes_controller consists of methods involved in creating, scoring & recording responses of the quizzes taken by reviewers or students of the other teams with the same assignment. This controller has some issues that violate essential Rails design principles such as the DRY principle. There are a few methods in this controller that should have been in model classes. Some methods share code, which creates code repetition. Some method comments need to be rewritten.

==Files Modified==
1. app/controllers/'''student_quizzes_controller.rb''' 2. app/views/student_quizzes/f'''inished_quiz.html''' 3. app/helpers/'''student_quizzes_helper.rb'''

==Modifications made to the existing code==
'''1. Modification - ''' Added comments for custom methods in this controller explaining the purpose. 

<pre>
# Based on the logged in user, verifies user's authourizations and privileges
def action_allowed?
</pre>
<pre>
# Initializes instance variables needed to fetch the necessary details of the quizzes.
def index
</pre>
<pre>
# For the response provided, this methods displays the questions, right/wrong answers and the final score.
def finished_quiz
</pre>
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
def self.take_quiz(assignment_id, reviewer_id)
</pre>
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
def record_response
</pre>
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
def review_questions
</pre>
<pre>
# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
</pre>
<pre>
# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>
<pre>
# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>

'''2. Modification - ''' Line 29 - .first has been changed to .last to count the score of the most recent attempt of the quiz. 
student_quizzes_controller.rb: 
Old:
<pre>
@response = Response.where(map_id: params[:map_id]).first
</pre>
New:
<pre>
@response = Response.where(map_id: params[:map_id]).last
</pre>

'''3. Modification - ''' Line 33 - @map has been renamed to @quiz_response_map to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@map = ResponseMap.find(params[:map_id])
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
@quiz_response_map = ResponseMap.find(params[:map_id])
@quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>

'''4. Modification - ''' Line 34 - @participant has been changed to @quiz_taker to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>
finished_quiz.html.erb: 
Old:
<pre>
<% @assignment = Assignment.find(@participant.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @participant, :stage => ""} %>
</pre>
New:
<pre>
<% @assignment = Assignment.find(@quiz_taker.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @quiz_taker, :stage => ""} %>
</pre>

'''5. Modification - ''' Line 39 - The method comment of self.take_quiz has been updated to describe its function 
student_quizzes_controller.rb: 
Old:
<pre>
# Gives details of the list of quizzes created by other teams for current project that a reviewer can take
</pre>
New:
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
</pre>

'''6. Modification - ''' Controller Method calculate_score has been split into three separate functions since the original method is too big and is split to use the other methods to handle score calculation for Single choice / True or False questions and Multiple answer questions separately. Then all three methods have been moved to student_quizzes_helper.rb file since they are being reused. 
student_quizzes_helper.rb: 
New:
<pre>
module StudentQuizzesHelper

# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
questionnaire = Questionnaire.find(map.reviewed_object_id)
answers = []
has_response = true
questions = Question.where(questionnaire_id: questionnaire.id)
questions.each do |question|
correct_answers = QuizQuestionChoice.where(question_id: question.id, iscorrect: true)
ques_type = question.type
if ques_type.eql? 'MultipleChoiceCheckbox'
has_response = multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
# TrueFalse and MultipleChoiceRadio
else
has_response = single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
end
end
if has_response
answers.each(&:save)
redirect_to controller: 'student_quizzes', action: 'finished_quiz', map_id: map.id
else
response.destroy
flash[:error] = 'Please answer every question.'
redirect_to action: :take_quiz, assignment_id: params[:assignment_id], questionnaire_id: questionnaire.id, map_id: map.id
end
end

# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
score = 0
if params[question.id.to_s].nil?
has_response = false
else
params[question.id.to_s].each do |choice|
# loop the quiz taker's choices and see if 1)all the correct choice are checked and 2) # of quiz taker's choice matches the # of the correct choices
correct_answers.each do |correct|
score += 1 if choice.eql? correct.txt
end
end
score = score == correct_answers.count && score == params[question.id.to_s].count ? 1 : 0
# for MultipleChoiceCheckbox, score =1 means the quiz taker have done this question correctly, not just make select this choice correctly.
params[question.id.to_s].each do |choice|
new_answer = Answer.new comments: choice, question_id: question.id, response_id: response.id, answer: score

has_response = false unless new_answer.valid?
answers.push(new_answer)
end
end
return has_response
end

# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
correct_answer = correct_answers.first
score = correct_answer.txt == params[question.id.to_s] ? 1 : 0
new_score = Answer.new comments: params[question.id.to_s], question_id: question.id, response_id: response.id, answer: score
has_response = false if new_score.nil? || new_score.comments.nil? || new_score.comments.empty?
answers.push(new_score)
return has_response
end

end
</pre>

'''7. Modification - ''' Line 60 - A method comment has been added for record_response to describe its function 
student_quizzes_controller.rb: 
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
</pre>

'''8. Modification - ''' -graded? has been removed as it is no longer necessary. 

'''9. Modification - ''' Line 72 - The Flash message has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
flash[:error] = 'You have already taken this quiz, below are the records for your response.'
</pre>
New:
<pre>
flash[:error] = 'You have already taken this quiz. Below are the responses of your previous attempt.'
</pre>

'''10. Modification - ''' Line 77 - The method comment for review_questions has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
</pre>
New:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
</pre>

==Test Plan==
===Manual Testing===
Follow these instructions to manually test the functionality of student_quizzes_controller. 
'''1'''. Login as instructor using the credentials, username: instructor6, password: password. 
'''2'''. Select the '''Assignments''' subheading. Here, create a new assignment by entering the necessary details. Enable the '''Has Teams?''' checkbox and create. Also enable the '''Has quiz?''' checkbox. 
'''3'''. Navigate to the Due Dates tab and set appropriate due dates for submission and review. For Round 1: Review, enable Has Quiz using the dropdown Menu. Once you save, A '''Number of Quiz questions''' field will be visible on the Assignments page. Set this to 2 and save. 
'''4'''. At the top of the page, there will be a notice asking you to add participants. Using the link provided, add a few students to the assignment. 
'''5'''. Logout as the Instructor and Login as the students. Make submissions for the assignment before the submission deadline. 
Note: You must create a team and set team name to be able to make a submission. 
'''6'''. At the bottom of the submission page, you will see a '''Create a Quiz''' link. Select that link. 
'''7'''. This takes you to the quiz creation page. Here you can set Radio Button MCQs, Checkbox MCQs and True/False Questions and set the correct answers. 
Then select '''Create Quiz'''. This creates the quiz. 
'''8'''. Logout and login as another student registered in the assignment. Make a submission as this student. Once the submission deadline has passed, review the first student's work and return to the main menu. 
'''9'''. You will see the option to '''Take quizzes'''. Here, select the quiz you have created and select '''Request'''. Here, you can take the quiz created by the other student.

===Manual Testing Walkthorugh===
The video below shows the steps for manually testing the controller functionality.
 
[https://drive.google.com/file/d/1b78JR5vAPQfzn569rciZ603gRJ8eIQnS/view?usp=sharing Manual testing video]

===Testing Video===
Originally the student_quizzes_controller did not have any test cases, so according to the documentation, we wrote some to check if the changes we introduced have broken the functionality. Our test cases have run successfully. Here is the video for the same. 
[https://drive.google.com/file/d/1Kl8f71sylFVBIKymvjWN9A_69jbwoDdP/view?usp=sharing Test Video link]

==Pull Request==
The link for our pull request - [https://github.com/expertiza/expertiza/pull/2340]

==Team members==
Jyothi Sumer Goud Maduru (jmaduru@ncsu.edu) 
Pradyumna Vemuri (pvemuri@ncsu.edu) 
Karthik Narayanan Gopala Sundaresan (kgopala3@ncsu.edu)

==Team Mentor==
Divyang Doshi (ddoshi2@ncsu.edu)

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-28T02:13:37Z

Pvemuri: /* Manual Testing Walkthorugh */

==About Expertiza==
Expertiza is a multi-purpose web application built using Ruby on Rails for Students and Instructors. Instructors enrolled in Expertiza can create and customize classes, teams, assignments, quizzes, and many more. On the other hand, Students are also allowed to form teams, attempt quizzes, and complete assignments. Apart from that, Expertiza also allows students to provide peer reviews enabling them to work together to improve others' learning experiences. It is an open-source application and its Github repository is [https://github.com/expertiza/expertiza Expertiza].
==E2215. Refactoring student_quizzes_controller.rb in Expertiza==
This page is a description of Expertiza OSS project E2215, which is refactoring the student_quizzes_controller.rb file.

==Controller Description==
The student_quizzes_controller consists of methods involved in creating, scoring & recording responses of the quizzes taken by reviewers or students of the other teams with the same assignment. This controller has some issues that violate essential Rails design principles such as the DRY principle. There are a few methods in this controller that should have been in model classes. Some methods share code, which creates code repetition. Some method comments need to be rewritten.

==Files Modified==
1. app/controllers/'''student_quizzes_controller.rb''' 2. app/views/student_quizzes/f'''inished_quiz.html''' 3. app/helpers/'''student_quizzes_helper.rb'''

==Modifications made to the existing code==
'''1. Modification - ''' Added comments for custom methods in this controller explaining the purpose. 

<pre>
# Based on the logged in user, verifies user's authourizations and privileges
def action_allowed?
</pre>
<pre>
# Initializes instance variables needed to fetch the necessary details of the quizzes.
def index
</pre>
<pre>
# For the response provided, this methods displays the questions, right/wrong answers and the final score.
def finished_quiz
</pre>
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
def self.take_quiz(assignment_id, reviewer_id)
</pre>
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
def record_response
</pre>
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
def review_questions
</pre>
<pre>
# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
</pre>
<pre>
# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>
<pre>
# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>

'''2. Modification - ''' Line 29 - .first has been changed to .last to count the score of the most recent attempt of the quiz. 
student_quizzes_controller.rb: 
Old:
<pre>
@response = Response.where(map_id: params[:map_id]).first
</pre>
New:
<pre>
@response = Response.where(map_id: params[:map_id]).last
</pre>

'''3. Modification - ''' Line 33 - @map has been renamed to @quiz_response_map to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@map = ResponseMap.find(params[:map_id])
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
@quiz_response_map = ResponseMap.find(params[:map_id])
@quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>

'''4. Modification - ''' Line 34 - @participant has been changed to @quiz_taker to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>
finished_quiz.html.erb: 
Old:
<pre>
<% @assignment = Assignment.find(@participant.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @participant, :stage => ""} %>
</pre>
New:
<pre>
<% @assignment = Assignment.find(@quiz_taker.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @quiz_taker, :stage => ""} %>
</pre>

'''5. Modification - ''' Line 39 - The method comment of self.take_quiz has been updated to describe its function 
student_quizzes_controller.rb: 
Old:
<pre>
# Gives details of the list of quizzes created by other teams for current project that a reviewer can take
</pre>
New:
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
</pre>

'''6. Modification - ''' Controller Method calculate_score has been split into three separate functions since the original method is too big and is split to use the other methods to handle score calculation for Single choice / True or False questions and Multiple answer questions separately. Then all three methods have been moved to student_quizzes_helper.rb file since they are being reused. 
student_quizzes_helper.rb: 
New:
<pre>
module StudentQuizzesHelper

# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
questionnaire = Questionnaire.find(map.reviewed_object_id)
answers = []
has_response = true
questions = Question.where(questionnaire_id: questionnaire.id)
questions.each do |question|
correct_answers = QuizQuestionChoice.where(question_id: question.id, iscorrect: true)
ques_type = question.type
if ques_type.eql? 'MultipleChoiceCheckbox'
has_response = multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
# TrueFalse and MultipleChoiceRadio
else
has_response = single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
end
end
if has_response
answers.each(&:save)
redirect_to controller: 'student_quizzes', action: 'finished_quiz', map_id: map.id
else
response.destroy
flash[:error] = 'Please answer every question.'
redirect_to action: :take_quiz, assignment_id: params[:assignment_id], questionnaire_id: questionnaire.id, map_id: map.id
end
end

# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
score = 0
if params[question.id.to_s].nil?
has_response = false
else
params[question.id.to_s].each do |choice|
# loop the quiz taker's choices and see if 1)all the correct choice are checked and 2) # of quiz taker's choice matches the # of the correct choices
correct_answers.each do |correct|
score += 1 if choice.eql? correct.txt
end
end
score = score == correct_answers.count && score == params[question.id.to_s].count ? 1 : 0
# for MultipleChoiceCheckbox, score =1 means the quiz taker have done this question correctly, not just make select this choice correctly.
params[question.id.to_s].each do |choice|
new_answer = Answer.new comments: choice, question_id: question.id, response_id: response.id, answer: score

has_response = false unless new_answer.valid?
answers.push(new_answer)
end
end
return has_response
end

# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
correct_answer = correct_answers.first
score = correct_answer.txt == params[question.id.to_s] ? 1 : 0
new_score = Answer.new comments: params[question.id.to_s], question_id: question.id, response_id: response.id, answer: score
has_response = false if new_score.nil? || new_score.comments.nil? || new_score.comments.empty?
answers.push(new_score)
return has_response
end

end
</pre>

'''7. Modification - ''' Line 60 - A method comment has been added for record_response to describe its function 
student_quizzes_controller.rb: 
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
</pre>

'''8. Modification - ''' -graded? has been removed as it is no longer necessary. 

'''9. Modification - ''' Line 72 - The Flash message has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
flash[:error] = 'You have already taken this quiz, below are the records for your response.'
</pre>
New:
<pre>
flash[:error] = 'You have already taken this quiz. Below are the responses of your previous attempt.'
</pre>

'''10. Modification - ''' Line 77 - The method comment for review_questions has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
</pre>
New:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
</pre>

==Test Plan==
===Manual Testing===
Follow these instructions to manually test the functionality of student_quizzes_controller. 
'''1'''. Login as instructor using the credentials, username: instructor6, password: password. 
'''2'''. Select the '''Assignments''' subheading. Here, create a new assignment by entering the necessary details. Enable the '''Has Teams?''' checkbox and create. Also enable the '''Has quiz?''' checkbox. 
'''3'''. Navigate to the Due Dates tab and set appropriate due dates for submission and review. For Round 1: Review, enable Has Quiz using the dropdown Menu. Once you save, A '''Number of Quiz questions''' field will be visible on the Assignments page. Set this to 2 and save. 
'''4'''. At the top of the page, there will be a notice asking you to add participants. Using the link provided, add a few students to the assignment. 
'''5'''. Logout as the Instructor and Login as the students. Make submissions for the assignment before the submission deadline. 
Note: You must create a team and set team name to be able to make a submission. 
'''6'''. At the bottom of the submission page, you will see a '''Create a Quiz''' link. Select that link. 
'''7'''. This takes you to the quiz creation page. Here you can set Radio Button MCQs, Checkbox MCQs and True/False Questions and set the correct answers. 
Then select '''Create Quiz'''. This creates the quiz. 
'''8'''. Logout and login as another student registered in the assignment. Make a submission as this student. Once the submission deadline has passed, review the first student's work and return to the main menu. 
'''9'''. You will see the option to '''Take quizzes'''. Here, select the quiz you have created and select '''Request'''. Here, you can take the quiz created by the other student.

===Manual Testing Walkthorugh===
The video below shows the steps for manually testing the controller functionality.
 
[https://drive.google.com/file/d/1b78JR5vAPQfzn569rciZ603gRJ8eIQnS/view?usp=sharing Manual testing video]

===Testing Video===
Originally the student_quizzes_controller did not have any test cases, so according to the documentation, we wrote some to check if the changes we introduced have broken the functionality. Our test cases have run successfully. Here is the video for the same. 
[https://drive.google.com/file/d/1Kl8f71sylFVBIKymvjWN9A_69jbwoDdP/view?usp=sharing Test Video link]

==Team members==
Jyothi Sumer Goud Maduru (jmaduru@ncsu.edu) 
Pradyumna Vemuri (pvemuri@ncsu.edu) 
Karthik Narayanan Gopala Sundaresan (kgopala3@ncsu.edu)

==Team Mentor==
Divyang Doshi (ddoshi2@ncsu.edu)

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-28T02:09:45Z

Pvemuri: /* Manual Testing Walkthorugh */

==About Expertiza==
Expertiza is a multi-purpose web application built using Ruby on Rails for Students and Instructors. Instructors enrolled in Expertiza can create and customize classes, teams, assignments, quizzes, and many more. On the other hand, Students are also allowed to form teams, attempt quizzes, and complete assignments. Apart from that, Expertiza also allows students to provide peer reviews enabling them to work together to improve others' learning experiences. It is an open-source application and its Github repository is [https://github.com/expertiza/expertiza Expertiza].
==E2215. Refactoring student_quizzes_controller.rb in Expertiza==
This page is a description of Expertiza OSS project E2215, which is refactoring the student_quizzes_controller.rb file.

==Controller Description==
The student_quizzes_controller consists of methods involved in creating, scoring & recording responses of the quizzes taken by reviewers or students of the other teams with the same assignment. This controller has some issues that violate essential Rails design principles such as the DRY principle. There are a few methods in this controller that should have been in model classes. Some methods share code, which creates code repetition. Some method comments need to be rewritten.

==Files Modified==
1. app/controllers/'''student_quizzes_controller.rb''' 2. app/views/student_quizzes/f'''inished_quiz.html''' 3. app/helpers/'''student_quizzes_helper.rb'''

==Modifications made to the existing code==
'''1. Modification - ''' Added comments for custom methods in this controller explaining the purpose. 

<pre>
# Based on the logged in user, verifies user's authourizations and privileges
def action_allowed?
</pre>
<pre>
# Initializes instance variables needed to fetch the necessary details of the quizzes.
def index
</pre>
<pre>
# For the response provided, this methods displays the questions, right/wrong answers and the final score.
def finished_quiz
</pre>
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
def self.take_quiz(assignment_id, reviewer_id)
</pre>
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
def record_response
</pre>
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
def review_questions
</pre>
<pre>
# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
</pre>
<pre>
# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>
<pre>
# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>

'''2. Modification - ''' Line 29 - .first has been changed to .last to count the score of the most recent attempt of the quiz. 
student_quizzes_controller.rb: 
Old:
<pre>
@response = Response.where(map_id: params[:map_id]).first
</pre>
New:
<pre>
@response = Response.where(map_id: params[:map_id]).last
</pre>

'''3. Modification - ''' Line 33 - @map has been renamed to @quiz_response_map to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@map = ResponseMap.find(params[:map_id])
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
@quiz_response_map = ResponseMap.find(params[:map_id])
@quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>

'''4. Modification - ''' Line 34 - @participant has been changed to @quiz_taker to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>
finished_quiz.html.erb: 
Old:
<pre>
<% @assignment = Assignment.find(@participant.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @participant, :stage => ""} %>
</pre>
New:
<pre>
<% @assignment = Assignment.find(@quiz_taker.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @quiz_taker, :stage => ""} %>
</pre>

'''5. Modification - ''' Line 39 - The method comment of self.take_quiz has been updated to describe its function 
student_quizzes_controller.rb: 
Old:
<pre>
# Gives details of the list of quizzes created by other teams for current project that a reviewer can take
</pre>
New:
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
</pre>

'''6. Modification - ''' Controller Method calculate_score has been split into three separate functions since the original method is too big and is split to use the other methods to handle score calculation for Single choice / True or False questions and Multiple answer questions separately. Then all three methods have been moved to student_quizzes_helper.rb file since they are being reused. 
student_quizzes_helper.rb: 
New:
<pre>
module StudentQuizzesHelper

# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
questionnaire = Questionnaire.find(map.reviewed_object_id)
answers = []
has_response = true
questions = Question.where(questionnaire_id: questionnaire.id)
questions.each do |question|
correct_answers = QuizQuestionChoice.where(question_id: question.id, iscorrect: true)
ques_type = question.type
if ques_type.eql? 'MultipleChoiceCheckbox'
has_response = multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
# TrueFalse and MultipleChoiceRadio
else
has_response = single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
end
end
if has_response
answers.each(&:save)
redirect_to controller: 'student_quizzes', action: 'finished_quiz', map_id: map.id
else
response.destroy
flash[:error] = 'Please answer every question.'
redirect_to action: :take_quiz, assignment_id: params[:assignment_id], questionnaire_id: questionnaire.id, map_id: map.id
end
end

# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
score = 0
if params[question.id.to_s].nil?
has_response = false
else
params[question.id.to_s].each do |choice|
# loop the quiz taker's choices and see if 1)all the correct choice are checked and 2) # of quiz taker's choice matches the # of the correct choices
correct_answers.each do |correct|
score += 1 if choice.eql? correct.txt
end
end
score = score == correct_answers.count && score == params[question.id.to_s].count ? 1 : 0
# for MultipleChoiceCheckbox, score =1 means the quiz taker have done this question correctly, not just make select this choice correctly.
params[question.id.to_s].each do |choice|
new_answer = Answer.new comments: choice, question_id: question.id, response_id: response.id, answer: score

has_response = false unless new_answer.valid?
answers.push(new_answer)
end
end
return has_response
end

# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
correct_answer = correct_answers.first
score = correct_answer.txt == params[question.id.to_s] ? 1 : 0
new_score = Answer.new comments: params[question.id.to_s], question_id: question.id, response_id: response.id, answer: score
has_response = false if new_score.nil? || new_score.comments.nil? || new_score.comments.empty?
answers.push(new_score)
return has_response
end

end
</pre>

'''7. Modification - ''' Line 60 - A method comment has been added for record_response to describe its function 
student_quizzes_controller.rb: 
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
</pre>

'''8. Modification - ''' -graded? has been removed as it is no longer necessary. 

'''9. Modification - ''' Line 72 - The Flash message has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
flash[:error] = 'You have already taken this quiz, below are the records for your response.'
</pre>
New:
<pre>
flash[:error] = 'You have already taken this quiz. Below are the responses of your previous attempt.'
</pre>

'''10. Modification - ''' Line 77 - The method comment for review_questions has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
</pre>
New:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
</pre>

==Test Plan==
===Manual Testing===
Follow these instructions to manually test the functionality of student_quizzes_controller. 
'''1'''. Login as instructor using the credentials, username: instructor6, password: password. 
'''2'''. Select the '''Assignments''' subheading. Here, create a new assignment by entering the necessary details. Enable the '''Has Teams?''' checkbox and create. Also enable the '''Has quiz?''' checkbox. 
'''3'''. Navigate to the Due Dates tab and set appropriate due dates for submission and review. For Round 1: Review, enable Has Quiz using the dropdown Menu. Once you save, A '''Number of Quiz questions''' field will be visible on the Assignments page. Set this to 2 and save. 
'''4'''. At the top of the page, there will be a notice asking you to add participants. Using the link provided, add a few students to the assignment. 
'''5'''. Logout as the Instructor and Login as the students. Make submissions for the assignment before the submission deadline. 
Note: You must create a team and set team name to be able to make a submission. 
'''6'''. At the bottom of the submission page, you will see a '''Create a Quiz''' link. Select that link. 
'''7'''. This takes you to the quiz creation page. Here you can set Radio Button MCQs, Checkbox MCQs and True/False Questions and set the correct answers. 
Then select '''Create Quiz'''. This creates the quiz. 
'''8'''. Logout and login as another student registered in the assignment. Make a submission as this student. Once the submission deadline has passed, review the first student's work and return to the main menu. 
'''9'''. You will see the option to '''Take quizzes'''. Here, select the quiz you have created and select '''Request'''. Here, you can take the quiz created by the other student.

===Manual Testing Walkthorugh===
The video below shows the steps above for manually testing the controller functionality.
 
[https://drive.google.com/file/d/1b78JR5vAPQfzn569rciZ603gRJ8eIQnS/view?usp=sharing Manual testing video]

===Testing Video===
Originally the student_quizzes_controller did not have any test cases, so according to the documentation, we wrote some to check if the changes we introduced have broken the functionality. Our test cases have run successfully. Here is the video for the same. 
[https://drive.google.com/file/d/1Kl8f71sylFVBIKymvjWN9A_69jbwoDdP/view?usp=sharing Test Video link]

==Team members==
Jyothi Sumer Goud Maduru (jmaduru@ncsu.edu) 
Pradyumna Vemuri (pvemuri@ncsu.edu) 
Karthik Narayanan Gopala Sundaresan (kgopala3@ncsu.edu)

==Team Mentor==
Divyang Doshi (ddoshi2@ncsu.edu)

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-28T02:04:18Z

Pvemuri: /* Testing Video */

==About Expertiza==
Expertiza is a multi-purpose web application built using Ruby on Rails for Students and Instructors. Instructors enrolled in Expertiza can create and customize classes, teams, assignments, quizzes, and many more. On the other hand, Students are also allowed to form teams, attempt quizzes, and complete assignments. Apart from that, Expertiza also allows students to provide peer reviews enabling them to work together to improve others' learning experiences. It is an open-source application and its Github repository is [https://github.com/expertiza/expertiza Expertiza].
==E2215. Refactoring student_quizzes_controller.rb in Expertiza==
This page is a description of Expertiza OSS project E2215, which is refactoring the student_quizzes_controller.rb file.

==Controller Description==
The student_quizzes_controller consists of methods involved in creating, scoring & recording responses of the quizzes taken by reviewers or students of the other teams with the same assignment. This controller has some issues that violate essential Rails design principles such as the DRY principle. There are a few methods in this controller that should have been in model classes. Some methods share code, which creates code repetition. Some method comments need to be rewritten.

==Files Modified==
1. app/controllers/'''student_quizzes_controller.rb''' 2. app/views/student_quizzes/f'''inished_quiz.html''' 3. app/helpers/'''student_quizzes_helper.rb'''

==Modifications made to the existing code==
'''1. Modification - ''' Added comments for custom methods in this controller explaining the purpose. 

<pre>
# Based on the logged in user, verifies user's authourizations and privileges
def action_allowed?
</pre>
<pre>
# Initializes instance variables needed to fetch the necessary details of the quizzes.
def index
</pre>
<pre>
# For the response provided, this methods displays the questions, right/wrong answers and the final score.
def finished_quiz
</pre>
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
def self.take_quiz(assignment_id, reviewer_id)
</pre>
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
def record_response
</pre>
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
def review_questions
</pre>
<pre>
# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
</pre>
<pre>
# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>
<pre>
# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>

'''2. Modification - ''' Line 29 - .first has been changed to .last to count the score of the most recent attempt of the quiz. 
student_quizzes_controller.rb: 
Old:
<pre>
@response = Response.where(map_id: params[:map_id]).first
</pre>
New:
<pre>
@response = Response.where(map_id: params[:map_id]).last
</pre>

'''3. Modification - ''' Line 33 - @map has been renamed to @quiz_response_map to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@map = ResponseMap.find(params[:map_id])
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
@quiz_response_map = ResponseMap.find(params[:map_id])
@quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>

'''4. Modification - ''' Line 34 - @participant has been changed to @quiz_taker to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>
finished_quiz.html.erb: 
Old:
<pre>
<% @assignment = Assignment.find(@participant.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @participant, :stage => ""} %>
</pre>
New:
<pre>
<% @assignment = Assignment.find(@quiz_taker.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @quiz_taker, :stage => ""} %>
</pre>

'''5. Modification - ''' Line 39 - The method comment of self.take_quiz has been updated to describe its function 
student_quizzes_controller.rb: 
Old:
<pre>
# Gives details of the list of quizzes created by other teams for current project that a reviewer can take
</pre>
New:
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
</pre>

'''6. Modification - ''' Controller Method calculate_score has been split into three separate functions since the original method is too big and is split to use the other methods to handle score calculation for Single choice / True or False questions and Multiple answer questions separately. Then all three methods have been moved to student_quizzes_helper.rb file since they are being reused. 
student_quizzes_helper.rb: 
New:
<pre>
module StudentQuizzesHelper

# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
questionnaire = Questionnaire.find(map.reviewed_object_id)
answers = []
has_response = true
questions = Question.where(questionnaire_id: questionnaire.id)
questions.each do |question|
correct_answers = QuizQuestionChoice.where(question_id: question.id, iscorrect: true)
ques_type = question.type
if ques_type.eql? 'MultipleChoiceCheckbox'
has_response = multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
# TrueFalse and MultipleChoiceRadio
else
has_response = single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
end
end
if has_response
answers.each(&:save)
redirect_to controller: 'student_quizzes', action: 'finished_quiz', map_id: map.id
else
response.destroy
flash[:error] = 'Please answer every question.'
redirect_to action: :take_quiz, assignment_id: params[:assignment_id], questionnaire_id: questionnaire.id, map_id: map.id
end
end

# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
score = 0
if params[question.id.to_s].nil?
has_response = false
else
params[question.id.to_s].each do |choice|
# loop the quiz taker's choices and see if 1)all the correct choice are checked and 2) # of quiz taker's choice matches the # of the correct choices
correct_answers.each do |correct|
score += 1 if choice.eql? correct.txt
end
end
score = score == correct_answers.count && score == params[question.id.to_s].count ? 1 : 0
# for MultipleChoiceCheckbox, score =1 means the quiz taker have done this question correctly, not just make select this choice correctly.
params[question.id.to_s].each do |choice|
new_answer = Answer.new comments: choice, question_id: question.id, response_id: response.id, answer: score

has_response = false unless new_answer.valid?
answers.push(new_answer)
end
end
return has_response
end

# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
correct_answer = correct_answers.first
score = correct_answer.txt == params[question.id.to_s] ? 1 : 0
new_score = Answer.new comments: params[question.id.to_s], question_id: question.id, response_id: response.id, answer: score
has_response = false if new_score.nil? || new_score.comments.nil? || new_score.comments.empty?
answers.push(new_score)
return has_response
end

end
</pre>

'''7. Modification - ''' Line 60 - A method comment has been added for record_response to describe its function 
student_quizzes_controller.rb: 
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
</pre>

'''8. Modification - ''' -graded? has been removed as it is no longer necessary. 

'''9. Modification - ''' Line 72 - The Flash message has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
flash[:error] = 'You have already taken this quiz, below are the records for your response.'
</pre>
New:
<pre>
flash[:error] = 'You have already taken this quiz. Below are the responses of your previous attempt.'
</pre>

'''10. Modification - ''' Line 77 - The method comment for review_questions has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
</pre>
New:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
</pre>

==Test Plan==
===Manual Testing===
Follow these instructions to manually test the functionality of student_quizzes_controller. 
'''1'''. Login as instructor using the credentials, username: instructor6, password: password. 
'''2'''. Select the '''Assignments''' subheading. Here, create a new assignment by entering the necessary details. Enable the '''Has Teams?''' checkbox and create. Also enable the '''Has quiz?''' checkbox. 
'''3'''. Navigate to the Due Dates tab and set appropriate due dates for submission and review. For Round 1: Review, enable Has Quiz using the dropdown Menu. Once you save, A '''Number of Quiz questions''' field will be visible on the Assignments page. Set this to 2 and save. 
'''4'''. At the top of the page, there will be a notice asking you to add participants. Using the link provided, add a few students to the assignment. 
'''5'''. Logout as the Instructor and Login as the students. Make submissions for the assignment before the submission deadline. 
Note: You must create a team and set team name to be able to make a submission. 
'''6'''. At the bottom of the submission page, you will see a '''Create a Quiz''' link. Select that link. 
'''7'''. This takes you to the quiz creation page. Here you can set Radio Button MCQs, Checkbox MCQs and True/False Questions and set the correct answers. 
Then select '''Create Quiz'''. This creates the quiz. 
'''8'''. Logout and login as another student registered in the assignment. Make a submission as this student. Once the submission deadline has passed, review the first student's work and return to the main menu. 
'''9'''. You will see the option to '''Take quizzes'''. Here, select the quiz you have created and select '''Request'''. Here, you can take the quiz created by the other student.

===Manual Testing Walkthorugh===

===Testing Video===
Originally the student_quizzes_controller did not have any test cases, so according to the documentation, we wrote some to check if the changes we introduced have broken the functionality. Our test cases have run successfully. Here is the video for the same. 
[https://drive.google.com/file/d/1Kl8f71sylFVBIKymvjWN9A_69jbwoDdP/view?usp=sharing Test Video link]

==Team members==
Jyothi Sumer Goud Maduru (jmaduru@ncsu.edu) 
Pradyumna Vemuri (pvemuri@ncsu.edu) 
Karthik Narayanan Gopala Sundaresan (kgopala3@ncsu.edu)

==Team Mentor==
Divyang Doshi (ddoshi2@ncsu.edu)

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-28T02:03:48Z

Pvemuri: /* Testing Video */

==About Expertiza==
Expertiza is a multi-purpose web application built using Ruby on Rails for Students and Instructors. Instructors enrolled in Expertiza can create and customize classes, teams, assignments, quizzes, and many more. On the other hand, Students are also allowed to form teams, attempt quizzes, and complete assignments. Apart from that, Expertiza also allows students to provide peer reviews enabling them to work together to improve others' learning experiences. It is an open-source application and its Github repository is [https://github.com/expertiza/expertiza Expertiza].
==E2215. Refactoring student_quizzes_controller.rb in Expertiza==
This page is a description of Expertiza OSS project E2215, which is refactoring the student_quizzes_controller.rb file.

==Controller Description==
The student_quizzes_controller consists of methods involved in creating, scoring & recording responses of the quizzes taken by reviewers or students of the other teams with the same assignment. This controller has some issues that violate essential Rails design principles such as the DRY principle. There are a few methods in this controller that should have been in model classes. Some methods share code, which creates code repetition. Some method comments need to be rewritten.

==Files Modified==
1. app/controllers/'''student_quizzes_controller.rb''' 2. app/views/student_quizzes/f'''inished_quiz.html''' 3. app/helpers/'''student_quizzes_helper.rb'''

==Modifications made to the existing code==
'''1. Modification - ''' Added comments for custom methods in this controller explaining the purpose. 

<pre>
# Based on the logged in user, verifies user's authourizations and privileges
def action_allowed?
</pre>
<pre>
# Initializes instance variables needed to fetch the necessary details of the quizzes.
def index
</pre>
<pre>
# For the response provided, this methods displays the questions, right/wrong answers and the final score.
def finished_quiz
</pre>
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
def self.take_quiz(assignment_id, reviewer_id)
</pre>
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
def record_response
</pre>
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
def review_questions
</pre>
<pre>
# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
</pre>
<pre>
# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>
<pre>
# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>

'''2. Modification - ''' Line 29 - .first has been changed to .last to count the score of the most recent attempt of the quiz. 
student_quizzes_controller.rb: 
Old:
<pre>
@response = Response.where(map_id: params[:map_id]).first
</pre>
New:
<pre>
@response = Response.where(map_id: params[:map_id]).last
</pre>

'''3. Modification - ''' Line 33 - @map has been renamed to @quiz_response_map to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@map = ResponseMap.find(params[:map_id])
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
@quiz_response_map = ResponseMap.find(params[:map_id])
@quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>

'''4. Modification - ''' Line 34 - @participant has been changed to @quiz_taker to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>
finished_quiz.html.erb: 
Old:
<pre>
<% @assignment = Assignment.find(@participant.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @participant, :stage => ""} %>
</pre>
New:
<pre>
<% @assignment = Assignment.find(@quiz_taker.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @quiz_taker, :stage => ""} %>
</pre>

'''5. Modification - ''' Line 39 - The method comment of self.take_quiz has been updated to describe its function 
student_quizzes_controller.rb: 
Old:
<pre>
# Gives details of the list of quizzes created by other teams for current project that a reviewer can take
</pre>
New:
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
</pre>

'''6. Modification - ''' Controller Method calculate_score has been split into three separate functions since the original method is too big and is split to use the other methods to handle score calculation for Single choice / True or False questions and Multiple answer questions separately. Then all three methods have been moved to student_quizzes_helper.rb file since they are being reused. 
student_quizzes_helper.rb: 
New:
<pre>
module StudentQuizzesHelper

# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
questionnaire = Questionnaire.find(map.reviewed_object_id)
answers = []
has_response = true
questions = Question.where(questionnaire_id: questionnaire.id)
questions.each do |question|
correct_answers = QuizQuestionChoice.where(question_id: question.id, iscorrect: true)
ques_type = question.type
if ques_type.eql? 'MultipleChoiceCheckbox'
has_response = multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
# TrueFalse and MultipleChoiceRadio
else
has_response = single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
end
end
if has_response
answers.each(&:save)
redirect_to controller: 'student_quizzes', action: 'finished_quiz', map_id: map.id
else
response.destroy
flash[:error] = 'Please answer every question.'
redirect_to action: :take_quiz, assignment_id: params[:assignment_id], questionnaire_id: questionnaire.id, map_id: map.id
end
end

# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
score = 0
if params[question.id.to_s].nil?
has_response = false
else
params[question.id.to_s].each do |choice|
# loop the quiz taker's choices and see if 1)all the correct choice are checked and 2) # of quiz taker's choice matches the # of the correct choices
correct_answers.each do |correct|
score += 1 if choice.eql? correct.txt
end
end
score = score == correct_answers.count && score == params[question.id.to_s].count ? 1 : 0
# for MultipleChoiceCheckbox, score =1 means the quiz taker have done this question correctly, not just make select this choice correctly.
params[question.id.to_s].each do |choice|
new_answer = Answer.new comments: choice, question_id: question.id, response_id: response.id, answer: score

has_response = false unless new_answer.valid?
answers.push(new_answer)
end
end
return has_response
end

# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
correct_answer = correct_answers.first
score = correct_answer.txt == params[question.id.to_s] ? 1 : 0
new_score = Answer.new comments: params[question.id.to_s], question_id: question.id, response_id: response.id, answer: score
has_response = false if new_score.nil? || new_score.comments.nil? || new_score.comments.empty?
answers.push(new_score)
return has_response
end

end
</pre>

'''7. Modification - ''' Line 60 - A method comment has been added for record_response to describe its function 
student_quizzes_controller.rb: 
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
</pre>

'''8. Modification - ''' -graded? has been removed as it is no longer necessary. 

'''9. Modification - ''' Line 72 - The Flash message has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
flash[:error] = 'You have already taken this quiz, below are the records for your response.'
</pre>
New:
<pre>
flash[:error] = 'You have already taken this quiz. Below are the responses of your previous attempt.'
</pre>

'''10. Modification - ''' Line 77 - The method comment for review_questions has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
</pre>
New:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
</pre>

==Test Plan==
===Manual Testing===
Follow these instructions to manually test the functionality of student_quizzes_controller. 
'''1'''. Login as instructor using the credentials, username: instructor6, password: password. 
'''2'''. Select the '''Assignments''' subheading. Here, create a new assignment by entering the necessary details. Enable the '''Has Teams?''' checkbox and create. Also enable the '''Has quiz?''' checkbox. 
'''3'''. Navigate to the Due Dates tab and set appropriate due dates for submission and review. For Round 1: Review, enable Has Quiz using the dropdown Menu. Once you save, A '''Number of Quiz questions''' field will be visible on the Assignments page. Set this to 2 and save. 
'''4'''. At the top of the page, there will be a notice asking you to add participants. Using the link provided, add a few students to the assignment. 
'''5'''. Logout as the Instructor and Login as the students. Make submissions for the assignment before the submission deadline. 
Note: You must create a team and set team name to be able to make a submission. 
'''6'''. At the bottom of the submission page, you will see a '''Create a Quiz''' link. Select that link. 
'''7'''. This takes you to the quiz creation page. Here you can set Radio Button MCQs, Checkbox MCQs and True/False Questions and set the correct answers. 
Then select '''Create Quiz'''. This creates the quiz. 
'''8'''. Logout and login as another student registered in the assignment. Make a submission as this student. Once the submission deadline has passed, review the first student's work and return to the main menu. 
'''9'''. You will see the option to '''Take quizzes'''. Here, select the quiz you have created and select '''Request'''. Here, you can take the quiz created by the other student.

===Manual Testing Walkthorugh===

===Testing Video===
Originally the student_quizzes_controller does not have any test cases, so according to the documentation, we wrote some to check if the changes we introduced have broken the functionality. Our test cases have run successfully. Here is the video for the same. 
[https://drive.google.com/file/d/1Kl8f71sylFVBIKymvjWN9A_69jbwoDdP/view?usp=sharing Test Video link]

==Team members==
Jyothi Sumer Goud Maduru (jmaduru@ncsu.edu) 
Pradyumna Vemuri (pvemuri@ncsu.edu) 
Karthik Narayanan Gopala Sundaresan (kgopala3@ncsu.edu)

==Team Mentor==
Divyang Doshi (ddoshi2@ncsu.edu)

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-28T02:03:33Z

Pvemuri: /* Testing Video */

==About Expertiza==
Expertiza is a multi-purpose web application built using Ruby on Rails for Students and Instructors. Instructors enrolled in Expertiza can create and customize classes, teams, assignments, quizzes, and many more. On the other hand, Students are also allowed to form teams, attempt quizzes, and complete assignments. Apart from that, Expertiza also allows students to provide peer reviews enabling them to work together to improve others' learning experiences. It is an open-source application and its Github repository is [https://github.com/expertiza/expertiza Expertiza].
==E2215. Refactoring student_quizzes_controller.rb in Expertiza==
This page is a description of Expertiza OSS project E2215, which is refactoring the student_quizzes_controller.rb file.

==Controller Description==
The student_quizzes_controller consists of methods involved in creating, scoring & recording responses of the quizzes taken by reviewers or students of the other teams with the same assignment. This controller has some issues that violate essential Rails design principles such as the DRY principle. There are a few methods in this controller that should have been in model classes. Some methods share code, which creates code repetition. Some method comments need to be rewritten.

==Files Modified==
1. app/controllers/'''student_quizzes_controller.rb''' 2. app/views/student_quizzes/f'''inished_quiz.html''' 3. app/helpers/'''student_quizzes_helper.rb'''

==Modifications made to the existing code==
'''1. Modification - ''' Added comments for custom methods in this controller explaining the purpose. 

<pre>
# Based on the logged in user, verifies user's authourizations and privileges
def action_allowed?
</pre>
<pre>
# Initializes instance variables needed to fetch the necessary details of the quizzes.
def index
</pre>
<pre>
# For the response provided, this methods displays the questions, right/wrong answers and the final score.
def finished_quiz
</pre>
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
def self.take_quiz(assignment_id, reviewer_id)
</pre>
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
def record_response
</pre>
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
def review_questions
</pre>
<pre>
# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
</pre>
<pre>
# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>
<pre>
# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>

'''2. Modification - ''' Line 29 - .first has been changed to .last to count the score of the most recent attempt of the quiz. 
student_quizzes_controller.rb: 
Old:
<pre>
@response = Response.where(map_id: params[:map_id]).first
</pre>
New:
<pre>
@response = Response.where(map_id: params[:map_id]).last
</pre>

'''3. Modification - ''' Line 33 - @map has been renamed to @quiz_response_map to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@map = ResponseMap.find(params[:map_id])
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
@quiz_response_map = ResponseMap.find(params[:map_id])
@quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>

'''4. Modification - ''' Line 34 - @participant has been changed to @quiz_taker to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>
finished_quiz.html.erb: 
Old:
<pre>
<% @assignment = Assignment.find(@participant.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @participant, :stage => ""} %>
</pre>
New:
<pre>
<% @assignment = Assignment.find(@quiz_taker.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @quiz_taker, :stage => ""} %>
</pre>

'''5. Modification - ''' Line 39 - The method comment of self.take_quiz has been updated to describe its function 
student_quizzes_controller.rb: 
Old:
<pre>
# Gives details of the list of quizzes created by other teams for current project that a reviewer can take
</pre>
New:
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
</pre>

'''6. Modification - ''' Controller Method calculate_score has been split into three separate functions since the original method is too big and is split to use the other methods to handle score calculation for Single choice / True or False questions and Multiple answer questions separately. Then all three methods have been moved to student_quizzes_helper.rb file since they are being reused. 
student_quizzes_helper.rb: 
New:
<pre>
module StudentQuizzesHelper

# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
questionnaire = Questionnaire.find(map.reviewed_object_id)
answers = []
has_response = true
questions = Question.where(questionnaire_id: questionnaire.id)
questions.each do |question|
correct_answers = QuizQuestionChoice.where(question_id: question.id, iscorrect: true)
ques_type = question.type
if ques_type.eql? 'MultipleChoiceCheckbox'
has_response = multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
# TrueFalse and MultipleChoiceRadio
else
has_response = single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
end
end
if has_response
answers.each(&:save)
redirect_to controller: 'student_quizzes', action: 'finished_quiz', map_id: map.id
else
response.destroy
flash[:error] = 'Please answer every question.'
redirect_to action: :take_quiz, assignment_id: params[:assignment_id], questionnaire_id: questionnaire.id, map_id: map.id
end
end

# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
score = 0
if params[question.id.to_s].nil?
has_response = false
else
params[question.id.to_s].each do |choice|
# loop the quiz taker's choices and see if 1)all the correct choice are checked and 2) # of quiz taker's choice matches the # of the correct choices
correct_answers.each do |correct|
score += 1 if choice.eql? correct.txt
end
end
score = score == correct_answers.count && score == params[question.id.to_s].count ? 1 : 0
# for MultipleChoiceCheckbox, score =1 means the quiz taker have done this question correctly, not just make select this choice correctly.
params[question.id.to_s].each do |choice|
new_answer = Answer.new comments: choice, question_id: question.id, response_id: response.id, answer: score

has_response = false unless new_answer.valid?
answers.push(new_answer)
end
end
return has_response
end

# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
correct_answer = correct_answers.first
score = correct_answer.txt == params[question.id.to_s] ? 1 : 0
new_score = Answer.new comments: params[question.id.to_s], question_id: question.id, response_id: response.id, answer: score
has_response = false if new_score.nil? || new_score.comments.nil? || new_score.comments.empty?
answers.push(new_score)
return has_response
end

end
</pre>

'''7. Modification - ''' Line 60 - A method comment has been added for record_response to describe its function 
student_quizzes_controller.rb: 
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
</pre>

'''8. Modification - ''' -graded? has been removed as it is no longer necessary. 

'''9. Modification - ''' Line 72 - The Flash message has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
flash[:error] = 'You have already taken this quiz, below are the records for your response.'
</pre>
New:
<pre>
flash[:error] = 'You have already taken this quiz. Below are the responses of your previous attempt.'
</pre>

'''10. Modification - ''' Line 77 - The method comment for review_questions has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
</pre>
New:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
</pre>

==Test Plan==
===Manual Testing===
Follow these instructions to manually test the functionality of student_quizzes_controller. 
'''1'''. Login as instructor using the credentials, username: instructor6, password: password. 
'''2'''. Select the '''Assignments''' subheading. Here, create a new assignment by entering the necessary details. Enable the '''Has Teams?''' checkbox and create. Also enable the '''Has quiz?''' checkbox. 
'''3'''. Navigate to the Due Dates tab and set appropriate due dates for submission and review. For Round 1: Review, enable Has Quiz using the dropdown Menu. Once you save, A '''Number of Quiz questions''' field will be visible on the Assignments page. Set this to 2 and save. 
'''4'''. At the top of the page, there will be a notice asking you to add participants. Using the link provided, add a few students to the assignment. 
'''5'''. Logout as the Instructor and Login as the students. Make submissions for the assignment before the submission deadline. 
Note: You must create a team and set team name to be able to make a submission. 
'''6'''. At the bottom of the submission page, you will see a '''Create a Quiz''' link. Select that link. 
'''7'''. This takes you to the quiz creation page. Here you can set Radio Button MCQs, Checkbox MCQs and True/False Questions and set the correct answers. 
Then select '''Create Quiz'''. This creates the quiz. 
'''8'''. Logout and login as another student registered in the assignment. Make a submission as this student. Once the submission deadline has passed, review the first student's work and return to the main menu. 
'''9'''. You will see the option to '''Take quizzes'''. Here, select the quiz you have created and select '''Request'''. Here, you can take the quiz created by the other student.

===Manual Testing Walkthorugh===

===Testing Video===
Originally the student_quizzes_controller does not have any test cases, so according to the documentation, we wrote some to check if the changes we introduced have broken the functionality. Our test cases have run successfully. Here is the video for the same. 
[https://drive.google.com/file/d/1Kl8f71sylFVBIKymvjWN9A_69jbwoDdP/view?usp=sharing Test Video link]

==Team members==
Jyothi Sumer Goud Maduru (jmaduru@ncsu.edu) 
Pradyumna Vemuri (pvemuri@ncsu.edu) 
Karthik Narayanan Gopala Sundaresan (kgopala3@ncsu.edu)

==Team Mentor==
Divyang Doshi (ddoshi2@ncsu.edu)

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-28T02:02:59Z

Pvemuri: /* Testing Video */

==About Expertiza==
Expertiza is a multi-purpose web application built using Ruby on Rails for Students and Instructors. Instructors enrolled in Expertiza can create and customize classes, teams, assignments, quizzes, and many more. On the other hand, Students are also allowed to form teams, attempt quizzes, and complete assignments. Apart from that, Expertiza also allows students to provide peer reviews enabling them to work together to improve others' learning experiences. It is an open-source application and its Github repository is [https://github.com/expertiza/expertiza Expertiza].
==E2215. Refactoring student_quizzes_controller.rb in Expertiza==
This page is a description of Expertiza OSS project E2215, which is refactoring the student_quizzes_controller.rb file.

==Controller Description==
The student_quizzes_controller consists of methods involved in creating, scoring & recording responses of the quizzes taken by reviewers or students of the other teams with the same assignment. This controller has some issues that violate essential Rails design principles such as the DRY principle. There are a few methods in this controller that should have been in model classes. Some methods share code, which creates code repetition. Some method comments need to be rewritten.

==Files Modified==
1. app/controllers/'''student_quizzes_controller.rb''' 2. app/views/student_quizzes/f'''inished_quiz.html''' 3. app/helpers/'''student_quizzes_helper.rb'''

==Modifications made to the existing code==
'''1. Modification - ''' Added comments for custom methods in this controller explaining the purpose. 

<pre>
# Based on the logged in user, verifies user's authourizations and privileges
def action_allowed?
</pre>
<pre>
# Initializes instance variables needed to fetch the necessary details of the quizzes.
def index
</pre>
<pre>
# For the response provided, this methods displays the questions, right/wrong answers and the final score.
def finished_quiz
</pre>
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
def self.take_quiz(assignment_id, reviewer_id)
</pre>
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
def record_response
</pre>
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
def review_questions
</pre>
<pre>
# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
</pre>
<pre>
# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>
<pre>
# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>

'''2. Modification - ''' Line 29 - .first has been changed to .last to count the score of the most recent attempt of the quiz. 
student_quizzes_controller.rb: 
Old:
<pre>
@response = Response.where(map_id: params[:map_id]).first
</pre>
New:
<pre>
@response = Response.where(map_id: params[:map_id]).last
</pre>

'''3. Modification - ''' Line 33 - @map has been renamed to @quiz_response_map to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@map = ResponseMap.find(params[:map_id])
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
@quiz_response_map = ResponseMap.find(params[:map_id])
@quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>

'''4. Modification - ''' Line 34 - @participant has been changed to @quiz_taker to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>
finished_quiz.html.erb: 
Old:
<pre>
<% @assignment = Assignment.find(@participant.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @participant, :stage => ""} %>
</pre>
New:
<pre>
<% @assignment = Assignment.find(@quiz_taker.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @quiz_taker, :stage => ""} %>
</pre>

'''5. Modification - ''' Line 39 - The method comment of self.take_quiz has been updated to describe its function 
student_quizzes_controller.rb: 
Old:
<pre>
# Gives details of the list of quizzes created by other teams for current project that a reviewer can take
</pre>
New:
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
</pre>

'''6. Modification - ''' Controller Method calculate_score has been split into three separate functions since the original method is too big and is split to use the other methods to handle score calculation for Single choice / True or False questions and Multiple answer questions separately. Then all three methods have been moved to student_quizzes_helper.rb file since they are being reused. 
student_quizzes_helper.rb: 
New:
<pre>
module StudentQuizzesHelper

# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
questionnaire = Questionnaire.find(map.reviewed_object_id)
answers = []
has_response = true
questions = Question.where(questionnaire_id: questionnaire.id)
questions.each do |question|
correct_answers = QuizQuestionChoice.where(question_id: question.id, iscorrect: true)
ques_type = question.type
if ques_type.eql? 'MultipleChoiceCheckbox'
has_response = multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
# TrueFalse and MultipleChoiceRadio
else
has_response = single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
end
end
if has_response
answers.each(&:save)
redirect_to controller: 'student_quizzes', action: 'finished_quiz', map_id: map.id
else
response.destroy
flash[:error] = 'Please answer every question.'
redirect_to action: :take_quiz, assignment_id: params[:assignment_id], questionnaire_id: questionnaire.id, map_id: map.id
end
end

# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
score = 0
if params[question.id.to_s].nil?
has_response = false
else
params[question.id.to_s].each do |choice|
# loop the quiz taker's choices and see if 1)all the correct choice are checked and 2) # of quiz taker's choice matches the # of the correct choices
correct_answers.each do |correct|
score += 1 if choice.eql? correct.txt
end
end
score = score == correct_answers.count && score == params[question.id.to_s].count ? 1 : 0
# for MultipleChoiceCheckbox, score =1 means the quiz taker have done this question correctly, not just make select this choice correctly.
params[question.id.to_s].each do |choice|
new_answer = Answer.new comments: choice, question_id: question.id, response_id: response.id, answer: score

has_response = false unless new_answer.valid?
answers.push(new_answer)
end
end
return has_response
end

# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
correct_answer = correct_answers.first
score = correct_answer.txt == params[question.id.to_s] ? 1 : 0
new_score = Answer.new comments: params[question.id.to_s], question_id: question.id, response_id: response.id, answer: score
has_response = false if new_score.nil? || new_score.comments.nil? || new_score.comments.empty?
answers.push(new_score)
return has_response
end

end
</pre>

'''7. Modification - ''' Line 60 - A method comment has been added for record_response to describe its function 
student_quizzes_controller.rb: 
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
</pre>

'''8. Modification - ''' -graded? has been removed as it is no longer necessary. 

'''9. Modification - ''' Line 72 - The Flash message has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
flash[:error] = 'You have already taken this quiz, below are the records for your response.'
</pre>
New:
<pre>
flash[:error] = 'You have already taken this quiz. Below are the responses of your previous attempt.'
</pre>

'''10. Modification - ''' Line 77 - The method comment for review_questions has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
</pre>
New:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
</pre>

==Test Plan==
===Manual Testing===
Follow these instructions to manually test the functionality of student_quizzes_controller. 
'''1'''. Login as instructor using the credentials, username: instructor6, password: password. 
'''2'''. Select the '''Assignments''' subheading. Here, create a new assignment by entering the necessary details. Enable the '''Has Teams?''' checkbox and create. Also enable the '''Has quiz?''' checkbox. 
'''3'''. Navigate to the Due Dates tab and set appropriate due dates for submission and review. For Round 1: Review, enable Has Quiz using the dropdown Menu. Once you save, A '''Number of Quiz questions''' field will be visible on the Assignments page. Set this to 2 and save. 
'''4'''. At the top of the page, there will be a notice asking you to add participants. Using the link provided, add a few students to the assignment. 
'''5'''. Logout as the Instructor and Login as the students. Make submissions for the assignment before the submission deadline. 
Note: You must create a team and set team name to be able to make a submission. 
'''6'''. At the bottom of the submission page, you will see a '''Create a Quiz''' link. Select that link. 
'''7'''. This takes you to the quiz creation page. Here you can set Radio Button MCQs, Checkbox MCQs and True/False Questions and set the correct answers. 
Then select '''Create Quiz'''. This creates the quiz. 
'''8'''. Logout and login as another student registered in the assignment. Make a submission as this student. Once the submission deadline has passed, review the first student's work and return to the main menu. 
'''9'''. You will see the option to '''Take quizzes'''. Here, select the quiz you have created and select '''Request'''. Here, you can take the quiz created by the other student.

===Manual Testing Walkthorugh===

===Testing Video===
Originally the student_quizzes_controller does not have any test cases, so according to the documentation, we wrote some to check if the changes we introduced have broken the functionality. Our test cases have run successfully. Here is the video for the same. 
<iframe src="https://drive.google.com/file/d/1Kl8f71sylFVBIKymvjWN9A_69jbwoDdP/preview" width="640" height="480" allow="autoplay"></iframe>

==Team members==
Jyothi Sumer Goud Maduru (jmaduru@ncsu.edu) 
Pradyumna Vemuri (pvemuri@ncsu.edu) 
Karthik Narayanan Gopala Sundaresan (kgopala3@ncsu.edu)

==Team Mentor==
Divyang Doshi (ddoshi2@ncsu.edu)

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-28T01:59:07Z

Pvemuri: /* Testing Video */

==About Expertiza==
Expertiza is a multi-purpose web application built using Ruby on Rails for Students and Instructors. Instructors enrolled in Expertiza can create and customize classes, teams, assignments, quizzes, and many more. On the other hand, Students are also allowed to form teams, attempt quizzes, and complete assignments. Apart from that, Expertiza also allows students to provide peer reviews enabling them to work together to improve others' learning experiences. It is an open-source application and its Github repository is [https://github.com/expertiza/expertiza Expertiza].
==E2215. Refactoring student_quizzes_controller.rb in Expertiza==
This page is a description of Expertiza OSS project E2215, which is refactoring the student_quizzes_controller.rb file.

==Controller Description==
The student_quizzes_controller consists of methods involved in creating, scoring & recording responses of the quizzes taken by reviewers or students of the other teams with the same assignment. This controller has some issues that violate essential Rails design principles such as the DRY principle. There are a few methods in this controller that should have been in model classes. Some methods share code, which creates code repetition. Some method comments need to be rewritten.

==Files Modified==
1. app/controllers/'''student_quizzes_controller.rb''' 2. app/views/student_quizzes/f'''inished_quiz.html''' 3. app/helpers/'''student_quizzes_helper.rb'''

==Modifications made to the existing code==
'''1. Modification - ''' Added comments for custom methods in this controller explaining the purpose. 

<pre>
# Based on the logged in user, verifies user's authourizations and privileges
def action_allowed?
</pre>
<pre>
# Initializes instance variables needed to fetch the necessary details of the quizzes.
def index
</pre>
<pre>
# For the response provided, this methods displays the questions, right/wrong answers and the final score.
def finished_quiz
</pre>
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
def self.take_quiz(assignment_id, reviewer_id)
</pre>
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
def record_response
</pre>
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
def review_questions
</pre>
<pre>
# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
</pre>
<pre>
# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>
<pre>
# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>

'''2. Modification - ''' Line 29 - .first has been changed to .last to count the score of the most recent attempt of the quiz. 
student_quizzes_controller.rb: 
Old:
<pre>
@response = Response.where(map_id: params[:map_id]).first
</pre>
New:
<pre>
@response = Response.where(map_id: params[:map_id]).last
</pre>

'''3. Modification - ''' Line 33 - @map has been renamed to @quiz_response_map to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@map = ResponseMap.find(params[:map_id])
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
@quiz_response_map = ResponseMap.find(params[:map_id])
@quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>

'''4. Modification - ''' Line 34 - @participant has been changed to @quiz_taker to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>
finished_quiz.html.erb: 
Old:
<pre>
<% @assignment = Assignment.find(@participant.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @participant, :stage => ""} %>
</pre>
New:
<pre>
<% @assignment = Assignment.find(@quiz_taker.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @quiz_taker, :stage => ""} %>
</pre>

'''5. Modification - ''' Line 39 - The method comment of self.take_quiz has been updated to describe its function 
student_quizzes_controller.rb: 
Old:
<pre>
# Gives details of the list of quizzes created by other teams for current project that a reviewer can take
</pre>
New:
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
</pre>

'''6. Modification - ''' Controller Method calculate_score has been split into three separate functions since the original method is too big and is split to use the other methods to handle score calculation for Single choice / True or False questions and Multiple answer questions separately. Then all three methods have been moved to student_quizzes_helper.rb file since they are being reused. 
student_quizzes_helper.rb: 
New:
<pre>
module StudentQuizzesHelper

# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
questionnaire = Questionnaire.find(map.reviewed_object_id)
answers = []
has_response = true
questions = Question.where(questionnaire_id: questionnaire.id)
questions.each do |question|
correct_answers = QuizQuestionChoice.where(question_id: question.id, iscorrect: true)
ques_type = question.type
if ques_type.eql? 'MultipleChoiceCheckbox'
has_response = multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
# TrueFalse and MultipleChoiceRadio
else
has_response = single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
end
end
if has_response
answers.each(&:save)
redirect_to controller: 'student_quizzes', action: 'finished_quiz', map_id: map.id
else
response.destroy
flash[:error] = 'Please answer every question.'
redirect_to action: :take_quiz, assignment_id: params[:assignment_id], questionnaire_id: questionnaire.id, map_id: map.id
end
end

# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
score = 0
if params[question.id.to_s].nil?
has_response = false
else
params[question.id.to_s].each do |choice|
# loop the quiz taker's choices and see if 1)all the correct choice are checked and 2) # of quiz taker's choice matches the # of the correct choices
correct_answers.each do |correct|
score += 1 if choice.eql? correct.txt
end
end
score = score == correct_answers.count && score == params[question.id.to_s].count ? 1 : 0
# for MultipleChoiceCheckbox, score =1 means the quiz taker have done this question correctly, not just make select this choice correctly.
params[question.id.to_s].each do |choice|
new_answer = Answer.new comments: choice, question_id: question.id, response_id: response.id, answer: score

has_response = false unless new_answer.valid?
answers.push(new_answer)
end
end
return has_response
end

# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
correct_answer = correct_answers.first
score = correct_answer.txt == params[question.id.to_s] ? 1 : 0
new_score = Answer.new comments: params[question.id.to_s], question_id: question.id, response_id: response.id, answer: score
has_response = false if new_score.nil? || new_score.comments.nil? || new_score.comments.empty?
answers.push(new_score)
return has_response
end

end
</pre>

'''7. Modification - ''' Line 60 - A method comment has been added for record_response to describe its function 
student_quizzes_controller.rb: 
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
</pre>

'''8. Modification - ''' -graded? has been removed as it is no longer necessary. 

'''9. Modification - ''' Line 72 - The Flash message has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
flash[:error] = 'You have already taken this quiz, below are the records for your response.'
</pre>
New:
<pre>
flash[:error] = 'You have already taken this quiz. Below are the responses of your previous attempt.'
</pre>

'''10. Modification - ''' Line 77 - The method comment for review_questions has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
</pre>
New:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
</pre>

==Test Plan==
===Manual Testing===
Follow these instructions to manually test the functionality of student_quizzes_controller. 
'''1'''. Login as instructor using the credentials, username: instructor6, password: password. 
'''2'''. Select the '''Assignments''' subheading. Here, create a new assignment by entering the necessary details. Enable the '''Has Teams?''' checkbox and create. Also enable the '''Has quiz?''' checkbox. 
'''3'''. Navigate to the Due Dates tab and set appropriate due dates for submission and review. For Round 1: Review, enable Has Quiz using the dropdown Menu. Once you save, A '''Number of Quiz questions''' field will be visible on the Assignments page. Set this to 2 and save. 
'''4'''. At the top of the page, there will be a notice asking you to add participants. Using the link provided, add a few students to the assignment. 
'''5'''. Logout as the Instructor and Login as the students. Make submissions for the assignment before the submission deadline. 
Note: You must create a team and set team name to be able to make a submission. 
'''6'''. At the bottom of the submission page, you will see a '''Create a Quiz''' link. Select that link. 
'''7'''. This takes you to the quiz creation page. Here you can set Radio Button MCQs, Checkbox MCQs and True/False Questions and set the correct answers. 
Then select '''Create Quiz'''. This creates the quiz. 
'''8'''. Logout and login as another student registered in the assignment. Make a submission as this student. Once the submission deadline has passed, review the first student's work and return to the main menu. 
'''9'''. You will see the option to '''Take quizzes'''. Here, select the quiz you have created and select '''Request'''. Here, you can take the quiz created by the other student.

===Manual Testing Walkthorugh===

===Testing Video===
Originally the student_quizzes_controller does not have any test cases, so according to the documentation, we wrote some to check if the changes we introduced have broken the functionality. Our test cases have run successfully. Here is the video for the same. 
[https://drive.google.com/file/d/1Kl8f71sylFVBIKymvjWN9A_69jbwoDdP/view?usp=sharing Test Video]

==Team members==
Jyothi Sumer Goud Maduru (jmaduru@ncsu.edu) 
Pradyumna Vemuri (pvemuri@ncsu.edu) 
Karthik Narayanan Gopala Sundaresan (kgopala3@ncsu.edu)

==Team Mentor==
Divyang Doshi (ddoshi2@ncsu.edu)

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-27T22:12:38Z

Pvemuri:

==About Expertiza==
Expertiza is a multi-purpose web application built using Ruby on Rails for Students and Instructors. Instructors enrolled in Expertiza can create and customize classes, teams, assignments, quizzes, and many more. On the other hand, Students are also allowed to form teams, attempt quizzes, and complete assignments. Apart from that, Expertiza also allows students to provide peer reviews enabling them to work together to improve others' learning experiences. It is an open-source application and its Github repository is [https://github.com/expertiza/expertiza Expertiza].
==E2215. Refactoring student_quizzes_controller.rb in Expertiza==
This page is a description of Expertiza OSS project E2215, which is refactoring the student_quizzes_controller.rb file.

==Controller Description==
The student_quizzes_controller consists of methods involved in creating, scoring & recording responses of the quizzes taken by reviewers or students of the other teams with the same assignment. This controller has some issues that violate essential Rails design principles such as the DRY principle. There are a few methods in this controller that should have been in model classes. Some methods share code, which creates code repetition. Some method comments need to be rewritten.

==Files Modified==
1. app/controllers/'''student_quizzes_controller.rb''' 2. app/views/student_quizzes/f'''inished_quiz.html''' 3. app/helpers/'''student_quizzes_helper.rb'''

==Modifications made to the existing code==
'''1. Modification - ''' Added comments for custom methods in this controller explaining the purpose. 

<pre>
# Based on the logged in user, verifies user's authourizations and privileges
def action_allowed?
</pre>
<pre>
# Initializes instance variables needed to fetch the necessary details of the quizzes.
def index
</pre>
<pre>
# For the response provided, this methods displays the questions, right/wrong answers and the final score.
def finished_quiz
</pre>
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
def self.take_quiz(assignment_id, reviewer_id)
</pre>
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
def record_response
</pre>
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
def review_questions
</pre>
<pre>
# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
</pre>
<pre>
# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>
<pre>
# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>

'''2. Modification - ''' Line 29 - .first has been changed to .last to count the score of the most recent attempt of the quiz. 
student_quizzes_controller.rb: 
Old:
<pre>
@response = Response.where(map_id: params[:map_id]).first
</pre>
New:
<pre>
@response = Response.where(map_id: params[:map_id]).last
</pre>

'''3. Modification - ''' Line 33 - @map has been renamed to @quiz_response_map to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@map = ResponseMap.find(params[:map_id])
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
@quiz_response_map = ResponseMap.find(params[:map_id])
@quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>

'''4. Modification - ''' Line 34 - @participant has been changed to @quiz_taker to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>
finished_quiz.html.erb: 
Old:
<pre>
<% @assignment = Assignment.find(@participant.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @participant, :stage => ""} %>
</pre>
New:
<pre>
<% @assignment = Assignment.find(@quiz_taker.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @quiz_taker, :stage => ""} %>
</pre>

'''5. Modification - ''' Line 39 - The method comment of self.take_quiz has been updated to describe its function 
student_quizzes_controller.rb: 
Old:
<pre>
# Gives details of the list of quizzes created by other teams for current project that a reviewer can take
</pre>
New:
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
</pre>

'''6. Modification - ''' Controller Method calculate_score has been split into three separate functions since the original method is too big and is split to use the other methods to handle score calculation for Single choice / True or False questions and Multiple answer questions separately. Then all three methods have been moved to student_quizzes_helper.rb file since they are being reused. 
student_quizzes_helper.rb: 
New:
<pre>
module StudentQuizzesHelper

# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
questionnaire = Questionnaire.find(map.reviewed_object_id)
answers = []
has_response = true
questions = Question.where(questionnaire_id: questionnaire.id)
questions.each do |question|
correct_answers = QuizQuestionChoice.where(question_id: question.id, iscorrect: true)
ques_type = question.type
if ques_type.eql? 'MultipleChoiceCheckbox'
has_response = multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
# TrueFalse and MultipleChoiceRadio
else
has_response = single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
end
end
if has_response
answers.each(&:save)
redirect_to controller: 'student_quizzes', action: 'finished_quiz', map_id: map.id
else
response.destroy
flash[:error] = 'Please answer every question.'
redirect_to action: :take_quiz, assignment_id: params[:assignment_id], questionnaire_id: questionnaire.id, map_id: map.id
end
end

# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
score = 0
if params[question.id.to_s].nil?
has_response = false
else
params[question.id.to_s].each do |choice|
# loop the quiz taker's choices and see if 1)all the correct choice are checked and 2) # of quiz taker's choice matches the # of the correct choices
correct_answers.each do |correct|
score += 1 if choice.eql? correct.txt
end
end
score = score == correct_answers.count && score == params[question.id.to_s].count ? 1 : 0
# for MultipleChoiceCheckbox, score =1 means the quiz taker have done this question correctly, not just make select this choice correctly.
params[question.id.to_s].each do |choice|
new_answer = Answer.new comments: choice, question_id: question.id, response_id: response.id, answer: score

has_response = false unless new_answer.valid?
answers.push(new_answer)
end
end
return has_response
end

# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
correct_answer = correct_answers.first
score = correct_answer.txt == params[question.id.to_s] ? 1 : 0
new_score = Answer.new comments: params[question.id.to_s], question_id: question.id, response_id: response.id, answer: score
has_response = false if new_score.nil? || new_score.comments.nil? || new_score.comments.empty?
answers.push(new_score)
return has_response
end

end
</pre>

'''7. Modification - ''' Line 60 - A method comment has been added for record_response to describe its function 
student_quizzes_controller.rb: 
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
</pre>

'''8. Modification - ''' -graded? has been removed as it is no longer necessary. 

'''9. Modification - ''' Line 72 - The Flash message has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
flash[:error] = 'You have already taken this quiz, below are the records for your response.'
</pre>
New:
<pre>
flash[:error] = 'You have already taken this quiz. Below are the responses of your previous attempt.'
</pre>

'''10. Modification - ''' Line 77 - The method comment for review_questions has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
</pre>
New:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
</pre>

==Test Plan==
===Manual Testing===
Follow these instructions to manually test the functionality of student_quizzes_controller. 
'''1'''. Login as instructor using the credentials, username: instructor6, password: password. 
'''2'''. Select the '''Assignments''' subheading. Here, create a new assignment by entering the necessary details. Enable the '''Has Teams?''' checkbox and create. Also enable the '''Has quiz?''' checkbox. 
'''3'''. Navigate to the Due Dates tab and set appropriate due dates for submission and review. For Round 1: Review, enable Has Quiz using the dropdown Menu. Once you save, A '''Number of Quiz questions''' field will be visible on the Assignments page. Set this to 2 and save. 
'''4'''. At the top of the page, there will be a notice asking you to add participants. Using the link provided, add a few students to the assignment. 
'''5'''. Logout as the Instructor and Login as the students. Make submissions for the assignment before the submission deadline. 
Note: You must create a team and set team name to be able to make a submission. 
'''6'''. At the bottom of the submission page, you will see a '''Create a Quiz''' link. Select that link. 
'''7'''. This takes you to the quiz creation page. Here you can set Radio Button MCQs, Checkbox MCQs and True/False Questions and set the correct answers. 
Then select '''Create Quiz'''. This creates the quiz. 
'''8'''. Logout and login as another student registered in the assignment. Make a submission as this student. Once the submission deadline has passed, review the first student's work and return to the main menu. 
'''9'''. You will see the option to '''Take quizzes'''. Here, select the quiz you have created and select '''Request'''. Here, you can take the quiz created by the other student.

===Manual Testing Walkthorugh===

===Testing Video===

==Team members==
Jyothi Sumer Goud Maduru (jmaduru@ncsu.edu) 
Pradyumna Vemuri (pvemuri@ncsu.edu) 
Karthik Narayanan Gopala Sundaresan (kgopala3@ncsu.edu)

==Team Mentor==
Divyang Doshi (ddoshi2@ncsu.edu)

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-22T01:24:56Z

Pvemuri: /* Team members */

==About Expertiza==
Expertiza is a multi-purpose web application built using Ruby on Rails for Students and Instructors. Instructors enrolled in Expertiza can create and customize classes, teams, assignments, quizzes, and many more. On the other hand, Students are also allowed to form teams, attempt quizzes, and complete assignments. Apart from that, Expertiza also allows students to provide peer reviews enabling them to work together to improve others' learning experiences. It is an open-source application and its Github repository is [https://github.com/expertiza/expertiza Expertiza].
==E2215. Refactoring student_quizzes_controller.rb in Expertiza==
This page is a description of Expertiza OSS project E2215, which is refactoring the student_quizzes_controller.rb file.

==Controller Description==
The student_quizzes_controller consists of methods involved in creating, scoring & recording responses of the quizzes taken by reviewers or students of the other teams with the same assignment. This controller has some issues that violate essential Rails design principles such as the DRY principle. There are a few methods in this controller that should have been in model classes. Some methods share code, which creates code repetition. Some method comments need to be rewritten.

==Files Modified==
1. app/controllers/'''student_quizzes_controller.rb''' 2. app/views/student_quizzes/f'''inished_quiz.html''' 3. app/helpers/'''student_quizzes_helper.rb'''

==Modifications made to the existing code==
'''1. Modification - ''' Added comments for custom methods in this controller explaining the purpose. 

<pre>
# Based on the logged in user, verifies user's authourizations and privileges
def action_allowed?
</pre>
<pre>
# Initializes instance variables needed to fetch the necessary details of the quizzes.
def index
</pre>
<pre>
# For the response provided, this methods displays the questions, right/wrong answers and the final score.
def finished_quiz
</pre>
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
def self.take_quiz(assignment_id, reviewer_id)
</pre>
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
def record_response
</pre>
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
def review_questions
</pre>
<pre>
# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
</pre>
<pre>
# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>
<pre>
# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>

'''2. Modification - ''' Line 29 - .first has been changed to .last to count the score of the most recent attempt of the quiz. 
student_quizzes_controller.rb: 
Old:
<pre>
@response = Response.where(map_id: params[:map_id]).first
</pre>
New:
<pre>
@response = Response.where(map_id: params[:map_id]).last
</pre>

'''3. Modification - ''' Line 33 - @map has been renamed to @quiz_response_map to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@map = ResponseMap.find(params[:map_id])
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
@quiz_response_map = ResponseMap.find(params[:map_id])
@quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>

'''4. Modification - ''' Line 34 - @participant has been changed to @quiz_taker to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>
finished_quiz.html.erb: 
Old:
<pre>
<% @assignment = Assignment.find(@participant.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @participant, :stage => ""} %>
</pre>
New:
<pre>
<% @assignment = Assignment.find(@quiz_taker.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @quiz_taker, :stage => ""} %>
</pre>

'''5. Modification - ''' Line 39 - The method comment of self.take_quiz has been updated to describe its function 
student_quizzes_controller.rb: 
Old:
<pre>
# Gives details of the list of quizzes created by other teams for current project that a reviewer can take
</pre>
New:
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
</pre>

'''6. Modification - ''' Controller Method calculate_score has been split into three separate functions since the original method is too big and is split to use the other methods to handle score calculation for Single choice / True or False questions and Multiple answer questions separately. Then all three methods have been moved to student_quizzes_helper.rb file since they are being reused. 
student_quizzes_helper.rb: 
New:
<pre>
module StudentQuizzesHelper

# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
questionnaire = Questionnaire.find(map.reviewed_object_id)
answers = []
has_response = true
questions = Question.where(questionnaire_id: questionnaire.id)
questions.each do |question|
correct_answers = QuizQuestionChoice.where(question_id: question.id, iscorrect: true)
ques_type = question.type
if ques_type.eql? 'MultipleChoiceCheckbox'
has_response = multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
# TrueFalse and MultipleChoiceRadio
else
has_response = single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
end
end
if has_response
answers.each(&:save)
redirect_to controller: 'student_quizzes', action: 'finished_quiz', map_id: map.id
else
response.destroy
flash[:error] = 'Please answer every question.'
redirect_to action: :take_quiz, assignment_id: params[:assignment_id], questionnaire_id: questionnaire.id, map_id: map.id
end
end

# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
score = 0
if params[question.id.to_s].nil?
has_response = false
else
params[question.id.to_s].each do |choice|
# loop the quiz taker's choices and see if 1)all the correct choice are checked and 2) # of quiz taker's choice matches the # of the correct choices
correct_answers.each do |correct|
score += 1 if choice.eql? correct.txt
end
end
score = score == correct_answers.count && score == params[question.id.to_s].count ? 1 : 0
# for MultipleChoiceCheckbox, score =1 means the quiz taker have done this question correctly, not just make select this choice correctly.
params[question.id.to_s].each do |choice|
new_answer = Answer.new comments: choice, question_id: question.id, response_id: response.id, answer: score

has_response = false unless new_answer.valid?
answers.push(new_answer)
end
end
return has_response
end

# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
correct_answer = correct_answers.first
score = correct_answer.txt == params[question.id.to_s] ? 1 : 0
new_score = Answer.new comments: params[question.id.to_s], question_id: question.id, response_id: response.id, answer: score
has_response = false if new_score.nil? || new_score.comments.nil? || new_score.comments.empty?
answers.push(new_score)
return has_response
end

end
</pre>

'''7. Modification - ''' Line 60 - A method comment has been added for record_response to describe its function 
student_quizzes_controller.rb: 
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
</pre>

'''8. Modification - ''' -graded? has been removed as it is no longer necessary. 

'''9. Modification - ''' Line 72 - The Flash message has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
flash[:error] = 'You have already taken this quiz, below are the records for your response.'
</pre>
New:
<pre>
flash[:error] = 'You have already taken this quiz. Below are the responses of your previous attempt.'
</pre>

'''10. Modification - ''' Line 77 - The method comment for review_questions has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
</pre>
New:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
</pre>

==Team members==
Jyothi Sumer Goud Maduru (jmaduru@ncsu.edu) 
Pradyumna Vemuri (pvemuri@ncsu.edu) 
Karthik Narayanan Gopala Sundaresan (kgopala3@ncsu.edu)

==Team Mentor==
Divyang Doshi (ddoshi2@ncsu.edu)

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-22T01:24:40Z

Pvemuri:

==About Expertiza==
Expertiza is a multi-purpose web application built using Ruby on Rails for Students and Instructors. Instructors enrolled in Expertiza can create and customize classes, teams, assignments, quizzes, and many more. On the other hand, Students are also allowed to form teams, attempt quizzes, and complete assignments. Apart from that, Expertiza also allows students to provide peer reviews enabling them to work together to improve others' learning experiences. It is an open-source application and its Github repository is [https://github.com/expertiza/expertiza Expertiza].
==E2215. Refactoring student_quizzes_controller.rb in Expertiza==
This page is a description of Expertiza OSS project E2215, which is refactoring the student_quizzes_controller.rb file.

==Controller Description==
The student_quizzes_controller consists of methods involved in creating, scoring & recording responses of the quizzes taken by reviewers or students of the other teams with the same assignment. This controller has some issues that violate essential Rails design principles such as the DRY principle. There are a few methods in this controller that should have been in model classes. Some methods share code, which creates code repetition. Some method comments need to be rewritten.

==Files Modified==
1. app/controllers/'''student_quizzes_controller.rb''' 2. app/views/student_quizzes/f'''inished_quiz.html''' 3. app/helpers/'''student_quizzes_helper.rb'''

==Modifications made to the existing code==
'''1. Modification - ''' Added comments for custom methods in this controller explaining the purpose. 

<pre>
# Based on the logged in user, verifies user's authourizations and privileges
def action_allowed?
</pre>
<pre>
# Initializes instance variables needed to fetch the necessary details of the quizzes.
def index
</pre>
<pre>
# For the response provided, this methods displays the questions, right/wrong answers and the final score.
def finished_quiz
</pre>
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
def self.take_quiz(assignment_id, reviewer_id)
</pre>
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
def record_response
</pre>
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
def review_questions
</pre>
<pre>
# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
</pre>
<pre>
# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>
<pre>
# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>

'''2. Modification - ''' Line 29 - .first has been changed to .last to count the score of the most recent attempt of the quiz. 
student_quizzes_controller.rb: 
Old:
<pre>
@response = Response.where(map_id: params[:map_id]).first
</pre>
New:
<pre>
@response = Response.where(map_id: params[:map_id]).last
</pre>

'''3. Modification - ''' Line 33 - @map has been renamed to @quiz_response_map to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@map = ResponseMap.find(params[:map_id])
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
@quiz_response_map = ResponseMap.find(params[:map_id])
@quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>

'''4. Modification - ''' Line 34 - @participant has been changed to @quiz_taker to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>
finished_quiz.html.erb: 
Old:
<pre>
<% @assignment = Assignment.find(@participant.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @participant, :stage => ""} %>
</pre>
New:
<pre>
<% @assignment = Assignment.find(@quiz_taker.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @quiz_taker, :stage => ""} %>
</pre>

'''5. Modification - ''' Line 39 - The method comment of self.take_quiz has been updated to describe its function 
student_quizzes_controller.rb: 
Old:
<pre>
# Gives details of the list of quizzes created by other teams for current project that a reviewer can take
</pre>
New:
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
</pre>

'''6. Modification - ''' Controller Method calculate_score has been split into three separate functions since the original method is too big and is split to use the other methods to handle score calculation for Single choice / True or False questions and Multiple answer questions separately. Then all three methods have been moved to student_quizzes_helper.rb file since they are being reused. 
student_quizzes_helper.rb: 
New:
<pre>
module StudentQuizzesHelper

# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
questionnaire = Questionnaire.find(map.reviewed_object_id)
answers = []
has_response = true
questions = Question.where(questionnaire_id: questionnaire.id)
questions.each do |question|
correct_answers = QuizQuestionChoice.where(question_id: question.id, iscorrect: true)
ques_type = question.type
if ques_type.eql? 'MultipleChoiceCheckbox'
has_response = multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
# TrueFalse and MultipleChoiceRadio
else
has_response = single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
end
end
if has_response
answers.each(&:save)
redirect_to controller: 'student_quizzes', action: 'finished_quiz', map_id: map.id
else
response.destroy
flash[:error] = 'Please answer every question.'
redirect_to action: :take_quiz, assignment_id: params[:assignment_id], questionnaire_id: questionnaire.id, map_id: map.id
end
end

# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
score = 0
if params[question.id.to_s].nil?
has_response = false
else
params[question.id.to_s].each do |choice|
# loop the quiz taker's choices and see if 1)all the correct choice are checked and 2) # of quiz taker's choice matches the # of the correct choices
correct_answers.each do |correct|
score += 1 if choice.eql? correct.txt
end
end
score = score == correct_answers.count && score == params[question.id.to_s].count ? 1 : 0
# for MultipleChoiceCheckbox, score =1 means the quiz taker have done this question correctly, not just make select this choice correctly.
params[question.id.to_s].each do |choice|
new_answer = Answer.new comments: choice, question_id: question.id, response_id: response.id, answer: score

has_response = false unless new_answer.valid?
answers.push(new_answer)
end
end
return has_response
end

# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
correct_answer = correct_answers.first
score = correct_answer.txt == params[question.id.to_s] ? 1 : 0
new_score = Answer.new comments: params[question.id.to_s], question_id: question.id, response_id: response.id, answer: score
has_response = false if new_score.nil? || new_score.comments.nil? || new_score.comments.empty?
answers.push(new_score)
return has_response
end

end
</pre>

'''7. Modification - ''' Line 60 - A method comment has been added for record_response to describe its function 
student_quizzes_controller.rb: 
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
</pre>

'''8. Modification - ''' -graded? has been removed as it is no longer necessary. 

'''9. Modification - ''' Line 72 - The Flash message has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
flash[:error] = 'You have already taken this quiz, below are the records for your response.'
</pre>
New:
<pre>
flash[:error] = 'You have already taken this quiz. Below are the responses of your previous attempt.'
</pre>

'''10. Modification - ''' Line 77 - The method comment for review_questions has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
</pre>
New:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
</pre>

==Team members==
Jyothi Sumer Goud Maduru (jmaduru@ncsu.edu)
Pradyumna Vemuri (pvemuri@ncsu.edu)
Karthik Narayanan Gopala Sundaresan (kgopala3@ncsu.edu)

==Team Mentor==
Divyang Doshi (ddoshi2@ncsu.edu)

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-22T00:49:05Z

Pvemuri:

==About Expertiza==
Expertiza is a multi-purpose web application built using Ruby on Rails for Students and Instructors. Instructors enrolled in Expertiza can create and customize classes, teams, assignments, quizzes, and many more. On the other hand, Students are also allowed to form teams, attempt quizzes, and complete assignments. Apart from that, Expertiza also allows students to provide peer reviews enabling them to work together to improve others' learning experiences. It is an open-source application and its Github repository is [https://github.com/expertiza/expertiza Expertiza].
==E2215. Refactoring student_quizzes_controller.rb in Expertiza==
This page is a description of Expertiza OSS project E2215, which is refactoring the student_quizzes_controller.rb file.

==Controller Description==
The student_quizzes_controller consists of methods involved in creating, scoring & recording responses of the quizzes taken by reviewers or students of the other teams with the same assignment. This controller has some issues that violate essential Rails design principles such as the DRY principle. There are a few methods in this controller that should have been in model classes. Some methods share code, which creates code repetition. Some method comments need to be rewritten.

==Files Modified==
1. app/controllers/'''student_quizzes_controller.rb''' 2. app/views/student_quizzes/f'''inished_quiz.html''' 3. app/helpers/'''student_quizzes_helper.rb'''

==Modifications made to the existing code==
'''1. Modification - ''' Added comments for custom methods in this controller explaining the purpose. 

<pre>
# Based on the logged in user, verifies user's authourizations and privileges
def action_allowed?
</pre>
<pre>
# Initializes instance variables needed to fetch the necessary details of the quizzes.
def index
</pre>
<pre>
# For the response provided, this methods displays the questions, right/wrong answers and the final score.
def finished_quiz
</pre>
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
def self.take_quiz(assignment_id, reviewer_id)
</pre>
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
def record_response
</pre>
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
def review_questions
</pre>
<pre>
# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
</pre>
<pre>
# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>
<pre>
# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>

'''2. Modification - ''' Line 29 - .first has been changed to .last to count the score of the most recent attempt of the quiz. 
student_quizzes_controller.rb: 
Old:
<pre>
@response = Response.where(map_id: params[:map_id]).first
</pre>
New:
<pre>
@response = Response.where(map_id: params[:map_id]).last
</pre>

'''3. Modification - ''' Line 33 - @map has been renamed to @quiz_response_map to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@map = ResponseMap.find(params[:map_id])
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
@quiz_response_map = ResponseMap.find(params[:map_id])
@quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>

'''4. Modification - ''' Line 34 - @participant has been changed to @quiz_taker to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>
finished_quiz.html.erb: 
Old:
<pre>
<% @assignment = Assignment.find(@participant.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @participant, :stage => ""} %>
</pre>
New:
<pre>
<% @assignment = Assignment.find(@quiz_taker.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @quiz_taker, :stage => ""} %>
</pre>

'''5. Modification - ''' Line 39 - The method comment of self.take_quiz has been updated to describe its function 
student_quizzes_controller.rb: 
Old:
<pre>
# Gives details of the list of quizzes created by other teams for current project that a reviewer can take
</pre>
New:
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
</pre>

'''6. Modification - ''' Controller Method calculate_score has been split into three separate functions since the original method is too big and is split to use the other methods to handle score calculation for Single choice / True or False questions and Multiple answer questions separately. Then all three methods have been moved to student_quizzes_helper.rb file since they are being reused. 
student_quizzes_helper.rb: 
New:
<pre>
module StudentQuizzesHelper

# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
questionnaire = Questionnaire.find(map.reviewed_object_id)
answers = []
has_response = true
questions = Question.where(questionnaire_id: questionnaire.id)
questions.each do |question|
correct_answers = QuizQuestionChoice.where(question_id: question.id, iscorrect: true)
ques_type = question.type
if ques_type.eql? 'MultipleChoiceCheckbox'
has_response = multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
# TrueFalse and MultipleChoiceRadio
else
has_response = single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
end
end
if has_response
answers.each(&:save)
redirect_to controller: 'student_quizzes', action: 'finished_quiz', map_id: map.id
else
response.destroy
flash[:error] = 'Please answer every question.'
redirect_to action: :take_quiz, assignment_id: params[:assignment_id], questionnaire_id: questionnaire.id, map_id: map.id
end
end

# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
score = 0
if params[question.id.to_s].nil?
has_response = false
else
params[question.id.to_s].each do |choice|
# loop the quiz taker's choices and see if 1)all the correct choice are checked and 2) # of quiz taker's choice matches the # of the correct choices
correct_answers.each do |correct|
score += 1 if choice.eql? correct.txt
end
end
score = score == correct_answers.count && score == params[question.id.to_s].count ? 1 : 0
# for MultipleChoiceCheckbox, score =1 means the quiz taker have done this question correctly, not just make select this choice correctly.
params[question.id.to_s].each do |choice|
new_answer = Answer.new comments: choice, question_id: question.id, response_id: response.id, answer: score

has_response = false unless new_answer.valid?
answers.push(new_answer)
end
end
return has_response
end

# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
correct_answer = correct_answers.first
score = correct_answer.txt == params[question.id.to_s] ? 1 : 0
new_score = Answer.new comments: params[question.id.to_s], question_id: question.id, response_id: response.id, answer: score
has_response = false if new_score.nil? || new_score.comments.nil? || new_score.comments.empty?
answers.push(new_score)
return has_response
end

end
</pre>

'''7. Modification - ''' Line 60 - A method comment has been added for record_response to describe its function 
student_quizzes_controller.rb: 
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
</pre>

'''8. Modification - ''' -graded? has been removed as it is no longer necessary. 

'''9. Modification - ''' Line 72 - The Flash message has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
flash[:error] = 'You have already taken this quiz, below are the records for your response.'
</pre>
New:
<pre>
flash[:error] = 'You have already taken this quiz. Below are the responses of your previous attempt.'
</pre>

'''10. Modification - ''' Line 77 - The method comment for review_questions has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
</pre>
New:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
</pre>

==Tests on the Controller Methods==

==Video on changes made==

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-22T00:41:17Z

Pvemuri:

==About Expertiza==
Expertiza is a multi-purpose web application built using Ruby on Rails for Students and Instructors. Instructors enrolled in Expertiza can create and customize classes, teams, assignments, quizzes, and many more. On the other hand, Students are also allowed to form teams, attempt quizzes, and complete assignments. Apart from that, Expertiza also allows students to provide peer reviews enabling them to work together to improve others' learning experiences. It is an open-source application and its Github repository is [https://github.com/expertiza/expertiza Expertiza].
==E2215. Refactoring student_quizzes_controller.rb in Expertiza==
This page is a description of Expertiza OSS project E2215, which is refactoring the student_quizzes_controller.rb file.

==Controller Description==
The student_quizzes_controller consists of methods involved in creating, scoring & recording responses of the quizzes taken by reviewers or students of the other teams with the same assignment. This controller has some issues that violate essential Rails design principles such as the DRY principle. There are a few methods in this controller that should have been in model classes. Some methods share code, which creates code repetition. Some method comments need to be rewritten.

==Files Modified==
1. app/controllers/'''student_quizzes_controller.rb''' 2. app/views/student_quizzes/f'''inished_quiz.html''' 3. app/helpers/'''student_quizzes_helper.rb'''

==Modifications made to the existing code==
'''1. Modification - ''' Added comments for custom methods in this controller explaining the purpose. 

<pre>
# Based on the logged in user, verifies user's authourizations and privileges
def action_allowed?
</pre>
<pre>
# Initializes instance variables needed to fetch the necessary details of the quizzes.
def index
</pre>
<pre>
# For the response provided, this methods displays the questions, right/wrong answers and the final score.
def finished_quiz
</pre>
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
def self.take_quiz(assignment_id, reviewer_id)
</pre>
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
def record_response
</pre>
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
def review_questions
</pre>
<pre>
# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
</pre>
<pre>
# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>
<pre>
# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>

'''2. Modification - ''' Line 29 - .first has been changed to .last to count the score of the most recent attempt of the quiz. 
student_quizzes_controller.rb: 
Old:
<pre>
@response = Response.where(map_id: params[:map_id]).first
</pre>
New:
<pre>
@response = Response.where(map_id: params[:map_id]).last
</pre>

'''3. Modification - ''' Line 33 - @map has been renamed to @quiz_response_map to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@map = ResponseMap.find(params[:map_id])
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
@quiz_response_map = ResponseMap.find(params[:map_id])
@quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>

'''4. Modification - ''' Line 34 - @participant has been changed to @quiz_taker to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>
finished_quiz.html.erb:
Old:
<pre>
<% @assignment = Assignment.find(@participant.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @participant, :stage => ""} %>
</pre>
New:
<pre>
<% @assignment = Assignment.find(@quiz_taker.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @quiz_taker, :stage => ""} %>
</pre>

'''5. Modification - ''' Line 39 - The method comment of self.take_quiz has been updated to describe its function 
student_quizzes_controller.rb: 
Old:
<pre>
# Gives details of the list of quizzes created by other teams for current project that a reviewer can take
</pre>
New:
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
</pre>

'''6. Modification - ''' Controller Method calculate_score has been split into three separate functions since the original method is too big and is split to use the other methods to handle score calculation for Single choice / True or False questions and Multiple answer questions separately. Then all three methods have been moved to student_quizzes_helper.rb file since they are being reused. 
student_quizzes_helper.rb: 
New:
<pre>
module StudentQuizzesHelper

# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
questionnaire = Questionnaire.find(map.reviewed_object_id)
answers = []
has_response = true
questions = Question.where(questionnaire_id: questionnaire.id)
questions.each do |question|
correct_answers = QuizQuestionChoice.where(question_id: question.id, iscorrect: true)
ques_type = question.type
if ques_type.eql? 'MultipleChoiceCheckbox'
has_response = multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
# TrueFalse and MultipleChoiceRadio
else
has_response = single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
end
end
if has_response
answers.each(&:save)
redirect_to controller: 'student_quizzes', action: 'finished_quiz', map_id: map.id
else
response.destroy
flash[:error] = 'Please answer every question.'
redirect_to action: :take_quiz, assignment_id: params[:assignment_id], questionnaire_id: questionnaire.id, map_id: map.id
end
end

# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
score = 0
if params[question.id.to_s].nil?
has_response = false
else
params[question.id.to_s].each do |choice|
# loop the quiz taker's choices and see if 1)all the correct choice are checked and 2) # of quiz taker's choice matches the # of the correct choices
correct_answers.each do |correct|
score += 1 if choice.eql? correct.txt
end
end
score = score == correct_answers.count && score == params[question.id.to_s].count ? 1 : 0
# for MultipleChoiceCheckbox, score =1 means the quiz taker have done this question correctly, not just make select this choice correctly.
params[question.id.to_s].each do |choice|
new_answer = Answer.new comments: choice, question_id: question.id, response_id: response.id, answer: score

has_response = false unless new_answer.valid?
answers.push(new_answer)
end
end
return has_response
end

# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
correct_answer = correct_answers.first
score = correct_answer.txt == params[question.id.to_s] ? 1 : 0
new_score = Answer.new comments: params[question.id.to_s], question_id: question.id, response_id: response.id, answer: score
has_response = false if new_score.nil? || new_score.comments.nil? || new_score.comments.empty?
answers.push(new_score)
return has_response
end

end
</pre>

'''7. Modification - ''' Line 60 - A method comment has been added for record_response to describe its function 
student_quizzes_controller.rb: 
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
</pre>

'''8. Modification - ''' -graded? has been removed as it is no longer necessary. 

'''9. Modification - ''' Line 72 - The Flash message has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
flash[:error] = 'You have already taken this quiz, below are the records for your response.'
</pre>
New:
<pre>
flash[:error] = 'You have already taken this quiz. Below are the responses of your previous attempt.'
</pre>

'''10. Modification - ''' Line 77 - The method comment for review_questions has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
</pre>
New:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
</pre>

==Tests on the Controller Methods==

==Video on changes made==

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-22T00:28:43Z

Pvemuri:

==About Expertiza==
Expertiza is a multi-purpose web application built using Ruby on Rails for Students and Instructors. Instructors enrolled in Expertiza can create and customize classes, teams, assignments, quizzes, and many more. On the other hand, Students are also allowed to form teams, attempt quizzes, and complete assignments. Apart from that, Expertiza also allows students to provide peer reviews enabling them to work together to improve others' learning experiences. It is an open-source application and its Github repository is [https://github.com/expertiza/expertiza Expertiza].
==E2215. Refactoring student_quizzes_controller.rb in Expertiza==
This page is a description of Expertiza OSS project E2215, which is refactoring the student_quizzes_controller.rb file.

==Controller Description==
The student_quizzes_controller consists of methods involved in creating, scoring & recording responses of the quizzes taken by reviewers or students of the other teams with the same assignment. This controller has some issues that violate essential Rails design principles such as the DRY principle. There are a few methods in this controller that should have been in model classes. Some methods share code, which creates code repetition. Some method comments need to be rewritten.

==Files Modified==
1. app/controllers/'''student_quizzes_controller.rb''' 2. app/views/student_quizzes/f'''inished_quiz.html''' 3. app/helpers/'''student_quizzes_helper.rb'''

==Modifications made to the existing code==
'''1. Modification - ''' Added comments for custom methods in this controller explaining the purpose. 

<pre>
# Based on the logged in user, verifies user's authourizations and privileges
def action_allowed?
</pre>
<pre>
# Initializes instance variables needed to fetch the necessary details of the quizzes.
def index
</pre>
<pre>
# For the response provided, this methods displays the questions, right/wrong answers and the final score.
def finished_quiz
</pre>
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
def self.take_quiz(assignment_id, reviewer_id)
</pre>
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
def record_response
</pre>
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
def review_questions
</pre>
<pre>
# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
</pre>
<pre>
# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>
<pre>
# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>

'''2. Modification - ''' Line 29 - .first has been changed to .last to count the score of the most recent attempt of the quiz. 
student_quizzes_controller.rb: 
Old:
<pre>
@response = Response.where(map_id: params[:map_id]).first
</pre>
New:
<pre>
@response = Response.where(map_id: params[:map_id]).last
</pre>

'''3. Modification - ''' Line 33 - @map has been renamed to @quiz_response_map to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@map = ResponseMap.find(params[:map_id])
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
@quiz_response_map = ResponseMap.find(params[:map_id])
@quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>
'''4. Modification - ''' Line 34 - @participant has been changed to @quiz_taker to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>
finished_quiz.html.erb:
Old:
<pre>
<% @assignment = Assignment.find(@participant.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @participant, :stage => ""} %>
</pre>
New:
<pre>
<% @assignment = Assignment.find(@quiz_taker.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @quiz_taker, :stage => ""} %>
</pre>
'''5. Modification - ''' Line 39 - The method comment of self.take_quiz has been updated to describe its function 
student_quizzes_controller.rb: 
Old:
<pre>
# Gives details of the list of quizzes created by other teams for current project that a reviewer can take
</pre>
New:
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
</pre>
'''6. Modification - ''' Controller Method calculate_score has been split into three separate functions and has been moved to student_quizzes_helper.rb. 
student_quizzes_helper.rb: 
New:
<pre>
module StudentQuizzesHelper

# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
questionnaire = Questionnaire.find(map.reviewed_object_id)
answers = []
has_response = true
questions = Question.where(questionnaire_id: questionnaire.id)
questions.each do |question|
correct_answers = QuizQuestionChoice.where(question_id: question.id, iscorrect: true)
ques_type = question.type
if ques_type.eql? 'MultipleChoiceCheckbox'
has_response = multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
# TrueFalse and MultipleChoiceRadio
else
has_response = single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
end
end
if has_response
answers.each(&:save)
redirect_to controller: 'student_quizzes', action: 'finished_quiz', map_id: map.id
else
response.destroy
flash[:error] = 'Please answer every question.'
redirect_to action: :take_quiz, assignment_id: params[:assignment_id], questionnaire_id: questionnaire.id, map_id: map.id
end
end

# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
score = 0
if params[question.id.to_s].nil?
has_response = false
else
params[question.id.to_s].each do |choice|
# loop the quiz taker's choices and see if 1)all the correct choice are checked and 2) # of quiz taker's choice matches the # of the correct choices
correct_answers.each do |correct|
score += 1 if choice.eql? correct.txt
end
end
score = score == correct_answers.count && score == params[question.id.to_s].count ? 1 : 0
# for MultipleChoiceCheckbox, score =1 means the quiz taker have done this question correctly, not just make select this choice correctly.
params[question.id.to_s].each do |choice|
new_answer = Answer.new comments: choice, question_id: question.id, response_id: response.id, answer: score

has_response = false unless new_answer.valid?
answers.push(new_answer)
end
end
return has_response
end

# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
correct_answer = correct_answers.first
score = correct_answer.txt == params[question.id.to_s] ? 1 : 0
new_score = Answer.new comments: params[question.id.to_s], question_id: question.id, response_id: response.id, answer: score
has_response = false if new_score.nil? || new_score.comments.nil? || new_score.comments.empty?
answers.push(new_score)
return has_response
end

end
</pre>
'''7. Modification - ''' Line 60 - A method comment has been added for record_response to describe its function 
student_quizzes_controller.rb: 
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
</pre>
'''8. Modification - ''' -graded? has been removed as it is no longer necessary. 
'''9. Modification - ''' Line 72 - The Flash message has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
flash[:error] = 'You have already taken this quiz, below are the records for your response.'
</pre>
New:
<pre>
flash[:error] = 'You have already taken this quiz. Below are the responses of your previous attempt.'
</pre>
'''10. Modification - ''' Line 77 - The method comment for review_questions has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
</pre>
New:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
</pre>

==Tests on the Controller Methods==

==Video on changes made==

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-22T00:25:46Z

Pvemuri:

==About Expertiza==
Expertiza is a multi-purpose web application built using Ruby on Rails for Students and Instructors. Instructors enrolled in Expertiza can create and customize classes, teams, assignments, quizzes, and many more. On the other hand, Students are also allowed to form teams, attempt quizzes, and complete assignments. Apart from that, Expertiza also allows students to provide peer reviews enabling them to work together to improve others' learning experiences. It is an open-source application and its Github repository is [https://github.com/expertiza/expertiza Expertiza].
==E2215. Refactoring student_quizzes_controller.rb in Expertiza==
This page is a description of Expertiza OSS project E2215, which is refactoring the student_quizzes_controller.rb file.

==Controller Description==
The student_quizzes_controller consists of methods involved in creating, scoring & recording responses of the quizzes taken by reviewers or students of the other teams with the same assignment. This controller has some issues that violate essential Rails design principles such as DRY principle. There are few methods in this controller that should have been in model classes. Some methods share code, which creates code repetition. Some method comments needs to be rewritten.

==Files Modified==
1. student_quizzes_controller.rb 2. finished_quiz.html 3. student_quizzes_helper.rb

==Modifications made to the existing code==
'''1. Modification - ''' Added comments for custom methods in this controller explaining the purpose. 

<pre>
# Based on the logged in user, verifies user's authourizations and privileges
def action_allowed?
</pre>
<pre>
# Initializes instance variables needed to fetch the necessary details of the quizzes.
def index
</pre>
<pre>
# For the response provided, this methods displays the questions, right/wrong answers and the final score.
def finished_quiz
</pre>
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
def self.take_quiz(assignment_id, reviewer_id)
</pre>
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
def record_response
</pre>
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
def review_questions
</pre>
<pre>
# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
</pre>
<pre>
# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>
<pre>
# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>
# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>

'''2. Modification - ''' Line 29 - .first has been changed to .last to count the score of the most recent attempt of the quiz. 
student_quizzes_controller.rb: 
Old:
<pre>
@response = Response.where(map_id: params[:map_id]).first
</pre>
New:
<pre>
@response = Response.where(map_id: params[:map_id]).last
</pre>

'''3. Modification - ''' Line 33 - @map has been renamed to @quiz_response_map to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@map = ResponseMap.find(params[:map_id])
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
@quiz_response_map = ResponseMap.find(params[:map_id])
@quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>
'''4. Modification - ''' Line 34 - @participant has been changed to @quiz_taker to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>
finished_quiz.html.erb:
Old:
<pre>
<% @assignment = Assignment.find(@participant.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @participant, :stage => ""} %>
</pre>
New:
<pre>
<% @assignment = Assignment.find(@quiz_taker.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @quiz_taker, :stage => ""} %>
</pre>
'''5. Modification - ''' Line 39 - The method comment of self.take_quiz has been updated to describe its function 
student_quizzes_controller.rb: 
Old:
<pre>
# Gives details of the list of quizzes created by other teams for current project that a reviewer can take
</pre>
New:
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
</pre>
'''6. Modification - ''' Controller Method calculate_score has been split into three separate functions and has been moved to student_quizzes_helper.rb. 
student_quizzes_helper.rb: 
New:
<pre>
module StudentQuizzesHelper

# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
questionnaire = Questionnaire.find(map.reviewed_object_id)
answers = []
has_response = true
questions = Question.where(questionnaire_id: questionnaire.id)
questions.each do |question|
correct_answers = QuizQuestionChoice.where(question_id: question.id, iscorrect: true)
ques_type = question.type
if ques_type.eql? 'MultipleChoiceCheckbox'
has_response = multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
# TrueFalse and MultipleChoiceRadio
else
has_response = single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
end
end
if has_response
answers.each(&:save)
redirect_to controller: 'student_quizzes', action: 'finished_quiz', map_id: map.id
else
response.destroy
flash[:error] = 'Please answer every question.'
redirect_to action: :take_quiz, assignment_id: params[:assignment_id], questionnaire_id: questionnaire.id, map_id: map.id
end
end

# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
score = 0
if params[question.id.to_s].nil?
has_response = false
else
params[question.id.to_s].each do |choice|
# loop the quiz taker's choices and see if 1)all the correct choice are checked and 2) # of quiz taker's choice matches the # of the correct choices
correct_answers.each do |correct|
score += 1 if choice.eql? correct.txt
end
end
score = score == correct_answers.count && score == params[question.id.to_s].count ? 1 : 0
# for MultipleChoiceCheckbox, score =1 means the quiz taker have done this question correctly, not just make select this choice correctly.
params[question.id.to_s].each do |choice|
new_answer = Answer.new comments: choice, question_id: question.id, response_id: response.id, answer: score

has_response = false unless new_answer.valid?
answers.push(new_answer)
end
end
return has_response
end

# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
correct_answer = correct_answers.first
score = correct_answer.txt == params[question.id.to_s] ? 1 : 0
new_score = Answer.new comments: params[question.id.to_s], question_id: question.id, response_id: response.id, answer: score
has_response = false if new_score.nil? || new_score.comments.nil? || new_score.comments.empty?
answers.push(new_score)
return has_response
end

end
</pre>
'''7. Modification - ''' Line 60 - A method comment has been added for record_response to describe its function 
student_quizzes_controller.rb: 
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
</pre>
'''8. Modification - ''' -graded? has been removed as it is no longer necessary. 
'''9. Modification - ''' Line 72 - The Flash message has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
flash[:error] = 'You have already taken this quiz, below are the records for your response.'
</pre>
New:
<pre>
flash[:error] = 'You have already taken this quiz. Below are the responses of your previous attempt.'
</pre>
'''10. Modification - ''' Line 77 - The method comment for review_questions has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
</pre>
New:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
</pre>

==Tests on the Controller Methods==

==Video on changes made==

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-22T00:24:36Z

Pvemuri:

==About Expertiza==
Expertiza is a multi-purpose web application built using Ruby on Rails for Students and Instructors. Instructors enrolled in Expertiza can create and customize classes, teams, assignments, quizzes, and many more. On the other hand, Students are also allowed to form teams, attempt quizzes, and complete assignments. Apart from that, Expertiza also allows students to provide peer reviews enabling them to work together to improve others' learning experiences. It is an open-source application and its Github repository is [https://github.com/expertiza/expertiza Expertiza].
==E2215. Refactoring student_quizzes_controller.rb in Expertiza==
This page is a description of Expertiza OSS project E2215, which is refactoring the student_quizzes_controller.rb file.

==Controller Description==
The student_quizzes_controller consists of methods involved in creating, scoring & recording responses of the quizzes taken by reviewers or students of the other teams with the same assignment. This controller has some issues that violate essential Rails design principles such as DRY principle. There are few methods in this controller that should have been in model classes. Some methods share code, which creates code repetition. Some method comments needs to be rewritten.

==Files Modified==
1. student_quizzes_controller.rb 2. finished_quiz.html 3. student_quizzes_helper.rb

==Modifications made to the existing code==
'''1. Modification - ''' Added comments for custom methods in this controller explaining the purpose. 
<pre>
# Based on the logged in user, verifies user's authourizations and privileges
def action_allowed?
</pre>
<pre>
# Initializes instance variables needed to fetch the necessary details of the quizzes.
def index
</pre>
<pre>
# For the response provided, this methods displays the questions, right/wrong answers and the final score.
def finished_quiz
</pre>
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
def self.take_quiz(assignment_id, reviewer_id)
</pre>
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
def record_response
</pre>
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
def review_questions
</pre>
<pre>
# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
</pre>
<pre>
# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>
<pre>
# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>
# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
</pre>
'''2. Modification - ''' Line 29 - .first has been changed to .last to count the score of the most recent attempt of the quiz. 
student_quizzes_controller.rb: 
Old:
<pre>
@response = Response.where(map_id: params[:map_id]).first
</pre>
New:
<pre>
@response = Response.where(map_id: params[:map_id]).last
</pre>
'''3. Modification - ''' Line 33 - @map has been renamed to @quiz_response_map to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@map = ResponseMap.find(params[:map_id])
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
@quiz_response_map = ResponseMap.find(params[:map_id])
@quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>
'''4. Modification - ''' Line 34 - @participant has been changed to @quiz_taker to more accurately describe its function. 
student_quizzes_controller.rb: 
Old:
<pre>
@participant = AssignmentTeam.find(@map.reviewee_id).participants.first
</pre>
New:
<pre>
quiz_taker = AssignmentTeam.find(@quiz_response_map.reviewee_id).participants.first
</pre>
finished_quiz.html.erb:
Old:
<pre>
<% @assignment = Assignment.find(@participant.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @participant, :stage => ""} %>
</pre>
New:
<pre>
<% @assignment = Assignment.find(@quiz_taker.parent_id)%>
<%= render :partial => 'submitted_content/main', :locals => {:participant => @quiz_taker, :stage => ""} %>
</pre>
'''5. Modification - ''' Line 39 - The method comment of self.take_quiz has been updated to describe its function 
student_quizzes_controller.rb: 
Old:
<pre>
# Gives details of the list of quizzes created by other teams for current project that a reviewer can take
</pre>
New:
<pre>
# Lists all the available quizzes created by the other teams in the current project which can be attempted.
</pre>
'''6. Modification - ''' Controller Method calculate_score has been split into three separate functions and has been moved to student_quizzes_helper.rb. 
student_quizzes_helper.rb: 
New:
<pre>
module StudentQuizzesHelper

# This method as whole fetches the answers provided and calculates the final scores for the quiz.
# Also calls seperate methods for handling single answer/ true or false evaluations and mulitple answer evaluations for calculating score.
def calculate_score(map, response)
questionnaire = Questionnaire.find(map.reviewed_object_id)
answers = []
has_response = true
questions = Question.where(questionnaire_id: questionnaire.id)
questions.each do |question|
correct_answers = QuizQuestionChoice.where(question_id: question.id, iscorrect: true)
ques_type = question.type
if ques_type.eql? 'MultipleChoiceCheckbox'
has_response = multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
# TrueFalse and MultipleChoiceRadio
else
has_response = single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
end
end
if has_response
answers.each(&:save)
redirect_to controller: 'student_quizzes', action: 'finished_quiz', map_id: map.id
else
response.destroy
flash[:error] = 'Please answer every question.'
redirect_to action: :take_quiz, assignment_id: params[:assignment_id], questionnaire_id: questionnaire.id, map_id: map.id
end
end

# Evaluates scores for questions that contains multiple answers
def multiple_answer_evaluation(answers, params, question, correct_answers, has_response, response)
score = 0
if params[question.id.to_s].nil?
has_response = false
else
params[question.id.to_s].each do |choice|
# loop the quiz taker's choices and see if 1)all the correct choice are checked and 2) # of quiz taker's choice matches the # of the correct choices
correct_answers.each do |correct|
score += 1 if choice.eql? correct.txt
end
end
score = score == correct_answers.count && score == params[question.id.to_s].count ? 1 : 0
# for MultipleChoiceCheckbox, score =1 means the quiz taker have done this question correctly, not just make select this choice correctly.
params[question.id.to_s].each do |choice|
new_answer = Answer.new comments: choice, question_id: question.id, response_id: response.id, answer: score

has_response = false unless new_answer.valid?
answers.push(new_answer)
end
end
return has_response
end

# Evaluates scores for questions that contains only single/ true or false answers
def single_answer_evaluation(answers, params, question, correct_answers, has_response, response)
correct_answer = correct_answers.first
score = correct_answer.txt == params[question.id.to_s] ? 1 : 0
new_score = Answer.new comments: params[question.id.to_s], question_id: question.id, response_id: response.id, answer: score
has_response = false if new_score.nil? || new_score.comments.nil? || new_score.comments.empty?
answers.push(new_score)
return has_response
end

end
</pre>
'''7. Modification - ''' Line 60 - A method comment has been added for record_response to describe its function 
student_quizzes_controller.rb: 
<pre>
# Stores the answers entered by the quiz taker and calculates the score based on the answers entered.
</pre>
'''8. Modification - ''' -graded? has been removed as it is no longer necessary. 
'''9. Modification - ''' Line 72 - The Flash message has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
flash[:error] = 'You have already taken this quiz, below are the records for your response.'
</pre>
New:
<pre>
flash[:error] = 'You have already taken this quiz. Below are the responses of your previous attempt.'
</pre>
'''10. Modification - ''' Line 77 - The method comment for review_questions has been updated. 
student_quizzes_controller.rb: 
Old:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
</pre>
New:
<pre>
# This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel.
# Using the current assignment id parameter, fetches all the questions for each quiz and finally lists all the answers and scores for each submission.
</pre>

==Tests on the Controller Methods==

==Video on changes made==

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-22T00:11:58Z

Pvemuri:

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-22T00:10:42Z

Pvemuri:

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-19T20:01:55Z

Pvemuri:

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-19T20:01:17Z

Pvemuri: /* Modifications made to the existing code */

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-19T19:53:36Z

Pvemuri:

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-19T19:53:14Z

Pvemuri: /* Files Involved */

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-19T19:52:58Z

Pvemuri:

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-19T16:52:13Z

Pvemuri:

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-19T16:51:38Z

Pvemuri: /* Controller Description */

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-19T16:50:26Z

Pvemuri: /* E2215. Refactoring student_quizzes_controller.rb in Expertiza */

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-19T16:50:00Z

Pvemuri: /* E2215. Refactoring student_quizzes_controller.rb in Expertiza */

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-19T16:49:49Z

Pvemuri: /* E2215. Refactoring student_quizzes_controller.rb in Expertiza */

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-19T16:48:37Z

Pvemuri: /* E2215. Refactoring student_quizzes_controller.rb in Expertiza */

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-19T16:42:35Z

Pvemuri:

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-19T16:42:05Z

Pvemuri:

==About Expertiza==
Expertiza is a multi-purpose web application built using Ruby on Rails for Students and Instructors. Instructors enrolled in expertiza can create and customize classes, teams, assignments, quizzes, and many more. On the other hand, Students are also allowed to form teams, attempt quizzes, and complete assignments. Apart from that, Expertiza also allows students to provide peer reviews enabling them to work together to improve others' learning experiences. It is an open-source application and its Github repository is [[https://github.com/expertiza/expertiza] Expertiza].
==E2215. Refactoring student_quizzes_controller.rb in Expertiza==

==Controller Description==

==Modifications made to the existing code==

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-19T16:40:47Z

Pvemuri:

==About Expertiza==
Expertiza is a multi-purpose web application built using Ruby on Rails for Students and Instructors. Instructors enrolled in expertiza can create and customize classes, teams, assignments, quizzes, and many more. On the other hand, Students are also allowed to form teams, attempt quizzes, and complete assignments. Apart from that, Expertiza also allows students to provide peer reviews enabling them to work together to improve others' learning experiences. It is an open-source application and its Github repository is [[https://github.com/expertiza/expertiza]]
==E2215. Refactoring student_quizzes_controller.rb in Expertiza==

==Controller Description==

==Modifications made to the existing code==

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-19T16:22:59Z

Pvemuri:

==About Expertiza==

==E2215. Refactoring student_quizzes_controller.rb in Expertiza==

==Controller Description==

==Modifications made to the existing code==

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-19T16:21:10Z

Pvemuri:

==About Expertiza==

==E2215. Refactoring student_quizzes_controller.rb in Expertiza==

CSC/ECE 517 Spring 2022 - E2215: Refactor student quizzes controller

2022-03-19T16:20:28Z

Pvemuri: Created page with "==About Expertiza=="

==About Expertiza==

CSC/ECE 517 Spring 2022

2022-03-19T16:19:10Z

Pvemuri: /* OSS Projects */

== OSS Projects ==

* [[CSC/ECE 517 Spring 2022 - E2203: Adding tests for courses_controller, eula_controller]]
* [[CSC/ECE 517 Spring 2022 - E2204: Adding tests for markup_styles_controller, lock_controller]]
* [[CSC/ECE 517 Spring 2022 - E2217: Refactor questionnaires_controller]]
* [[CSC/ECE 517 Spring 2022 - E2216: Refactor late_policies_controller]]
* [[CSC/ECE 517 Spring 2022 - E2215: Refactor student_quizzes_controller]]

== Final Projects ==