Expertiza_Wiki - User contributions [en]

File:Usecasediagram.png

2021-11-30T03:12:46Z

Adas9: Adas9 uploaded a new version of File:Usecasediagram.png

CSC/ECE 517 Fall 2021 - E2159. Expertiza internationalization

2021-11-30T03:09:08Z

Adas9: /* Database Modification */

== Introduction - Purpose & Problem ==

Currently, all Expertiza screens can only be viewed in English. Many Expertiza users are from other countries. This is a problem since this limits the accessibility of Expertiza. An important step in solving this problem is by making Expertiza available in more languages, which is a form of internationalization.
W3C defines [https://www.w3.org/International/questions/qa-i18n internationalization] as “''the design and development of a product, application or document content that enables easy localization for target audiences that vary in culture, region, or language.''”

[[File:country_pie.png|none|500px|]] 
Survey of home country of Expertiza users for a given course 

'''Scope:''' The scope of this project is limited however only to static strings. i.e. user-generated content will not be automatically translated to other languages.

'''Breaking down internationalization into 3 sequential subproblems:''' 
[[File:Twophase2.jpg|none|700px]] 
'''1. Language selection''' 
Every user has an option to set a language preference in the User Profile Information Edit page.

[[File:ProfileEditPage.png]] 
There is also an option where the instructor can choose a default language for a course.

[[File:language2inter.png]]

Thus, the language not only varies from user to user but also across screens for the same user. Thus we need to recompute the language in which the page is to be rendered. If the student has given a language preference, then the choice is given weightage over the course default language chosen by the instructor.

'''2. Rendering the language''' 
'''How do we go about rendering the screen in that language?''' 
In the previous step, we’ve identified the language in which a view is to be rendered. It is important to note that this language may not only differ for a different user, but also for a different page for the same user. The question now becomes, how do we render the screen in this language? 
To tackle this question, we explore 2 fundamental concepts: 
'''2.1 Views are composed of independent language elements''' 
While this is something we typically take for granted, it becomes especially important in the context of translation. That is, a view is not a single contiguous block of text, nor is it an atomic visualization of information (unlike a screenshot), but rather a carefully organized collection of individual elements such as texts, buttons, etc that each contain language that needs to be translated separately. Crucially, this means that we cannot swap out a page in one language in its entirety for a page in another language in its entirety. Instead, each individual element needs to be swapped out individually so as to only impact the language and not the structural composition of the page itself.
 
'''2.2 Views require translation at a large number of call sites''' 
Given that a view is composed of individual elements, this also means that the computation of how to translate such an element such as a button’s text would need to be done separately for each element. This would result in not only a single centralized

'''3. Translation gaps'''

What if the translation for the target language is not available?
Even translation for a language like Hindi may be available in general, the translation for a given text may not be available Hindi. This may be due to a variety of reasons:
<ul>
<li>
The specific text may have been accidentally missed out (remember the translation is not being done at runtime through an API, but rather curated by the developer)
</li>
<li>
The given text is non-trivial to translate to the target language
</li>
</ul>
Our design would thus need to accommodate this by seamlessly falling back on another language whose translation is available.

== Scope ==
The scope of this project is limited however only to static strings. I.e. user-generated content will not be automatically translated to other languages.

== Design ==
'''Proposed Solution''' 
We explore and solve each of the three problems above in isolation:

'''''1. Language selection''''' 
The language in which the page is rendered depends on a set of conditions.

<li>If the user has set a language preference all pages are displayed in that language.</li>

<li>If the user has not set a language preference and the user is an instructor, all the pages are displayed in English.</li>

<li>If the user has not set a language preference and the user is a student who is on a page that is specific to a course for which the instructor has added a default language, the page is displayed in the course’s default language.</li>

The below functions are added and called before page rendering to bring in this logic.
<pre>
before_action :set_locale

def set_locale
# Checks whether the user is logged in, else the default locale is used
if logged_in?
# If the current user has set his preferred language, the locale is set according to their preference
if @current_user.locale != "no_pref"
I18n.locale = @current_user.locale
# If the user doesn't have any preference, the locale is taken from the course locale, if the current page is a course specific page or else default locale is used
elsif current_user_role? && current_user_role.student? && ["student_task", "sign_up_sheet", "student_teams", "student_review", "grades", "submitted_content", "participants"].include?(params[:controller])
set_new_locale_for_student
else
I18n.locale = I18n.default_locale
end
else
I18n.locale = I18n.default_locale
end
end

def set_new_locale_for_student
# Gets participant using student from params
if !params[:id].nil? || !params[:student_id].nil?
participant_id = params[:id] || params[:student_id]
participant = AssignmentParticipant.find_by(id: participant_id)
# If id or student_id not correct, revert to locale based on courses.
if participant.nil?
find_locale_from_courses
return
end
# Find assignment from participant and find locale from the assigment
assignment = participant.assignment
if !assignment.course.nil?
new_locale = assignment.course.locale
if !new_locale.nil?
I18n.locale = new_locale
else
I18n.locale = I18n.default_locale
end
else
I18n.locale = I18n.default_locale
end
else
find_locale_from_courses
end
end

def find_locale_from_courses
# If the page is a course or assignment page with no specific student id, every course of that student is checked and if
# the language for all these course are same, the page is displayed in that language
courseParticipants = CourseParticipant.where(user_id: current_user.id)
courseParticipantsLocales = courseParticipants.map { |cp| cp.course.locale }
# If no tasks, then possible to have no courses assigned.
if courseParticipantsLocales.uniq.length == 1 #&& !@tasks.empty?
course = courseParticipants.first.course
if course.locale?
I18n.locale = course.locale
else
I18n.locale = I18n.default_locale
end
else
I18n.locale = I18n.default_locale
end
end
</pre>

<li>If the student user has not set a language preference and is not on a course-specific page, then the page is displayed in English.
If a language preference is obtained by following the above conditions but some keys in the page don't have a translation for the language, the English translation for that key is returned as a fallback.</li>

'''''2. Rendering the language''''' 
Once we have determined the language in which to render the page, we now need to update the rails view code to actually generate the appropriate HTML in the target language. This is the responsibility of the view. However, currently, the actual content of the HTML is hardcoded in (red) English. For example: 
<pre><h2>Summary Report for assignment: <%= @assignment.name %></h2>
<h4>Team: <%= @team.name %></h4></pre>
 
As discussed earlier, “Views are composed of independent language elements” and so we cannot simply swap out the entire page content for a separate page in another language (Why? - See “swap out the entire view” in the alternative approaches section): 
<pre><h2>Rapport de synthèse pour l'affectation: <%= @assignment.name %></h2>
<h4>Équipe: <%= @team.name %></h4></pre>

 Instead, the better approach is to have a single unified view that dynamically changes based on the selected language: <pre><h2><%=language==’en’ ? ‘Summary Report for assignment’ : ‘Rapport de synthèse pour l'affectation’>: <%= @assignment.name %></h2>
<h4><%=language==’en’ ? ‘Team’ : ‘Équipe’>: <%= @team.name %></h4></pre>

 However this is clearly infeasible considering the number of call sites where we have to apply this logic. Thus, in order to maximize how concise the call site is, we can pull out this logic into a common helper function: <pre><h2><%=localized(“report_summary.page_header”)>: <%= @assignment.name %></h2>
<h4><%=localized(“report_summary.team_label”)>: <%= @team.name %></h4></pre>
 Here the assumption is that the localized(“key”) is aware of the currently selected language and that “report_summary.page_header” is the key for the header which is available in English and Hindi. The helper intelligently selects and returns the right text based on the currently selected language. Through this approach, we are able to render the view in multiple possible languages without any significant increase in the verbosity of the view.

What’s more, is that the above problem is a common problem for user-facing applications and a standard library for doing the above and much more already exists for rails applications called i18n
 

'''''I18n - Internationalisation, How are we using I18n in Ruby on Rail''''' 
I18n is a ruby library/gem which helps us render the static string on the view dynamically. Dynamicity means that based on a local decision of choosing the current language of the view, the library returns the strings of that particular language at runtime. 

 
These strings, instead of hardcoding in the view.rb, are provided in external .yml files. Now at the View level, we can pass an id to the 't' function and the I18n library returns the string for that id of the current set language(called as locale). 
[[File:i18n.png]] 
For this purpose, we have to provide .yml files for each language and in those language-specific .yml, we have to provide a map of key-value pairs where the key is the id of the string and value is the string in that particular language. By default the language or locale is set to be English(:en).
 
THE GREATEST BENEFITS of using this library are - 
*The strings aren't hardcoded in the code/build. The strings are being fetched from external files which can be easily modified. For example, if one needs to change the text from 'Please Help' to 'Help', then one just needs to make a change in the .yml file and the change would reflect on the browser. For this change, we didn't need to redeploy the server. We just Decoupled the view when and where from what content is to be shown.
*Adding more languages is now super easy. Adding support for another language is just one line change in the config and adding a .yml file (having all the key-value pairs for the strings) for the new language. By doing this we can extend the language support as much as we want.
 
'''''3. Translation gaps'''''
 Also, if the language is set to be Hindi or any other language but the key-value pair is not set for that particular string then, automatically the library returns the default which is the English text. <pre>config.i18n.fallbacks = [:en]</pre>

== Alternate approaches ==

'''1. Why not simply swap out the entire view for another language instead of each text?''' 
A view is an organized collection of multiple separate elements, views often involve dynamic generation and some level of sophistication. If we were to swap out one page in its entirety for another page this would often violate the '''DRY''' principle since we would have to have two separate implementations of the view in each language. Thus in the worst case, you have a complex view that has to be replicated dozens of times in various languages.
The majority of complexity of the page is not in the content itself but rather the code that executes to generate that content, thus it makes sense to instead maintain a single view and embed the language switching logic at each location where translation needs to occur to avoid replication of everything around it.

'''2. Why did we pick i18n over implementing it ourselves?''' 
Doing it ourselves felt like a great option. But i18n not just selects a language string at runtime for us it does a lot more under the hood which makes our lives easier. For example, it manages locale over the session for us, even if we change the urls and shift tabs and other stuff it manages our locale. 
Also there is a great principle that says - “ If it isn’t broken, Don’t fix it”. The library manages the registering of different language yml files, points to the right right text at runtime, manages session locale and a lot more. So we want to explore this library instead of reimplementing the same thing again. 

'''3, Why did we store the default language choices in database instead of in session?''' 
We had to decide on whether to keep the student’s language preference in the database or in the session. We have thought about both approaches and below listed are the advantages and disadvantages.

In the work done by the previous team, they added a dropdown in the navbar where a student can choose the preferred language. One of the changes that we did was to move this field to the user profile page. The earlier team used session storage to store the preferred language. This session resets on every logout, but since the preferred language can easily be set from any page this wasn't much of an issue.

<li>Storing user language preference in database.</li>

If we are moving the language preference field to the user profile page, it will create some user experience issues if the preference is stored in session. The student will have to visit the user profile page every time they log in. To avoid this scenario, it’s better to keep the language preference in the database, so that the preference stays saved across sessions.
The disadvantage of moving the language preference to the database is that it brings forth a schema change and this always requires a very careful going through to ensure that nothing else is affected.

<li>Storing language preference in session storage.</li>

The main advantage of storing the language preference in session storage is that no schema change is involved. This decreases the chance of other features being affected. The main disadvantage is that the student will have to go to the user profile page every time they log in to set the preference, causing a user experience issue. Keep in mind that we’re moving the field away from the navbar to a user profile page.

After considering these points, we finally decided to go store the user preference in the database itself as the project requires us to add a language preference field in user profile page.

== Use Case Diagram ==
<li>An instructor can add a default language to any course. English is the default choice.</li>

<li>The user has an option to change their preferred language at any time. They have the option to do so in their profile page. </li>

<li>All pages including the course-related and non-course-related pages are displayed in the user preferred language for any user other than student</li>

<li>Every non-course-related page is displayed in the student’s preferred language. Keys for which a translation is not found are displayed in the default language that is English</li>

<li>Every course-related page is displayed in the student’s preferred language. If the student doesn’t have a preferred language, the course is displayed in the course’s preferred language. Keys for which a translation is not found are displayed in the default language that is English.</li>

[[File:usecasediagram.png|2000px|865px]]

== Major design patterns and principles used ==

'''1. DRY: The i18n ‘t’ function''' 
We observe an extreme case of DRY with the t function of i18n.
For some background, the t function of the library takes in a key representing a text and returns the content referred to by that key in the preferred language of the user. It also performs many other functions such as falling back to a backup language if the translation for the preferred language has not been configured for that specific key. Thus since this logic has to be applied at every element of the view, it would behove us to extract this logic into a reusable function which is what the designers of the i18n library have employed

'''2. Chain of responsibility''' 
[[File:Chainofresp.png]] 

The I18n library gives us an option to have many fall back options. When the required text for a given language is not found, we then move on to find the text for the next language in the chain and so on until we find it. And in the end we will put english as default language. So if the key value pair for the text is not found in none of the yml files then the text will be fetched from the English language yml file.
 

'''3. Open closed principle & Strategy Pattern''' 
As discussed in the “Language selection" design proposal above, if the user has not selected a preferred language, we do not simply default the view to render in the application language (English). Instead, the project requirements state that for course specific screens such as the assignment view, we would need to render the view in the course’s language.
While we could implement this code into the application controller that checks the controller being access and accordingly applies overrides on the default language, this violates the open closed principle since we would need to extend this logic any time we introduce a new course specific screen. Instead a better approach is to delegate the decision of selecting the language to the view itself since the view would be most aware of whether the view is course specific or not. We can also preserve the DRYness through mix-ins.

== Database Design ==
We add the locale field to the users and courses tables which has the default values 0 and 1, which is no preference and en_US respectively.

The migrations will look as follows:

<pre>
class AddLangLocaleToUsers < ActiveRecord::Migration
def change
add_column :users, :locale, :integer, default: 0
end
end
</pre>

<pre>
class AddLocaleToCourses < ActiveRecord::Migration
def change
add_column :courses, :locale, :integer, default: 1
end
end
</pre>

== Database Modification ==
We add a new integer field to the users table to store the user preferred language. The integer will be hashed to the supported languages. The default value in the table will be 0, which will be no_pref.

<pre>
enum locale: {
no_pref: 0,
en_US: 1,
hi_IN: 2
}
</pre>

We also add a new integer field to the courses table to store the course preferred language. The integer will be hashed to the supported languages. The default value in the table will be 1, which will be en_US.

<pre>
enum locale: {
en_US: 1,
hi_IN: 2
}
</pre>

Hence the updated courses table will look like following:

<pre>
create_table "courses", force: :cascade do |t|
t.string "name", limit: 255
t.integer "instructor_id", limit: 4
t.string "directory_path", limit: 255
t.text "info", limit: 65535
t.datetime "created_at"
t.datetime "updated_at"
t.boolean "private", default: false, null: false
t.integer "institutions_id", limit: 4
t.integer "locale", limit: 4, default: 1
end
</pre>

While the updated users table will look like the following:

<pre>
create_table "users", force: :cascade do |t|
t.string "name", limit: 255, default: "", null: false
t.string "crypted_password", limit: 40, default: "", null: false
t.integer "role_id", limit: 4, default: 0, null: false
t.string "password_salt", limit: 255
t.string "fullname", limit: 255
t.string "email", limit: 255
t.integer "parent_id", limit: 4
t.boolean "private_by_default", default: false
t.string "mru_directory_path", limit: 128
t.boolean "email_on_review"
t.boolean "email_on_submission"
t.boolean "email_on_review_of_review"
t.boolean "is_new_user", default: true, null: false
t.integer "master_permission_granted", limit: 1, default: 0
t.string "handle", limit: 255
t.text "digital_certificate", limit: 16777215
t.string "persistence_token", limit: 255
t.string "timezonepref", limit: 255
t.text "public_key", limit: 16777215
t.boolean "copy_of_emails", default: false
t.integer "institution_id", limit: 4
t.boolean "preference_home_flag", default: true
t.integer "locale", limit: 4, default: 0
end
</pre>

The locale field is the last column on both tables:
<pre>
courses:> t.integer "locale", limit: 4, default: 1
</pre>
<pre>
users:> t.integer "locale", limit: 4, default: 0
</pre>

== Test Plan ==

===Manual Testing===

Through manual testing, we aim to identify if all the features of the application are working as intended when the language conversion occurs.

Scenario 1

1. Log in to Expertiza as a student.

2. Go to the “user profile” page and change “preferred language” to Hindi.

3. Check to see if the English strings on the profile page are translated to Hindi.

4. Check if a page for which Hindi translation keys are added has its English static strings translated to Hindi.

Scenario 2

1. Log in to Expertiza as a student.

2. Go to the “user profile” page and change “preferred language” to Nil.

3. Check to see if the English strings on the page are unchanged, as the “user profile” translates only if the student has a preference.

4. Go to an assignment page for which Hindi translation keys are added, which is under a course with the default language set to Hindi, and check whether the English strings are translated to Hindi.

Scenario 3

1. Log in to Expertiza as a student.

2. Go to the “user profile” page and change “preferred language” to Nil.

3. Check to see if the English strings on the page are unchanged, as the “user profile” translates only if the student has a preference.

4. Go to a non-course-specific page and verify that the page is displayed in English itself, as non of the default languages set for any of the courses should have any role.

Scenario 4

1. Log in to Expertiza as a student.

2. Go to the “user profile” page and change “preferred language” to Hindi.

3. Go to a page where translation keys aren’t added completely and make sure that the unspecified keys display strings in English as a fallback.

== Future Scope==
'''1. Expand to more languages''' 
As part of this project we have targetted Hindi as a second language, however our work makes it easy to extend to other languages as well.

'''2. Identify and implement the course language override on more course specific screens''' 
As part of this project, we have introduced a generic framework by which any view can provide a preferred language in which it should be rendered, this is required by this project for the course language feature set by the instructor.
We have currently made the assignment screen display in the course’s language, however other screens such as the “Your work” screen and so on are also specific to the course could also be rendered in the course language when the user has not provided a preference.

== Team ==

'''Team Members'''

Reuben M. V. John [[mailto:rmjohn2@ncsu.edu rmjohn2@ncsu.edu]] 
Renji Joseph Sabu [[mailto:rsabu@ncsu.edu rsabu@ncsu.edu]] 
Ashwin Das [[mailto:adas9@ncsu.edu adas9@ncsu.edu]] 
Arnav Julka [[mailto:ajulka@ncsu.edu ajulka@ncsu.edu]] 

'''Mentor'''

Jialin Cui [[mailto:jcui9@ncsu.edu jcui9@ncsu.edu]]

CSC/ECE 517 Fall 2021 - E2159. Expertiza internationalization

2021-11-30T01:31:57Z

Adas9: /* Database Design */

== Introduction - Purpose & Problem ==

Currently, all Expertiza screens can only be viewed in English. Many Expertiza users are from other countries. This is a problem since this limits the accessibility of Expertiza. An important step in solving this problem is by making Expertiza available in more languages, which is a form of internationalization.
W3C defines [https://www.w3.org/International/questions/qa-i18n internationalization] as “''the design and development of a product, application or document content that enables easy localization for target audiences that vary in culture, region, or language.''”

[[File:country_pie.png|none|500px|]] 
Survey of home country of Expertiza users for a given course 

'''Scope:''' The scope of this project is limited however only to static strings. i.e. user-generated content will not be automatically translated to other languages.

'''Breaking down internationalization into 3 sequential subproblems:''' 
[[File:Twophase2.jpg|none|700px]] 
'''1. Language selection''' 
Every user has an option to set a language preference in the User Profile Information Edit page.

[[File:ProfileEditPage.png]] 
There is also an option where the instructor can choose a default language for a course.

[[File:language2inter.png]]

Thus, the language not only varies from user to user but also across screens for the same user. Thus we need to recompute the language in which the page is to be rendered. If the student has given a language preference, then the choice is given weightage over the course default language chosen by the instructor.

'''2. Rendering the language''' 
'''How do we go about rendering the screen in that language?''' 
In the previous step, we’ve identified the language in which a view is to be rendered. It is important to note that this language may not only differ for a different user, but also for a different page for the same user. The question now becomes, how do we render the screen in this language? 
To tackle this question, we explore 2 fundamental concepts: 
'''2.1 Views are composed of independent language elements''' 
While this is something we typically take for granted, it becomes especially important in the context of translation. That is, a view is not a single contiguous block of text, nor is it an atomic visualization of information (unlike a screenshot), but rather a carefully organized collection of individual elements such as texts, buttons, etc that each contain language that needs to be translated separately. Crucially, this means that we cannot swap out a page in one language in its entirety for a page in another language in its entirety. Instead, each individual element needs to be swapped out individually so as to only impact the language and not the structural composition of the page itself.
 
'''2.2 Views require translation at a large number of call sites''' 
Given that a view is composed of individual elements, this also means that the computation of how to translate such an element such as a button’s text would need to be done separately for each element. This would result in not only a single centralized

'''3. Translation gaps'''

What if the translation for the target language is not available?
Even translation for a language like Hindi may be available in general, the translation for a given text may not be available Hindi. This may be due to a variety of reasons:
<ul>
<li>
The specific text may have been accidentally missed out (remember the translation is not being done at runtime through an API, but rather curated by the developer)
</li>
<li>
The given text is non-trivial to translate to the target language
</li>
</ul>
Our design would thus need to accommodate this by seamlessly falling back on another language whose translation is available.

== Scope ==
The scope of this project is limited however only to static strings. I.e. user-generated content will not be automatically translated to other languages.

== Design ==
'''Proposed Solution''' 
We explore and solve each of the three problems above in isolation:

'''''1. Language selection''''' 
The language in which the page is rendered depends on a set of conditions.

<li>If the user has set a language preference all pages are displayed in that language.</li>

<li>If the user has not set a language preference and the user is an instructor, all the pages are displayed in English.</li>

<li>If the user has not set a language preference and the user is a student who is on a page that is specific to a course for which the instructor has added a default language, the page is displayed in the course’s default language.</li>

The below functions are added and called before page rendering to bring in this logic.
<pre>
before_action :set_locale

def set_locale
# Checks whether the user is logged in, else the default locale is used
if logged_in?
# If the current user has set his preferred language, the locale is set according to their preference
if @current_user.locale != "no_pref"
I18n.locale = @current_user.locale
# If the user doesn't have any preference, the locale is taken from the course locale, if the current page is a course specific page or else default locale is used
elsif current_user_role? && current_user_role.student? && ["student_task", "sign_up_sheet", "student_teams", "student_review", "grades", "submitted_content", "participants"].include?(params[:controller])
set_new_locale_for_student
else
I18n.locale = I18n.default_locale
end
else
I18n.locale = I18n.default_locale
end
end

def set_new_locale_for_student
# Gets participant using student from params
if !params[:id].nil? || !params[:student_id].nil?
participant_id = params[:id] || params[:student_id]
participant = AssignmentParticipant.find_by(id: participant_id)
# If id or student_id not correct, revert to locale based on courses.
if participant.nil?
find_locale_from_courses
return
end
# Find assignment from participant and find locale from the assigment
assignment = participant.assignment
if !assignment.course.nil?
new_locale = assignment.course.locale
if !new_locale.nil?
I18n.locale = new_locale
else
I18n.locale = I18n.default_locale
end
else
I18n.locale = I18n.default_locale
end
else
find_locale_from_courses
end
end

def find_locale_from_courses
# If the page is a course or assignment page with no specific student id, every course of that student is checked and if
# the language for all these course are same, the page is displayed in that language
courseParticipants = CourseParticipant.where(user_id: current_user.id)
courseParticipantsLocales = courseParticipants.map { |cp| cp.course.locale }
# If no tasks, then possible to have no courses assigned.
if courseParticipantsLocales.uniq.length == 1 #&& !@tasks.empty?
course = courseParticipants.first.course
if course.locale?
I18n.locale = course.locale
else
I18n.locale = I18n.default_locale
end
else
I18n.locale = I18n.default_locale
end
end
</pre>

<li>If the student user has not set a language preference and is not on a course-specific page, then the page is displayed in English.
If a language preference is obtained by following the above conditions but some keys in the page don't have a translation for the language, the English translation for that key is returned as a fallback.</li>

'''''2. Rendering the language''''' 
Once we have determined the language in which to render the page, we now need to update the rails view code to actually generate the appropriate HTML in the target language. This is the responsibility of the view. However, currently, the actual content of the HTML is hardcoded in (red) English. For example: 
<pre><h2>Summary Report for assignment: <%= @assignment.name %></h2>
<h4>Team: <%= @team.name %></h4></pre>
 
As discussed earlier, “Views are composed of independent language elements” and so we cannot simply swap out the entire page content for a separate page in another language (Why? - See “swap out the entire view” in the alternative approaches section): 
<pre><h2>Rapport de synthèse pour l'affectation: <%= @assignment.name %></h2>
<h4>Équipe: <%= @team.name %></h4></pre>

 Instead, the better approach is to have a single unified view that dynamically changes based on the selected language: <pre><h2><%=language==’en’ ? ‘Summary Report for assignment’ : ‘Rapport de synthèse pour l'affectation’>: <%= @assignment.name %></h2>
<h4><%=language==’en’ ? ‘Team’ : ‘Équipe’>: <%= @team.name %></h4></pre>

 However this is clearly infeasible considering the number of call sites where we have to apply this logic. Thus, in order to maximize how concise the call site is, we can pull out this logic into a common helper function: <pre><h2><%=localized(“report_summary.page_header”)>: <%= @assignment.name %></h2>
<h4><%=localized(“report_summary.team_label”)>: <%= @team.name %></h4></pre>
 Here the assumption is that the localized(“key”) is aware of the currently selected language and that “report_summary.page_header” is the key for the header which is available in English and Hindi. The helper intelligently selects and returns the right text based on the currently selected language. Through this approach, we are able to render the view in multiple possible languages without any significant increase in the verbosity of the view.

What’s more, is that the above problem is a common problem for user-facing applications and a standard library for doing the above and much more already exists for rails applications called i18n
 

'''''I18n - Internationalisation, How are we using I18n in Ruby on Rail''''' 
I18n is a ruby library/gem which helps us render the static string on the view dynamically. Dynamicity means that based on a local decision of choosing the current language of the view, the library returns the strings of that particular language at runtime. 

 
These strings, instead of hardcoding in the view.rb, are provided in external .yml files. Now at the View level, we can pass an id to the 't' function and the I18n library returns the string for that id of the current set language(called as locale). 
[[File:i18n.png]] 
For this purpose, we have to provide .yml files for each language and in those language-specific .yml, we have to provide a map of key-value pairs where the key is the id of the string and value is the string in that particular language. By default the language or locale is set to be English(:en).
 
THE GREATEST BENEFITS of using this library are - 
*The strings aren't hardcoded in the code/build. The strings are being fetched from external files which can be easily modified. For example, if one needs to change the text from 'Please Help' to 'Help', then one just needs to make a change in the .yml file and the change would reflect on the browser. For this change, we didn't need to redeploy the server. We just Decoupled the view when and where from what content is to be shown.
*Adding more languages is now super easy. Adding support for another language is just one line change in the config and adding a .yml file (having all the key-value pairs for the strings) for the new language. By doing this we can extend the language support as much as we want.
 
'''''3. Translation gaps'''''
 Also, if the language is set to be Hindi or any other language but the key-value pair is not set for that particular string then, automatically the library returns the default which is the English text. <pre>config.i18n.fallbacks = [:en]</pre>

== Alternate approaches ==

'''1. Why not simply swap out the entire view for another language instead of each text?''' 
A view is an organized collection of multiple separate elements, views often involve dynamic generation and some level of sophistication. If we were to swap out one page in its entirety for another page this would often violate the '''DRY''' principle since we would have to have two separate implementations of the view in each language. Thus in the worst case, you have a complex view that has to be replicated dozens of times in various languages.
The majority of complexity of the page is not in the content itself but rather the code that executes to generate that content, thus it makes sense to instead maintain a single view and embed the language switching logic at each location where translation needs to occur to avoid replication of everything around it.

'''2. Why did we pick i18n over implementing it ourselves?''' 
Doing it ourselves felt like a great option. But i18n not just selects a language string at runtime for us it does a lot more under the hood which makes our lives easier. For example, it manages locale over the session for us, even if we change the urls and shift tabs and other stuff it manages our locale. 
Also there is a great principle that says - “ If it isn’t broken, Don’t fix it”. The library manages the registering of different language yml files, points to the right right text at runtime, manages session locale and a lot more. So we want to explore this library instead of reimplementing the same thing again. 

'''3, Do we store the language preference, in the session or in the database?''' 
We are still deciding on whether to keep the student’s language preference in the database or in the session. We have thought about both approaches and below listed are the advantages and disadvantages.

In the work done by the previous team, they added a dropdown in the navbar where a student can choose the preferred language. One of the changes that we intend to do is move this field to the user profile page. The earlier team used session storage to store the preferred language. This session resets on every logout, but since the preferred language can easily be set from any page this won’t be much of an issue.

<li>Storing language preference in database.</li>

If we are moving the language preference field to the user profile page, it will create some user experience issues if the preference is stored in session. The student will have to visit the user profile page every time they log in. To avoid this scenario, it’s better to keep the language preference in the database, so that the preference stays saved across sessions.
The disadvantage of moving the language preference to the database is that it brings forth a schema change and this always requires a very careful going through to ensure that nothing else is affected.

<li>Storing language preference in session storage.</li>

The main advantage of storing the language preference in session storage is that no schema change is involved. This decreases the chance of other features being affected. The main disadvantage is that the student will have to go to the user profile page every time they log in to set the preference, causing a user experience issue. Keep in mind that we’re moving the field away from the navbar to a user profile page.

== Use Case Diagram ==
<li>An instructor can add a default language to any course. English is the default choice.</li>

<li>The student has an option to change their preferred language at any time. They have the option to do so in their profile page. </li>

<li>Every non-course-related page is displayed in the student’s preferred language. Keys for which a translation is not found are displayed in the default language that is English.</li>

<li>Every course-related page is displayed in the student’s preferred language. If the student doesn’t have a preferred language, the course is displayed in the course’s preferred language. Keys for which a translation is not found are displayed in the default language that is English.</li>

[[File:usecasediagram.png|2000px|865px]]

== Major design patterns and principles used ==

'''1. DRY: The i18n ‘t’ function''' 
We observe an extreme case of DRY with the t function of i18n.
For some background, the t function of the library takes in a key representing a text and returns the content referred to by that key in the preferred language of the user. It also performs many other functions such as falling back to a backup language if the translation for the preferred language has not been configured for that specific key. Thus since this logic has to be applied at every element of the view, it would behove us to extract this logic into a reusable function which is what the designers of the i18n library have employed

'''2. Chain of responsibility''' 
[[File:Chainofresp.png]] 

The I18n library gives us an option to have many fall back options. When the required text for a given language is not found, we then move on to find the text for the next language in the chain and so on until we find it. And in the end we will put english as default language. So if the key value pair for the text is not found in none of the yml files then the text will be fetched from the English language yml file.
 

'''3. Open closed principle & Strategy Pattern''' 
As discussed in the “Language selection" design proposal above, if the user has not selected a preferred language, we do not simply default the view to render in the application language (English). Instead, the project requirements state that for course specific screens such as the assignment view, we would need to render the view in the course’s language.
While we could implement this code into the application controller that checks the controller being access and accordingly applies overrides on the default language, this violates the open closed principle since we would need to extend this logic any time we introduce a new course specific screen. Instead a better approach is to delegate the decision of selecting the language to the view itself since the view would be most aware of whether the view is course specific or not. We can also preserve the DRYness through mix-ins.

== Database Design ==
We add the locale field to the users and courses tables which has the default values 0 and 1, which is no preference and en_US respectively.

The migrations will look as follows:

<pre>
class AddLangLocaleToUsers < ActiveRecord::Migration
def change
add_column :users, :locale, :integer, default: 0
end
end
</pre>

<pre>
class AddLocaleToCourses < ActiveRecord::Migration
def change
add_column :courses, :locale, :integer, default: 1
end
end
</pre>

== Database Modification ==
The only need to update the users table if we are keeping the language preference in the DB.
The current schema of the “users” table is :

<pre>
create_table "users", force: :cascade do |t|
t.string "name", limit: 255, default: "", null: false

t.string "crypted_password", limit: 40, default: "", null: false

t.integer "role_id", limit: 4, default: 0, null: false

t.string "password_salt", limit: 255

t.string "fullname", limit: 255

t.string "email", limit: 255

t.integer "parent_id", limit: 4

t.boolean "private_by_default", default: false

t.string "mru_directory_path", limit: 128

t.boolean "email_on_review"

t.boolean "email_on_submission"

t.boolean "email_on_review_of_review"

t.boolean "is_new_user", default: true, null: false

t.integer "master_permission_granted", limit: 1, default: 0

t.string "handle", limit: 255

t.text "digital_certificate", limit: 16777215

t.string "persistence_token", limit: 255

t.string "timezonepref", limit: 255

t.text "public_key", limit: 16777215

t.boolean "copy_of_emails", default: false

t.integer "institution_id", limit: 4

t.boolean "preference_home_flag", default: true

end
</pre>

Which will change to:

<pre>
create_table "users", force: :cascade do |t|
t.string "name", limit: 255, default: "", null: false

t.string "crypted_password", limit: 40, default: "", null: false

t.integer "role_id", limit: 4, default: 0, null: false

t.string "password_salt", limit: 255

t.string "fullname", limit: 255

t.string "email", limit: 255

t.integer "parent_id", limit: 4

t.boolean "private_by_default", default: false

t.string "mru_directory_path", limit: 128

t.boolean "email_on_review"

t.boolean "email_on_submission"

t.boolean "email_on_review_of_review"

t.boolean "is_new_user", default: true, null: false

t.integer "master_permission_granted", limit: 1, default: 0

t.string "handle", limit: 255

t.text "digital_certificate", limit: 16777215

t.string "persistence_token", limit: 255

t.string "timezonepref", limit: 255

t.text "public_key", limit: 16777215

t.boolean "copy_of_emails", default: false

t.integer "institution_id", limit: 4

t.boolean "preference_home_flag", default: true

t.string “language_preference”, limit: 255

end
</pre>

== Test Plan ==

===Manual Testing===

Through manual testing, we aim to identify if all the features of the application are working as intended when the language conversion occurs.

Scenario 1

1. Log in to Expertiza as a student.

2. Go to the “user profile” page and change “preferred language” to Hindi.

3. Check to see if the English strings on the profile page are translated to Hindi.

4. Check if a page for which Hindi translation keys are added has its English static strings translated to Hindi.

Scenario 2

1. Log in to Expertiza as a student.

2. Go to the “user profile” page and change “preferred language” to Nil.

3. Check to see if the English strings on the page are unchanged, as the “user profile” translates only if the student has a preference.

4. Go to an assignment page for which Hindi translation keys are added, which is under a course with the default language set to Hindi, and check whether the English strings are translated to Hindi.

Scenario 3

1. Log in to Expertiza as a student.

2. Go to the “user profile” page and change “preferred language” to Nil.

3. Check to see if the English strings on the page are unchanged, as the “user profile” translates only if the student has a preference.

4. Go to a non-course-specific page and verify that the page is displayed in English itself, as non of the default languages set for any of the courses should have any role.

Scenario 4

1. Log in to Expertiza as a student.

2. Go to the “user profile” page and change “preferred language” to Hindi.

3. Go to a page where translation keys aren’t added completely and make sure that the unspecified keys display strings in English as a fallback.

== Future Scope==
'''1. Expand to more languages''' 
As part of this project we have targetted Hindi as a second language, however our work makes it easy to extend to other languages as well.

'''2. Identify and implement the course language override on more course specific screens''' 
As part of this project, we have introduced a generic framework by which any view can provide a preferred language in which it should be rendered, this is required by this project for the course language feature set by the instructor.
We have currently made the assignment screen display in the course’s language, however other screens such as the “Your work” screen and so on are also specific to the course could also be rendered in the course language when the user has not provided a preference.

== Team ==

'''Team Members'''

Reuben M. V. John [[mailto:rmjohn2@ncsu.edu rmjohn2@ncsu.edu]] 
Renji Joseph Sabu [[mailto:rsabu@ncsu.edu rsabu@ncsu.edu]] 
Ashwin Das [[mailto:adas9@ncsu.edu adas9@ncsu.edu]] 
Arnav Julka [[mailto:ajulka@ncsu.edu ajulka@ncsu.edu]] 

'''Mentor'''

Jialin Cui [[mailto:jcui9@ncsu.edu jcui9@ncsu.edu]]

CSC/ECE 517 Fall 2021 - E2159. Expertiza internationalization

2021-11-03T21:19:51Z

Adas9: /* Introduction - Purpose & Problem */

== Introduction - Purpose & Problem ==

Currently, all Expertiza screens can only be viewed in English. Many Expertiza users are from other countries. This is a problem since this limits the accessibility of Expertiza. An important step in solving this problem is by making Expertiza available in more languages, which is a form of internationalization.
W3C defines [https://www.w3.org/International/questions/qa-i18n internationalization] as “''the design and development of a product, application or document content that enables easy localization for target audiences that vary in culture, region, or language.''”

[[File:country_pie.png|none|500px|]] 
Survey of home country of Expertiza users for a given course 

'''Scope:''' The scope of this project is limited however only to static strings. i.e. user-generated content will not be automatically translated to other languages.

'''Breaking down internationalization into 3 sequential subproblems:''' 
[[File:Twophase2.jpg|none|700px]] 
'''1. Language selection''' 
Internationalization is done for pages viewed by students only. Any user other than students views all pages in English. The student has the option to set a language preference.

LOFI UI sketch

[[File:language1inter.png]] 
There is also an option where the instructor can choose a default language for a course.

[[File:language2inter.png]]

Thus, the language not only varies from user to user but also across screens for the same user. Thus we need to recompute the language in which the page is to be rendered. If the student has given a language preference, then the choice is given weightage over the default language chosen by the instructor.

'''2. Rendering the language''' 
'''How do we go about rendering the screen in that language?''' 
In the previous step, we’ve identified the language in which a view is to be rendered. It is important to note that this language may not only differ for a different user, but also for a different page for the same user. The question now becomes, how do we render the screen in this language? 
To tackle this question, we explore 2 fundamental concepts: 
'''2.1 Views are composed of independent language elements''' 
While this is something we typically take for granted, it becomes especially important in the context of translation. That is, a view is not a single contiguous block of text, nor is it an atomic visualization of information (unlike a screenshot), but rather a carefully organized collection of individual elements such as texts, buttons, etc that each contain language that needs to be translated separately. Crucially, this means that we cannot swap out a page in one language in its entirety for a page in another language in its entirety. Instead, each individual element needs to be swapped out individually so as to only impact the language and not the structural composition of the page itself.
 
'''2.2 Views require translation at a large number of call sites''' 
Given that a view is composed of individual elements, this also means that the computation of how to translate such an element such as a button’s text would need to be done separately for each element. This would result in not only a single centralized

'''3. Translation gaps'''

What if the translation for the target language is not available?
Even translation for a language like Hindi may be available in general, the translation for a given text may not be available Hindi. This may be due to a variety of reasons:
The specific text may have been accidentally missed out (remember the translation is not being done at runtime through an API, but rather curated by the developer)
The given text is non-trivial to translate to the target language
Our design would thus need to accommodate this by seamlessly falling back on another language whose translation is available.

== Scope ==
The scope of this project is limited however only to static strings. I.e. user-generated content will not be automatically translated to other languages.

== Design ==
'''Proposed Solution''' 
We explore and solve each of the three problems above in isolation:

'''''1. Language selection''''' 
The language in which the page is rendered depends on a set of conditions.

<li>If the student has set a language preference, it overrides the default language setting saved by the instructor, and all pages are displayed in the language preferred by the student.</li>

<li>If the student has not set a language preference and is on a page that is specific to a course for which the instructor has added a default language, the page is displayed in the course’s default language.</li>

<li>If the student has not set a language preference and is not on a course-specific page, then the page is displayed in English.
If a language preference is obtained by following the above conditions but some keys in the page don't have a translation for the language, the English translation for that key is returned as a fallback.</li>

'''''2. Rendering the language''''' 
Once we have determined the language in which to render the page, we now need to update the rails view code to actually generate the appropriate HTML in the target language. This is the responsibility of the view. However, currently, the actual content of the HTML is hardcoded in (red) English. For example: 
<pre><h2>Summary Report for assignment: <%= @assignment.name %></h2>
<h4>Team: <%= @team.name %></h4></pre>
 
As discussed earlier, “Views are composed of independent language elements” and so we cannot simply swap out the entire page content for a separate page in another language (Why? - See “swap out the entire view” in the alternative approaches section): 
<pre><h2>Rapport de synthèse pour l'affectation: <%= @assignment.name %></h2>
<h4>Équipe: <%= @team.name %></h4></pre>

 Instead, the better approach is to have a single unified view that dynamically changes based on the selected language: <pre><h2><%=language==’en’ ? ‘Summary Report for assignment’ : ‘Rapport de synthèse pour l'affectation’>: <%= @assignment.name %></h2>
<h4><%=language==’en’ ? ‘Team’ : ‘Équipe’>: <%= @team.name %></h4></pre>

 However this is clearly infeasible considering the number of call sites where we have to apply this logic. Thus, in order to maximize how concise the call site is, we can pull out this logic into a common helper function: <pre><h2><%=localized(“report_summary.page_header”)>: <%= @assignment.name %></h2>
<h4><%=localized(“report_summary.team_label”)>: <%= @team.name %></h4></pre>
 Here the assumption is that the localized(“key”) is aware of the currently selected language and that “report_summary.page_header” is the key for the header which is available in English and Hindi. The helper intelligently selects and returns the right text based on the currently selected language. Through this approach, we are able to render the view in multiple possible languages without any significant increase in the verbosity of the view.

What’s more, is that the above problem is a common problem for user-facing applications and a standard library for doing the above and much more already exists for rails applications called i18n
 

'''''I18n - Internationalisation, How are we using I18n in Ruby on Rail''''' 
I18n is a ruby library/gem which helps us render the static string on the view dynamically. Dynamicity means that based on a local decision of choosing the current language of the view, the library returns the strings of that particular language at runtime. 

 
These strings, instead of hardcoding in the view.rb, are provided in external .yml files. Now at the View level, we can pass an id to the 't' function and the I18n library returns the string for that id of the current set language(called as locale). 
[[File:i18n.png]] 
For this purpose, we have to provide .yml files for each language and in those language-specific .yml, we have to provide a map of key-value pairs where the key is the id of the string and value is the string in that particular language. By default the language or locale is set to be English(:en).
 
THE GREATEST BENEFITS of using this library are - 
*The strings aren't hardcoded in the code/build. The strings are being fetched from external files which can be easily modified. For example, if one needs to change the text from 'Please Help' to 'Help', then one just needs to make a change in the .yml file and the change would reflect on the browser. For this change, we didn't need to redeploy the server. We just Decoupled the view when and where from what content is to be shown.
*Adding more languages is now super easy. Adding support for another language is just one line change in the config and adding a .yml file (having all the key-value pairs for the strings) for the new language. By doing this we can extend the language support as much as we want.
 
'''''3. Translation gaps'''''
 Also, if the language is set to be Hindi or any other language but the key-value pair is not set for that particular string then, automatically the library returns the default which is the English text. <pre>config.i18n.fallbacks = [:en]</pre>

== Alternate approaches ==

'''1. Why not simply swap out the entire view for another language instead of each text?''' 
A view is an organized collection of multiple separate elements, views often involve dynamic generation and some level of sophistication. If we were to swap out one page in its entirety for another page this would often violate the '''DRY''' principle since we would have to have two separate implementations of the view in each language. Thus in the worst case, you have a complex view that has to be replicated dozens of times in various languages.
The majority of complexity of the page is not in the content itself but rather the code that executes to generate that content, thus it makes sense to instead maintain a single view and embed the language switching logic at each location where translation needs to occur to avoid replication of everything around it.

'''2. Why did we pick i18n over implementing it ourselves?''' 
@ajulka

'''3, Do we store the language preference, in the session or in the database?''' 
We are still deciding on whether to keep the student’s language preference in the database or in the session. We have thought about both approaches and below listed are the advantages and disadvantages.

In the work done by the previous team, they added a dropdown in the navbar where a student can choose the preferred language. One of the changes that we intend to do is move this field to the user profile page. The earlier team used session storage to store the preferred language. This session resets on every logout, but since the preferred language can easily be set from any page this won’t be much of an issue.

<li>Storing language preference in database.</li>

If we are moving the language preference field to the user profile page, it will create some user experience issues if the preference is stored in session. The student will have to visit the user profile page every time they log in. To avoid this scenario, it’s better to keep the language preference in the database, so that the preference stays saved across sessions.
The disadvantage of moving the language preference to the database is that it brings forth a schema change and this always requires a very careful going through to ensure that nothing else is affected.

<li>Storing language preference in session storage.</li>

The main advantage of storing the language preference in session storage is that no schema change is involved. This decreases the chance of other features being affected. The main disadvantage is that the student will have to go to the user profile page every time they log in to set the preference, causing a user experience issue. Keep in mind that we’re moving the field away from the navbar to a user profile page.

== Use Case Diagram ==
<li>An instructor can add a default language to any course. English is the default choice.</li>

<li>The student has an option to change their preferred language at any time. They have the option to do so in their profile page. </li>

<li>Every non-course-related page is displayed in the student’s preferred language. Keys for which a translation is not found are displayed in the default language that is English.</li>

<li>Every course-related page is displayed in the student’s preferred language. If the student doesn’t have a preferred language, the course is displayed in the course’s preferred language. Keys for which a translation is not found are displayed in the default language that is English.</li>

[[File:usecasediagram.png|2000px|865px]]

== Major design patterns and principles used ==

'''1. DRY: The i18n ‘t’ function''' 
We observe an extreme case of DRY with the t function of i18n.
For some background, the t function of the library takes in a key representing a text and returns the content referred to by that key in the preferred language of the user. It also performs many other functions such as falling back to a backup language if the translation for the preferred language has not been configured for that specific key. Thus since this logic has to be applied at every element of the view, it would behove us to extract this logic into a reusable function which is what the designers of the i18n library have employed

'''2. Chain of responsibility''' 
[[File:Chainofresp.png]] 

The I18n library gives us an option to have many fall back options. When the required text for a given language is not found, we then move on to find the text for the next language in the chain and so on until we find it. And in the end we will put english as default language. So if the key value pair for the text is not found in none of the yml files then the text will be fetched from the English language yml file.
 

'''3. Open closed principle & Strategy Pattern''' 
As discussed in the “Language selection" design proposal above, if the user has not selected a preferred language, we do not simply default the view to render in the application language (English). Instead, the project requirements state that for course specific screens such as the assignment view, we would need to render the view in the course’s language.
While we could implement this code into the application controller that checks the controller being access and accordingly applies overrides on the default language, this violates the open closed principle since we would need to extend this logic any time we introduce a new course specific screen. Instead a better approach is to delegate the decision of selecting the language to the view itself since the view would be most aware of whether the view is course specific or not. We can also preserve the DRYness through mix-ins.

== Database Design ==
Currently, we are debating between keeping the language preference in the session or in the database. If we are going with the latter, we have to add a column in the users table.

The migration will look as follows:

<pre>rails generate migration add_language_preference_to_users language_preference:string</pre>

<pre>
class AddLanguagePreferenceToUsers < ActiveRecord::Migration[5.0]
def change
add_column :users, :language_preference, :string
end
end
</pre>

== Database Modification ==
The only need to update the users table if we are keeping the language preference in the DB.
The current schema of the “users” table is :

<pre>
create_table "users", force: :cascade do |t|
t.string "name", limit: 255, default: "", null: false

t.string "crypted_password", limit: 40, default: "", null: false

t.integer "role_id", limit: 4, default: 0, null: false

t.string "password_salt", limit: 255

t.string "fullname", limit: 255

t.string "email", limit: 255

t.integer "parent_id", limit: 4

t.boolean "private_by_default", default: false

t.string "mru_directory_path", limit: 128

t.boolean "email_on_review"

t.boolean "email_on_submission"

t.boolean "email_on_review_of_review"

t.boolean "is_new_user", default: true, null: false

t.integer "master_permission_granted", limit: 1, default: 0

t.string "handle", limit: 255

t.text "digital_certificate", limit: 16777215

t.string "persistence_token", limit: 255

t.string "timezonepref", limit: 255

t.text "public_key", limit: 16777215

t.boolean "copy_of_emails", default: false

t.integer "institution_id", limit: 4

t.boolean "preference_home_flag", default: true

end
</pre>

Which will change to:

<pre>
create_table "users", force: :cascade do |t|
t.string "name", limit: 255, default: "", null: false

t.string "crypted_password", limit: 40, default: "", null: false

t.integer "role_id", limit: 4, default: 0, null: false

t.string "password_salt", limit: 255

t.string "fullname", limit: 255

t.string "email", limit: 255

t.integer "parent_id", limit: 4

t.boolean "private_by_default", default: false

t.string "mru_directory_path", limit: 128

t.boolean "email_on_review"

t.boolean "email_on_submission"

t.boolean "email_on_review_of_review"

t.boolean "is_new_user", default: true, null: false

t.integer "master_permission_granted", limit: 1, default: 0

t.string "handle", limit: 255

t.text "digital_certificate", limit: 16777215

t.string "persistence_token", limit: 255

t.string "timezonepref", limit: 255

t.text "public_key", limit: 16777215

t.boolean "copy_of_emails", default: false

t.integer "institution_id", limit: 4

t.boolean "preference_home_flag", default: true

t.string “language_preference”, limit: 255

end
</pre>

== Test Plan ==

===Manual Testing===

Through manual testing, we aim to identify if all the features of the application are working as intended when the language conversion occurs.

Scenario 1

1. Log in to Expertiza as a student.

2. Go to the “user profile” page and change “preferred language” to Hindi.

3. Check to see if the English strings on the profile page are translated to Hindi.

4. Check if a page for which Hindi translation keys are added has its English static strings translated to Hindi.

Scenario 2

1. Log in to Expertiza as a student.

2. Go to the “user profile” page and change “preferred language” to Nil.

3. Check to see if the English strings on the page are unchanged, as the “user profile” translates only if the student has a preference.

4. Go to an assignment page for which Hindi translation keys are added, which is under a course with the default language set to Hindi, and check whether the English strings are translated to Hindi.

Scenario 3

1. Log in to Expertiza as a student.

2. Go to the “user profile” page and change “preferred language” to Nil.

3. Check to see if the English strings on the page are unchanged, as the “user profile” translates only if the student has a preference.

4. Go to a non-course-specific page and verify that the page is displayed in English itself, as non of the default languages set for any of the courses should have any role.

Scenario 4

1. Log in to Expertiza as a student.

2. Go to the “user profile” page and change “preferred language” to Hindi.

3. Go to a page where translation keys aren’t added completely and make sure that the unspecified keys display strings in English as a fallback.

== Future Scope==
'''1. Expand to more languages''' 
As part of this project we have targetted Hindi as a second language, however our work makes it easy to extend to other languages as well.

'''2. Identify and implement the course language override on more course specific screens''' 
As part of this project, we have introduced a generic framework by which any view can provide a preferred language in which it should be rendered, this is required by this project for the course language feature set by the instructor.
We have currently made the assignment screen display in the course’s language, however other screens such as the “Your work” screen and so on are also specific to the course could also be rendered in the course language when the user has not provided a preference.

== Team ==

'''Team Members'''

Reuben M. V. John [[mailto:rmjohn2@ncsu.edu rmjohn2@ncsu.edu]] 
Renji Joseph Sabu [[mailto:rsabu@ncsu.edu rsabu@ncsu.edu]] 
Ashwin Das [[mailto:adas9@ncsu.edu adas9@ncsu.edu]] 
Arnav Julka [[mailto:ajulka@ncsu.edu ajulka@ncsu.edu]] 

'''Mentor'''

Jialin Cui [[mailto:jcui9@ncsu.edu jcui9@ncsu.edu]]

File:Language2inter.png

2021-11-03T21:19:34Z

Adas9:

File:Language1inter.png

2021-11-03T21:18:54Z

Adas9:

CSC/ECE 517 Fall 2021 - E2159. Expertiza internationalization

2021-11-03T03:36:30Z

Adas9: /* Scope */

CSC/ECE 517 Fall 2021 - E2159. Expertiza internationalization

2021-11-03T03:35:29Z

Adas9: /* Design */

CSC/ECE 517 Fall 2021 - E2159. Expertiza internationalization

2021-11-03T03:31:16Z

Adas9: /* Introduction - Purpose & Problem */

CSC/ECE 517 Fall 2021 - E2159. Expertiza internationalization

2021-11-03T03:29:01Z

Adas9: /* Introduction - Purpose & Problem */

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-23T21:53:22Z

Adas9:

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
===Background===
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc). It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the student_quizzes_controller and late_policies_controller. In this Wiki Page, we would be explaining the changes that we have made for the same.
===Motivation===
This project in particular intends that the students collaborate with each other and work on making enhancements to the code base by applying the concepts of Rails, RSpec, DRY code, Test-driven development, etc. This provides an opportunity for students to contribute to an open-source project and learn further about software deployment etc.

student_quizzes_controller needs several comments to explain the methods and the code in general while late_policies_controller has code duplication which could be refactored to make it DRY and follow the Ruby style guide and Rails 4 syntax.
===Issues in student_quizzes_controller===
* Issue 1: finished_quiz method needs a comment describing its purpose (Line 23)
* Issue 2: Update .first to .last (Line 24)
* Issue 3: Check @participant variable name (Line 28)
* Issue 4: Fix method comment for self.take_quiz (Line 34)
* Issue 5: Refactor calculate_score method (Line 53-96 and Line 108)
* Issue 6: record_response needs a method comment (Line 98)
* Issue 7: Fix the English in the message (Line 110)
* Issue 8: Refactor review_questions method (Line 119)

===Issues in late_policies_controller===
* Issue 9: Create public & private late policies
* Issue 10: Fix duplicate code in create and update method.
* Issue 11: create and update method need comments and better identifier naming

== Modifications made to student_quizzes_controller ==
=== Issue 1 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Issue 2 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Issue 3 ===
----
Method: finished_quiz

The code under consideration is the following <pre>@participant = AssignmentTeam.find(@map.reviewee_id).participants.first</pre>

We get the first participant from the list of participants from AssignmentTeam, which is stored in the variable @participant. Therefore no refactor is required for this issue.

=== Issue 4 ===
----
Updated the method comment to better explain its purpose. 
Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Issue 5 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Issue 6 ===
----
Added method comment to record response to describe its purpose. 
Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Issue 7 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Issue 8 ===
----
Update the method comment to better describe review_questions. 
Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

== Modifications made to late_policies_controller ==

=== Issue 9 ===
----
It seems like some other team already fixed this issue, as all late policies are already shown in index.

<pre>
# GET /late_policies
# GET /late_policies.xml
def index
@penalty_policies = LatePolicy.all
respond_to do |format|
format.html # index.html.erb
format.xml { render xml: @penalty_policies }
end
end
</pre>

=== Issue 10 ===
----
We started by exploring the create and update methods in the late_policies_controller. We found an existing bug in the code. In an update, if the new policy name is the name of an existing policy, an error wasn't returned and the call went through, resulting in multiple policies with the same name. We fixed that error. 
[[File:Codebug.png|3000px|948px]] 
After the fix, the error message is shown properly when the new policy name is the name of an existing policy. 
[[File:Bugfix.png|2000px|865px]]

We also moved the duplicate code from update and create to a validator function which validates the policy name and penality points per unit for both create and update. The fix was done in the controller itself because the view already handled duplicate code using the partial form.

Before Refactoring

<pre>
# POST /late_policies
# POST /late_policies.xml
def create
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
if same_policy_name != LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
same_policy_name = true
end
if !invalid_penalty_per_unit && !same_policy_name
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
# if name has changed then only check for this
if params[:late_policy][:policy_name] != @penalty_policy.policy_name
if same_policy_name == LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "The policy could not be updated because a policy with the same name already exists."
end
end
if !same_policy_name && !invalid_penalty_per_unit
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif invalid_penalty_per_unit
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif same_policy_name
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

After Refactoring

<pre>
# validate checks if the entered penalty per unit and policy name is valid
def validate(params, is_update, current_policy_name)
valid = {}
# penalty per unit cannot be greater than max penalty
valid[:invalid_penalty_per_unit] = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if valid[:invalid_penalty_per_unit]
valid[:policy_name_already_exists] = false
# entered policy name cannot be same as an existing one
if (is_update && current_policy_name != params[:late_policy][:policy_name]) || !is_update
if LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
valid[:policy_name_already_exists] = true
end
end
valid
end
# POST /late_policies
# POST /late_policies.xml
def create
valid = validate(params, false, "")
if !valid[:invalid_penalty_per_unit] && !valid[:policy_name_already_exists]
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
valid = validate(params, true, @penalty_policy.policy_name)
if !valid[:policy_name_already_exists] && !valid[:invalid_penalty_per_unit]
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif valid[:invalid_penalty_per_unit]
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif valid[:policy_name_already_exists]
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

=== Issue 11 ===
----

We removed 'same_policy_name' and 'invalid_penalty_per_unit' and used a hash for that functionality. Then we changed the 'same_policy_name' to 'policy_name_already_exists'. We also added comments to the validator function which is called in create and update.

<pre>
# validate checks if the entered penalty per unit and policy name is valid
def validate(params, is_update, current_policy_name)
valid = {}
# penalty per unit cannot be greater than max penalty
valid[:invalid_penalty_per_unit] = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if valid[:invalid_penalty_per_unit]
valid[:policy_name_already_exists] = false
# entered policy name cannot be same as an existing one
if (is_update && current_policy_name != params[:late_policy][:policy_name]) || !is_update
if LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
valid[:policy_name_already_exists] = true
end
end
valid
end
</pre>

==Affected Classes==
Changed existent classes
* controllers/student_quizzes_controller.rb
* controllers/late_policies_controller.rb

==Test Plan==
As this is a refactoring project with mostly adding comments and updating variable names we can check if the code is working by running the existing tests itself.

Test the student quizzes controller with the following command:
<pre>rspec spec/controllers/student_quizzes_controller_spec.rb</pre>
Test the late policies controller with the following command:
<pre>rspec spec/controllers/late_policies_controller_spec.rb</pre>

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T07:42:50Z

Adas9:

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T07:36:28Z

Adas9: /* Issue 10 */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
===Background===
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc). It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the student_quizzes_controller and late_policies_controller. In this Wiki Page, we would be explaining the changes that we have made for the same.
===Motivation===
This project in particular intends that the students collaborate with each other and work on making enhancements to the code base by applying the concepts of Rails, RSpec, DRY code, Test-driven development, etc. This provides an opportunity for students to contribute to an open-source project and learn further about software deployment etc.

student_quizzes_controller needs several comments to explain the methods and the code in general while late_policies_controller has code duplication which could be refactored to make it DRY and follow the Ruby style guide and Rails 4 syntax.
===Issues in student_quizzes_controller===
* Issue 1: finished_quiz method needs a comment describing its purpose (Line 23)
* Issue 2: Update .first to .last (Line 24)
* Issue 3: Check @participant variable name (Line 28)
* Issue 4: Fix method comment for self.take_quiz (Line 34)
* Issue 5: Refactor calculate_score method (Line 53-96 and Line 108)
* Issue 6: record_response needs a method comment (Line 98)
* Issue 7: Fix the English in the message (Line 110)
* Issue 8: Refactor review_questions method (Line 119)

===Issues in late_policies_controller===
* Issue 9: Create public & private late policies
* Issue 10: Fix duplicate code in create and update method.
* Issue 11: create and update method need comments and better identifier naming

== Modifications made to student_quizzes_controller ==
=== Issue 1 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Issue 2 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Issue 3 ===
----
Method: finished_quiz

The code under consideration is the following <pre>@participant = AssignmentTeam.find(@map.reviewee_id).participants.first</pre>

We get the first participant from the list of participants from AssignmentTeam, which is stored in the variable @participant. Therefore no refactor is required for this issue.

=== Issue 4 ===
----
Updated the method comment to better explain its purpose. 
Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Issue 5 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Issue 6 ===
----
Added method comment to record response to describe its purpose. 
Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Issue 7 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Issue 8 ===
----
Update the method comment to better describe review_questions. 
Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

== Modifications made to late_policies_controller ==

=== Issue 9 ===
----
< Add description here >

=== Issue 10 ===
----
We started by exploring the create and update methods in the late_policies_controller. We found an existing bug in the code. In an update, if the new policy name is the name of an existing policy, an error wasn't returned and the call went through, resulting in multiple policies with the same name. We fixed that error. 
[[File:Codebug.png|3000px|948px]] 
After the fix, the error message is shown properly when the new policy name is the name of an existing policy. 
[[File:Bugfix.png|2000px|865px]]

We also moved the duplicate code from update and create to a validator function which validates the policy name and penality points per unit for both create and update. The fix was done in the controller itself because the view already handled duplicate code using the partial form.

Before Refactoring

<pre>
# POST /late_policies
# POST /late_policies.xml
def create
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
if same_policy_name != LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
same_policy_name = true
end
if !invalid_penalty_per_unit && !same_policy_name
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
# if name has changed then only check for this
if params[:late_policy][:policy_name] != @penalty_policy.policy_name
if same_policy_name == LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "The policy could not be updated because a policy with the same name already exists."
end
end
if !same_policy_name && !invalid_penalty_per_unit
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif invalid_penalty_per_unit
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif same_policy_name
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

After Refactoring

<pre>
# validate checks if the entered penalty per unit and policy name is valid
def validate(params, is_update, current_policy_name)
valid = {}
# penalty per unit cannot be greater than max penalty
valid[:invalid_penalty_per_unit] = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if valid[:invalid_penalty_per_unit]
valid[:policy_name_already_exists] = false
# entered policy name cannot be same as an existing one
if (is_update && current_policy_name != params[:late_policy][:policy_name]) || !is_update
if LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
valid[:policy_name_already_exists] = true
end
end
valid
end
# POST /late_policies
# POST /late_policies.xml
def create
valid = validate(params, false, "")
if !valid[:invalid_penalty_per_unit] && !valid[:policy_name_already_exists]
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
valid = validate(params, true, @penalty_policy.policy_name)
if !valid[:policy_name_already_exists] && !valid[:invalid_penalty_per_unit]
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif valid[:invalid_penalty_per_unit]
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif valid[:policy_name_already_exists]
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

=== Issue 11 ===
----

We removed 'same_policy_name' and 'invalid_penalty_per_unit' and used a hash for that functionality. Then we changed the 'same_policy_name' to 'policy_name_already_exists'. We also added comments to the validator function which is called in create and update.

<pre>
# validate checks if the entered penalty per unit and policy name is valid
def validate(params, is_update, current_policy_name)
valid = {}
# penalty per unit cannot be greater than max penalty
valid[:invalid_penalty_per_unit] = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if valid[:invalid_penalty_per_unit]
valid[:policy_name_already_exists] = false
# entered policy name cannot be same as an existing one
if (is_update && current_policy_name != params[:late_policy][:policy_name]) || !is_update
if LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
valid[:policy_name_already_exists] = true
end
end
valid
end
</pre>

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T07:33:53Z

Adas9: /* Issue 10 */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
===Background===
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc). It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the student_quizzes_controller and late_policies_controller. In this Wiki Page, we would be explaining the changes that we have made for the same.
===Motivation===
This project in particular intends that the students collaborate with each other and work on making enhancements to the code base by applying the concepts of Rails, RSpec, DRY code, Test-driven development, etc. This provides an opportunity for students to contribute to an open-source project and learn further about software deployment etc.

student_quizzes_controller needs several comments to explain the methods and the code in general while late_policies_controller has code duplication which could be refactored to make it DRY and follow the Ruby style guide and Rails 4 syntax.
===Issues in student_quizzes_controller===
* Issue 1: finished_quiz method needs a comment describing its purpose (Line 23)
* Issue 2: Update .first to .last (Line 24)
* Issue 3: Check @participant variable name (Line 28)
* Issue 4: Fix method comment for self.take_quiz (Line 34)
* Issue 5: Refactor calculate_score method (Line 53-96 and Line 108)
* Issue 6: record_response needs a method comment (Line 98)
* Issue 7: Fix the English in the message (Line 110)
* Issue 8: Refactor review_questions method (Line 119)

===Issues in late_policies_controller===
* Issue 9: Create public & private late policies
* Issue 10: Fix duplicate code in create and update method.
* Issue 11: create and update method need comments and better identifier naming

== Modifications made to student_quizzes_controller ==
=== Issue 1 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Issue 2 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Issue 3 ===
----
Method: finished_quiz

The code under consideration is the following <pre>@participant = AssignmentTeam.find(@map.reviewee_id).participants.first</pre>

We get the first participant from the list of participants from AssignmentTeam, which is stored in the variable @participant. Therefore no refactor is required for this issue.

=== Issue 4 ===
----
Updated the method comment to better explain its purpose. 
Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Issue 5 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Issue 6 ===
----
Added method comment to record response to describe its purpose. 
Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Issue 7 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Issue 8 ===
----
Update the method comment to better describe review_questions. 
Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

== Modifications made to late_policies_controller ==

=== Issue 9 ===
----
< Add description here >

=== Issue 10 ===
----
We started by exploring the create and update methods in the late_policies_controller. We found out an existing bug in the code. In an update, if the new policy name is the name of an existing policy, an error wasn't returned and the call went through, resulting in multiple policies with the same name. We fixed that error.
[[File:Codebug.png|3000px|948px]]
After the fix, the error message is shown properly when the new policy name is the name of an existing policy.
[[File:Bugfix.png|2000px|865px]]

We also moved the duplicate code from update and create to a validator function which validates the policy name and penality points per unit for both create and update. The fix was done in the controller itself because view already handled duplicate code using the partial form.

Before Refactoring

<pre>
# POST /late_policies
# POST /late_policies.xml
def create
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
if same_policy_name != LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
same_policy_name = true
end
if !invalid_penalty_per_unit && !same_policy_name
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
# if name has changed then only check for this
if params[:late_policy][:policy_name] != @penalty_policy.policy_name
if same_policy_name == LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "The policy could not be updated because a policy with the same name already exists."
end
end
if !same_policy_name && !invalid_penalty_per_unit
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif invalid_penalty_per_unit
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif same_policy_name
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

After Refactoring

<pre>
# validate checks if the entered penalty per unit and policy name is valid
def validate(params, is_update, current_policy_name)
valid = {}
# penalty per unit cannot be greater than max penalty
valid[:invalid_penalty_per_unit] = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if valid[:invalid_penalty_per_unit]
valid[:policy_name_already_exists] = false
# entered policy name cannot be same as an existing one
if (is_update && current_policy_name != params[:late_policy][:policy_name]) || !is_update
if LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
valid[:policy_name_already_exists] = true
end
end
valid
end
# POST /late_policies
# POST /late_policies.xml
def create
valid = validate(params, false, "")
if !valid[:invalid_penalty_per_unit] && !valid[:policy_name_already_exists]
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
valid = validate(params, true, @penalty_policy.policy_name)
if !valid[:policy_name_already_exists] && !valid[:invalid_penalty_per_unit]
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif valid[:invalid_penalty_per_unit]
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif valid[:policy_name_already_exists]
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

=== Issue 11 ===
----

We removed 'same_policy_name' and 'invalid_penalty_per_unit' and used a hash for that functionality. Then we changed the 'same_policy_name' to 'policy_name_already_exists'. We also added comments to the validator function which is called in create and update.

<pre>
# validate checks if the entered penalty per unit and policy name is valid
def validate(params, is_update, current_policy_name)
valid = {}
# penalty per unit cannot be greater than max penalty
valid[:invalid_penalty_per_unit] = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if valid[:invalid_penalty_per_unit]
valid[:policy_name_already_exists] = false
# entered policy name cannot be same as an existing one
if (is_update && current_policy_name != params[:late_policy][:policy_name]) || !is_update
if LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
valid[:policy_name_already_exists] = true
end
end
valid
end
</pre>

File:Bugfix.png

2021-10-21T07:31:42Z

Adas9:

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T07:31:18Z

Adas9: /* Issue 10 */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
===Background===
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc). It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the student_quizzes_controller and late_policies_controller. In this Wiki Page, we would be explaining the changes that we have made for the same.
===Motivation===
This project in particular intends that the students collaborate with each other and work on making enhancements to the code base by applying the concepts of Rails, RSpec, DRY code, Test-driven development, etc. This provides an opportunity for students to contribute to an open-source project and learn further about software deployment etc.

student_quizzes_controller needs several comments to explain the methods and the code in general while late_policies_controller has code duplication which could be refactored to make it DRY and follow the Ruby style guide and Rails 4 syntax.
===Issues in student_quizzes_controller===
* Issue 1: finished_quiz method needs a comment describing its purpose (Line 23)
* Issue 2: Update .first to .last (Line 24)
* Issue 3: Check @participant variable name (Line 28)
* Issue 4: Fix method comment for self.take_quiz (Line 34)
* Issue 5: Refactor calculate_score method (Line 53-96 and Line 108)
* Issue 6: record_response needs a method comment (Line 98)
* Issue 7: Fix the English in the message (Line 110)
* Issue 8: Refactor review_questions method (Line 119)

===Issues in late_policies_controller===
* Issue 9: Create public & private late policies
* Issue 10: Fix duplicate code in create and update method.
* Issue 11: create and update method need comments and better identifier naming

== Modifications made to student_quizzes_controller ==
=== Issue 1 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Issue 2 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Issue 3 ===
----
Method: finished_quiz

The code under consideration is the following <pre>@participant = AssignmentTeam.find(@map.reviewee_id).participants.first</pre>

We get the first participant from the list of participants from AssignmentTeam, which is stored in the variable @participant. Therefore no refactor is required for this issue.

=== Issue 4 ===
----
Updated the method comment to better explain its purpose. 
Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Issue 5 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Issue 6 ===
----
Added method comment to record response to describe its purpose. 
Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Issue 7 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Issue 8 ===
----
Update the method comment to better describe review_questions. 
Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

== Modifications made to late_policies_controller ==

=== Issue 9 ===
----
< Add description here >

=== Issue 10 ===
----
We started by exploring the create and update methods in the late_policies_controller. We found out an existing bug in the code. In an update, if the new policy name is the name of an existing policy, an error wasn't returned and the call went through, resulting in multiple policies with the same name. We fixed that error.
[[File:Codebug.png|3000px|948px]]
After the fix, the error message is shown properly when the new policy name is the name of an existing policy.
[[File:file:///Users/macbookpro/Desktop/Screenshot%202021-10-21%20at%202.24.33%20AM.png]]

We also moved the duplicate code from update and create to a validator function which validates the policy name and penality points per unit for both create and update. The fix was done in the controller itself because view already handled duplicate code using the partial form.

Before Refactoring

<pre>
# POST /late_policies
# POST /late_policies.xml
def create
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
if same_policy_name != LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
same_policy_name = true
end
if !invalid_penalty_per_unit && !same_policy_name
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
# if name has changed then only check for this
if params[:late_policy][:policy_name] != @penalty_policy.policy_name
if same_policy_name == LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "The policy could not be updated because a policy with the same name already exists."
end
end
if !same_policy_name && !invalid_penalty_per_unit
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif invalid_penalty_per_unit
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif same_policy_name
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

After Refactoring

<pre>
# validate checks if the entered penalty per unit and policy name is valid
def validate(params, is_update, current_policy_name)
valid = {}
# penalty per unit cannot be greater than max penalty
valid[:invalid_penalty_per_unit] = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if valid[:invalid_penalty_per_unit]
valid[:policy_name_already_exists] = false
# entered policy name cannot be same as an existing one
if (is_update && current_policy_name != params[:late_policy][:policy_name]) || !is_update
if LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
valid[:policy_name_already_exists] = true
end
end
valid
end
# POST /late_policies
# POST /late_policies.xml
def create
valid = validate(params, false, "")
if !valid[:invalid_penalty_per_unit] && !valid[:policy_name_already_exists]
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
valid = validate(params, true, @penalty_policy.policy_name)
if !valid[:policy_name_already_exists] && !valid[:invalid_penalty_per_unit]
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif valid[:invalid_penalty_per_unit]
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif valid[:policy_name_already_exists]
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

=== Issue 11 ===
----

We removed 'same_policy_name' and 'invalid_penalty_per_unit' and used a hash for that functionality. Then we changed the 'same_policy_name' to 'policy_name_already_exists'. We also added comments to the validator function which is called in create and update.

<pre>
# validate checks if the entered penalty per unit and policy name is valid
def validate(params, is_update, current_policy_name)
valid = {}
# penalty per unit cannot be greater than max penalty
valid[:invalid_penalty_per_unit] = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if valid[:invalid_penalty_per_unit]
valid[:policy_name_already_exists] = false
# entered policy name cannot be same as an existing one
if (is_update && current_policy_name != params[:late_policy][:policy_name]) || !is_update
if LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
valid[:policy_name_already_exists] = true
end
end
valid
end
</pre>

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T07:30:34Z

Adas9: /* Issue 10 */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
===Background===
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc). It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the student_quizzes_controller and late_policies_controller. In this Wiki Page, we would be explaining the changes that we have made for the same.
===Motivation===
This project in particular intends that the students collaborate with each other and work on making enhancements to the code base by applying the concepts of Rails, RSpec, DRY code, Test-driven development, etc. This provides an opportunity for students to contribute to an open-source project and learn further about software deployment etc.

student_quizzes_controller needs several comments to explain the methods and the code in general while late_policies_controller has code duplication which could be refactored to make it DRY and follow the Ruby style guide and Rails 4 syntax.
===Issues in student_quizzes_controller===
* Issue 1: finished_quiz method needs a comment describing its purpose (Line 23)
* Issue 2: Update .first to .last (Line 24)
* Issue 3: Check @participant variable name (Line 28)
* Issue 4: Fix method comment for self.take_quiz (Line 34)
* Issue 5: Refactor calculate_score method (Line 53-96 and Line 108)
* Issue 6: record_response needs a method comment (Line 98)
* Issue 7: Fix the English in the message (Line 110)
* Issue 8: Refactor review_questions method (Line 119)

===Issues in late_policies_controller===
* Issue 9: Create public & private late policies
* Issue 10: Fix duplicate code in create and update method.
* Issue 11: create and update method need comments and better identifier naming

== Modifications made to student_quizzes_controller ==
=== Issue 1 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Issue 2 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Issue 3 ===
----
Method: finished_quiz

The code under consideration is the following <pre>@participant = AssignmentTeam.find(@map.reviewee_id).participants.first</pre>

We get the first participant from the list of participants from AssignmentTeam, which is stored in the variable @participant. Therefore no refactor is required for this issue.

=== Issue 4 ===
----
Updated the method comment to better explain its purpose. 
Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Issue 5 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Issue 6 ===
----
Added method comment to record response to describe its purpose. 
Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Issue 7 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Issue 8 ===
----
Update the method comment to better describe review_questions. 
Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

== Modifications made to late_policies_controller ==

=== Issue 9 ===
----
< Add description here >

=== Issue 10 ===
----
We started by exploring the create and update methods in the late_policies_controller. We found out an existing bug in the code. In an update, if the new policy name is the name of an existing policy, an error wasn't returned and the call went through, resulting in multiple policies with the same name. We fixed that error.
[[File:Codebug.png|3000px|948px]]
After the fix, the error message is shown properly when the new policy name is the name of an existing policy.
[[File:UpdateBug.png]]

We also moved the duplicate code from update and create to a validator function which validates the policy name and penality points per unit for both create and update. The fix was done in the controller itself because view already handled duplicate code using the partial form.

Before Refactoring

<pre>
# POST /late_policies
# POST /late_policies.xml
def create
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
if same_policy_name != LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
same_policy_name = true
end
if !invalid_penalty_per_unit && !same_policy_name
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
# if name has changed then only check for this
if params[:late_policy][:policy_name] != @penalty_policy.policy_name
if same_policy_name == LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "The policy could not be updated because a policy with the same name already exists."
end
end
if !same_policy_name && !invalid_penalty_per_unit
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif invalid_penalty_per_unit
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif same_policy_name
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

After Refactoring

<pre>
# validate checks if the entered penalty per unit and policy name is valid
def validate(params, is_update, current_policy_name)
valid = {}
# penalty per unit cannot be greater than max penalty
valid[:invalid_penalty_per_unit] = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if valid[:invalid_penalty_per_unit]
valid[:policy_name_already_exists] = false
# entered policy name cannot be same as an existing one
if (is_update && current_policy_name != params[:late_policy][:policy_name]) || !is_update
if LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
valid[:policy_name_already_exists] = true
end
end
valid
end
# POST /late_policies
# POST /late_policies.xml
def create
valid = validate(params, false, "")
if !valid[:invalid_penalty_per_unit] && !valid[:policy_name_already_exists]
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
valid = validate(params, true, @penalty_policy.policy_name)
if !valid[:policy_name_already_exists] && !valid[:invalid_penalty_per_unit]
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif valid[:invalid_penalty_per_unit]
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif valid[:policy_name_already_exists]
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

=== Issue 11 ===
----

We removed 'same_policy_name' and 'invalid_penalty_per_unit' and used a hash for that functionality. Then we changed the 'same_policy_name' to 'policy_name_already_exists'. We also added comments to the validator function which is called in create and update.

<pre>
# validate checks if the entered penalty per unit and policy name is valid
def validate(params, is_update, current_policy_name)
valid = {}
# penalty per unit cannot be greater than max penalty
valid[:invalid_penalty_per_unit] = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if valid[:invalid_penalty_per_unit]
valid[:policy_name_already_exists] = false
# entered policy name cannot be same as an existing one
if (is_update && current_policy_name != params[:late_policy][:policy_name]) || !is_update
if LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
valid[:policy_name_already_exists] = true
end
end
valid
end
</pre>

File:Codebug.png

2021-10-21T07:24:23Z

Adas9:

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T07:23:22Z

Adas9: /* Issue 10 */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
===Background===
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc). It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the student_quizzes_controller and late_policies_controller. In this Wiki Page, we would be explaining the changes that we have made for the same.
===Motivation===
This project in particular intends that the students collaborate with each other and work on making enhancements to the code base by applying the concepts of Rails, RSpec, DRY code, Test-driven development, etc. This provides an opportunity for students to contribute to an open-source project and learn further about software deployment etc.

student_quizzes_controller needs several comments to explain the methods and the code in general while late_policies_controller has code duplication which could be refactored to make it DRY and follow the Ruby style guide and Rails 4 syntax.
===Issues in student_quizzes_controller===
* Issue 1: finished_quiz method needs a comment describing its purpose (Line 23)
* Issue 2: Update .first to .last (Line 24)
* Issue 3: Check @participant variable name (Line 28)
* Issue 4: Fix method comment for self.take_quiz (Line 34)
* Issue 5: Refactor calculate_score method (Line 53-96 and Line 108)
* Issue 6: record_response needs a method comment (Line 98)
* Issue 7: Fix the English in the message (Line 110)
* Issue 8: Refactor review_questions method (Line 119)

===Issues in late_policies_controller===
* Issue 9: Create public & private late policies
* Issue 10: Fix duplicate code in create and update method.
* Issue 11: create and update method need comments and better identifier naming

== Modifications made to student_quizzes_controller ==
=== Issue 1 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Issue 2 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Issue 3 ===
----
Method: finished_quiz

The code under consideration is the following <pre>@participant = AssignmentTeam.find(@map.reviewee_id).participants.first</pre>

We get the first participant from the list of participants from AssignmentTeam, which is stored in the variable @participant. Therefore no refactor is required for this issue.

=== Issue 4 ===
----
Updated the method comment to better explain its purpose. 
Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Issue 5 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Issue 6 ===
----
Added method comment to record response to describe its purpose. 
Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Issue 7 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Issue 8 ===
----
Update the method comment to better describe review_questions. 
Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

== Modifications made to late_policies_controller ==

=== Issue 9 ===
----
< Add description here >

=== Issue 10 ===
----
We started by exploring the create and update methods in the late_policies_controller. We found out an existing bug in the code. In an update, if the new policy name is the name of an existing policy, an error wasn't returned and the call went through, resulting in multiple policies with the same name. We fixed that error.
[[File:file:///Users/macbookpro/Desktop/bug.png]]
After the fix, the error message is shown properly when the new policy name is the name of an existing policy.
[[File:UpdateBug.png]]

We also moved the duplicate code from update and create to a validator function which validates the policy name and penality points per unit for both create and update. The fix was done in the controller itself because view already handled duplicate code using the partial form.

Before Refactoring

<pre>
# POST /late_policies
# POST /late_policies.xml
def create
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
if same_policy_name != LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
same_policy_name = true
end
if !invalid_penalty_per_unit && !same_policy_name
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
# if name has changed then only check for this
if params[:late_policy][:policy_name] != @penalty_policy.policy_name
if same_policy_name == LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "The policy could not be updated because a policy with the same name already exists."
end
end
if !same_policy_name && !invalid_penalty_per_unit
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif invalid_penalty_per_unit
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif same_policy_name
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

After Refactoring

<pre>
# validate checks if the entered penalty per unit and policy name is valid
def validate(params, is_update, current_policy_name)
valid = {}
# penalty per unit cannot be greater than max penalty
valid[:invalid_penalty_per_unit] = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if valid[:invalid_penalty_per_unit]
valid[:policy_name_already_exists] = false
# entered policy name cannot be same as an existing one
if (is_update && current_policy_name != params[:late_policy][:policy_name]) || !is_update
if LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
valid[:policy_name_already_exists] = true
end
end
valid
end
# POST /late_policies
# POST /late_policies.xml
def create
valid = validate(params, false, "")
if !valid[:invalid_penalty_per_unit] && !valid[:policy_name_already_exists]
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
valid = validate(params, true, @penalty_policy.policy_name)
if !valid[:policy_name_already_exists] && !valid[:invalid_penalty_per_unit]
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif valid[:invalid_penalty_per_unit]
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif valid[:policy_name_already_exists]
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

=== Issue 11 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T07:13:37Z

Adas9: /* Issue 7 */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
===Background===
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc). It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the student_quizzes_controller and late_policies_controller. In this Wiki Page, we would be explaining the changes that we have made for the same.
===Motivation===
This project in particular intends that the students collaborate with each other and work on making enhancements to the code base by applying the concepts of Rails, RSpec, DRY code, Test-driven development, etc. This provides an opportunity for students to contribute to an open-source project and learn further about software deployment etc.

student_quizzes_controller needs several comments to explain the methods and the code in general while late_policies_controller has code duplication which could be refactored to make it DRY and follow the Ruby style guide and Rails 4 syntax.
===Issues in student_quizzes_controller===
* Issue 1: finished_quiz method needs a comment describing its purpose (Line 23)
* Issue 2: Update .first to .last (Line 24)
* Issue 3: Check @participant variable name (Line 28)
* Issue 4: Fix method comment for self.take_quiz (Line 34)
* Issue 5: Refactor calculate_score method (Line 53-96 and Line 108)
* Issue 6: record_response needs a method comment (Line 98)
* Issue 7: Fix the English in the message (Line 110)
* Issue 8: Refactor review_questions method (Line 119)

===Issues in late_policies_controller===
* Issue 9: Create public & private late policies
* Issue 10: Fix duplicate code in create and update method.
* Issue 11: create and update method need comments and better identifier naming

== Modifications made to student_quizzes_controller ==
=== Issue 1 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Issue 2 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Issue 3 ===
----
Method: finished_quiz

The code under consideration is the following <pre>@participant = AssignmentTeam.find(@map.reviewee_id).participants.first</pre>

We get the first participant from the list of participants from AssignmentTeam, which is stored in the variable @participant. Therefore no refactor is required for this issue.

=== Issue 4 ===
----
Updated the method comment to better explain its purpose. 
Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Issue 5 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Issue 6 ===
----
Added method comment to record response to describe its purpose. 
Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Issue 7 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Issue 8 ===
----
Update the method comment to better describe review_questions. 
Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

== Modifications made to late_policies_controller ==

=== Issue 9 ===
----
< Add description here >

=== Issue 10 ===
----
We started by exploring the create and update methods in the late_policies_controller. We found out an existing bug in the code. In update, if the new policy name is the name of an existing policy, an error wasn't returned and the call went through, resulting in multiple policies with the same name. We fixed that error.
[[File:UpdateBugExisting.png]]

After the fix, the error message is shown properly when the new policy name is the name of an existing policy.
[[File:UpdateBug.png]]

We also moved the duplicate code from update and create to a validator function which validates the policy name and penality points per unit for both create and update. The fix was done in the controller itself because view already handled duplicate code using partial form.

Before Refactoring

<pre>
# POST /late_policies
# POST /late_policies.xml
def create
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
if same_policy_name != LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
same_policy_name = true
end
if !invalid_penalty_per_unit && !same_policy_name
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
# if name has changed then only check for this
if params[:late_policy][:policy_name] != @penalty_policy.policy_name
if same_policy_name == LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "The policy could not be updated because a policy with the same name already exists."
end
end
if !same_policy_name && !invalid_penalty_per_unit
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif invalid_penalty_per_unit
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif same_policy_name
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

After Refactoring

<pre>
# validate checks if the entered penalty per unit and policy name is valid
def validate(params, is_update, current_policy_name)
valid = {}
# penalty per unit cannot be greater than max penalty
valid[:invalid_penalty_per_unit] = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if valid[:invalid_penalty_per_unit]
valid[:policy_name_already_exists] = false
# entered policy name cannot be same as an existing one
if (is_update && current_policy_name != params[:late_policy][:policy_name]) || !is_update
if LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
valid[:policy_name_already_exists] = true
end
end
valid
end
# POST /late_policies
# POST /late_policies.xml
def create
valid = validate(params, false, "")
if !valid[:invalid_penalty_per_unit] && !valid[:policy_name_already_exists]
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
valid = validate(params, true, @penalty_policy.policy_name)
if !valid[:policy_name_already_exists] && !valid[:invalid_penalty_per_unit]
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif valid[:invalid_penalty_per_unit]
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif valid[:policy_name_already_exists]
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

=== Issue 11 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T07:13:24Z

Adas9: /* Modifications made to late_policies_controller */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
===Background===
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc). It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the student_quizzes_controller and late_policies_controller. In this Wiki Page, we would be explaining the changes that we have made for the same.
===Motivation===
This project in particular intends that the students collaborate with each other and work on making enhancements to the code base by applying the concepts of Rails, RSpec, DRY code, Test-driven development, etc. This provides an opportunity for students to contribute to an open-source project and learn further about software deployment etc.

student_quizzes_controller needs several comments to explain the methods and the code in general while late_policies_controller has code duplication which could be refactored to make it DRY and follow the Ruby style guide and Rails 4 syntax.
===Issues in student_quizzes_controller===
* Issue 1: finished_quiz method needs a comment describing its purpose (Line 23)
* Issue 2: Update .first to .last (Line 24)
* Issue 3: Check @participant variable name (Line 28)
* Issue 4: Fix method comment for self.take_quiz (Line 34)
* Issue 5: Refactor calculate_score method (Line 53-96 and Line 108)
* Issue 6: record_response needs a method comment (Line 98)
* Issue 7: Fix the English in the message (Line 110)
* Issue 8: Refactor review_questions method (Line 119)

===Issues in late_policies_controller===
* Issue 9: Create public & private late policies
* Issue 10: Fix duplicate code in create and update method.
* Issue 11: create and update method need comments and better identifier naming

== Modifications made to student_quizzes_controller ==
=== Issue 1 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Issue 2 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Issue 3 ===
----
Method: finished_quiz

The code under consideration is the following <pre>@participant = AssignmentTeam.find(@map.reviewee_id).participants.first</pre>

We get the first participant from the list of participants from AssignmentTeam, which is stored in the variable @participant. Therefore no refactor is required for this issue.

=== Issue 4 ===
----
Updated the method comment to better explain its purpose. 
Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Issue 5 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Issue 6 ===
----
Added method comment to record response to describe its purpose. 
Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Issue 7 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Issue 7 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Issue 8 ===
----
Update the method comment to better describe review_questions. 
Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

== Modifications made to late_policies_controller ==

=== Issue 9 ===
----
< Add description here >

=== Issue 10 ===
----
We started by exploring the create and update methods in the late_policies_controller. We found out an existing bug in the code. In update, if the new policy name is the name of an existing policy, an error wasn't returned and the call went through, resulting in multiple policies with the same name. We fixed that error.
[[File:UpdateBugExisting.png]]

After the fix, the error message is shown properly when the new policy name is the name of an existing policy.
[[File:UpdateBug.png]]

We also moved the duplicate code from update and create to a validator function which validates the policy name and penality points per unit for both create and update. The fix was done in the controller itself because view already handled duplicate code using partial form.

Before Refactoring

<pre>
# POST /late_policies
# POST /late_policies.xml
def create
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
if same_policy_name != LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
same_policy_name = true
end
if !invalid_penalty_per_unit && !same_policy_name
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
# if name has changed then only check for this
if params[:late_policy][:policy_name] != @penalty_policy.policy_name
if same_policy_name == LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "The policy could not be updated because a policy with the same name already exists."
end
end
if !same_policy_name && !invalid_penalty_per_unit
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif invalid_penalty_per_unit
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif same_policy_name
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

After Refactoring

<pre>
# validate checks if the entered penalty per unit and policy name is valid
def validate(params, is_update, current_policy_name)
valid = {}
# penalty per unit cannot be greater than max penalty
valid[:invalid_penalty_per_unit] = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if valid[:invalid_penalty_per_unit]
valid[:policy_name_already_exists] = false
# entered policy name cannot be same as an existing one
if (is_update && current_policy_name != params[:late_policy][:policy_name]) || !is_update
if LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
valid[:policy_name_already_exists] = true
end
end
valid
end
# POST /late_policies
# POST /late_policies.xml
def create
valid = validate(params, false, "")
if !valid[:invalid_penalty_per_unit] && !valid[:policy_name_already_exists]
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
valid = validate(params, true, @penalty_policy.policy_name)
if !valid[:policy_name_already_exists] && !valid[:invalid_penalty_per_unit]
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif valid[:invalid_penalty_per_unit]
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif valid[:policy_name_already_exists]
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

=== Issue 11 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T07:12:56Z

Adas9: /* Issue 9 */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
===Background===
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc). It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the student_quizzes_controller and late_policies_controller. In this Wiki Page, we would be explaining the changes that we have made for the same.
===Motivation===
This project in particular intends that the students collaborate with each other and work on making enhancements to the code base by applying the concepts of Rails, RSpec, DRY code, Test-driven development, etc. This provides an opportunity for students to contribute to an open-source project and learn further about software deployment etc.

student_quizzes_controller needs several comments to explain the methods and the code in general while late_policies_controller has code duplication which could be refactored to make it DRY and follow the Ruby style guide and Rails 4 syntax.
===Issues in student_quizzes_controller===
* Issue 1: finished_quiz method needs a comment describing its purpose (Line 23)
* Issue 2: Update .first to .last (Line 24)
* Issue 3: Check @participant variable name (Line 28)
* Issue 4: Fix method comment for self.take_quiz (Line 34)
* Issue 5: Refactor calculate_score method (Line 53-96 and Line 108)
* Issue 6: record_response needs a method comment (Line 98)
* Issue 7: Fix the English in the message (Line 110)
* Issue 8: Refactor review_questions method (Line 119)

===Issues in late_policies_controller===
* Issue 9: Create public & private late policies
* Issue 10: Fix duplicate code in create and update method.
* Issue 11: create and update method need comments and better identifier naming

== Modifications made to student_quizzes_controller ==
=== Issue 1 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Issue 2 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Issue 3 ===
----
Method: finished_quiz

The code under consideration is the following <pre>@participant = AssignmentTeam.find(@map.reviewee_id).participants.first</pre>

We get the first participant from the list of participants from AssignmentTeam, which is stored in the variable @participant. Therefore no refactor is required for this issue.

=== Issue 4 ===
----
Updated the method comment to better explain its purpose. 
Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Issue 5 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Issue 6 ===
----
Added method comment to record response to describe its purpose. 
Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Issue 7 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Issue 7 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Issue 8 ===
----
Update the method comment to better describe review_questions. 
Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

== Modifications made to late_policies_controller ==

=== Issue 1 ===
----
< Add description here >

=== Issue 2 ===
----
We started by exploring the create and update methods in the late_policies_controller. We found out an existing bug in the code. In update, if the new policy name is the name of an existing policy, an error wasn't returned and the call went through, resulting in multiple policies with the same name. We fixed that error.
[[File:UpdateBugExisting.png]]

After the fix, the error message is shown properly when the new policy name is the name of an existing policy.
[[File:UpdateBug.png]]

We also moved the duplicate code from update and create to a validator function which validates the policy name and penality points per unit for both create and update. The fix was done in the controller itself because view already handled duplicate code using partial form.

Before Refactoring

<pre>
# POST /late_policies
# POST /late_policies.xml
def create
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
if same_policy_name != LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
same_policy_name = true
end
if !invalid_penalty_per_unit && !same_policy_name
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
# if name has changed then only check for this
if params[:late_policy][:policy_name] != @penalty_policy.policy_name
if same_policy_name == LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "The policy could not be updated because a policy with the same name already exists."
end
end
if !same_policy_name && !invalid_penalty_per_unit
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif invalid_penalty_per_unit
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif same_policy_name
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

After Refactoring

<pre>
# validate checks if the entered penalty per unit and policy name is valid
def validate(params, is_update, current_policy_name)
valid = {}
# penalty per unit cannot be greater than max penalty
valid[:invalid_penalty_per_unit] = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if valid[:invalid_penalty_per_unit]
valid[:policy_name_already_exists] = false
# entered policy name cannot be same as an existing one
if (is_update && current_policy_name != params[:late_policy][:policy_name]) || !is_update
if LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
valid[:policy_name_already_exists] = true
end
end
valid
end
# POST /late_policies
# POST /late_policies.xml
def create
valid = validate(params, false, "")
if !valid[:invalid_penalty_per_unit] && !valid[:policy_name_already_exists]
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
valid = validate(params, true, @penalty_policy.policy_name)
if !valid[:policy_name_already_exists] && !valid[:invalid_penalty_per_unit]
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif valid[:invalid_penalty_per_unit]
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif valid[:policy_name_already_exists]
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

=== Issue 3 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T07:12:46Z

Adas9: /* Issue 8 */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
===Background===
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc). It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the student_quizzes_controller and late_policies_controller. In this Wiki Page, we would be explaining the changes that we have made for the same.
===Motivation===
This project in particular intends that the students collaborate with each other and work on making enhancements to the code base by applying the concepts of Rails, RSpec, DRY code, Test-driven development, etc. This provides an opportunity for students to contribute to an open-source project and learn further about software deployment etc.

student_quizzes_controller needs several comments to explain the methods and the code in general while late_policies_controller has code duplication which could be refactored to make it DRY and follow the Ruby style guide and Rails 4 syntax.
===Issues in student_quizzes_controller===
* Issue 1: finished_quiz method needs a comment describing its purpose (Line 23)
* Issue 2: Update .first to .last (Line 24)
* Issue 3: Check @participant variable name (Line 28)
* Issue 4: Fix method comment for self.take_quiz (Line 34)
* Issue 5: Refactor calculate_score method (Line 53-96 and Line 108)
* Issue 6: record_response needs a method comment (Line 98)
* Issue 7: Fix the English in the message (Line 110)
* Issue 8: Refactor review_questions method (Line 119)

===Issues in late_policies_controller===
* Issue 9: Create public & private late policies
* Issue 10: Fix duplicate code in create and update method.
* Issue 11: create and update method need comments and better identifier naming

== Modifications made to student_quizzes_controller ==
=== Issue 1 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Issue 2 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Issue 3 ===
----
Method: finished_quiz

The code under consideration is the following <pre>@participant = AssignmentTeam.find(@map.reviewee_id).participants.first</pre>

We get the first participant from the list of participants from AssignmentTeam, which is stored in the variable @participant. Therefore no refactor is required for this issue.

=== Issue 4 ===
----
Updated the method comment to better explain its purpose. 
Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Issue 5 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Issue 6 ===
----
Added method comment to record response to describe its purpose. 
Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Issue 7 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Issue 7 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Issue 9 ===
----
Update the method comment to better describe review_questions. 
Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

== Modifications made to late_policies_controller ==

=== Issue 1 ===
----
< Add description here >

=== Issue 2 ===
----
We started by exploring the create and update methods in the late_policies_controller. We found out an existing bug in the code. In update, if the new policy name is the name of an existing policy, an error wasn't returned and the call went through, resulting in multiple policies with the same name. We fixed that error.
[[File:UpdateBugExisting.png]]

After the fix, the error message is shown properly when the new policy name is the name of an existing policy.
[[File:UpdateBug.png]]

We also moved the duplicate code from update and create to a validator function which validates the policy name and penality points per unit for both create and update. The fix was done in the controller itself because view already handled duplicate code using partial form.

Before Refactoring

<pre>
# POST /late_policies
# POST /late_policies.xml
def create
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
if same_policy_name != LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
same_policy_name = true
end
if !invalid_penalty_per_unit && !same_policy_name
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
# if name has changed then only check for this
if params[:late_policy][:policy_name] != @penalty_policy.policy_name
if same_policy_name == LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "The policy could not be updated because a policy with the same name already exists."
end
end
if !same_policy_name && !invalid_penalty_per_unit
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif invalid_penalty_per_unit
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif same_policy_name
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

After Refactoring

<pre>
# validate checks if the entered penalty per unit and policy name is valid
def validate(params, is_update, current_policy_name)
valid = {}
# penalty per unit cannot be greater than max penalty
valid[:invalid_penalty_per_unit] = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if valid[:invalid_penalty_per_unit]
valid[:policy_name_already_exists] = false
# entered policy name cannot be same as an existing one
if (is_update && current_policy_name != params[:late_policy][:policy_name]) || !is_update
if LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
valid[:policy_name_already_exists] = true
end
end
valid
end
# POST /late_policies
# POST /late_policies.xml
def create
valid = validate(params, false, "")
if !valid[:invalid_penalty_per_unit] && !valid[:policy_name_already_exists]
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
valid = validate(params, true, @penalty_policy.policy_name)
if !valid[:policy_name_already_exists] && !valid[:invalid_penalty_per_unit]
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif valid[:invalid_penalty_per_unit]
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif valid[:policy_name_already_exists]
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

=== Issue 3 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T07:09:30Z

Adas9: /* Modifications made to student_quizzes_controller */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
===Background===
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc). It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the student_quizzes_controller and late_policies_controller. In this Wiki Page, we would be explaining the changes that we have made for the same.
===Motivation===
This project in particular intends that the students collaborate with each other and work on making enhancements to the code base by applying the concepts of Rails, RSpec, DRY code, Test-driven development, etc. This provides an opportunity for students to contribute to an open-source project and learn further about software deployment etc.

student_quizzes_controller needs several comments to explain the methods and the code in general while late_policies_controller has code duplication which could be refactored to make it DRY and follow the Ruby style guide and Rails 4 syntax.
===Issues in student_quizzes_controller===
* Issue 1: finished_quiz method needs a comment describing its purpose (Line 23)
* Issue 2: Update .first to .last (Line 24)
* Issue 3: Check @participant variable name (Line 28)
* Issue 4: Fix method comment for self.take_quiz (Line 34)
* Issue 5: Refactor calculate_score method (Line 53-96 and Line 108)
* Issue 6: record_response needs a method comment (Line 98)
* Issue 7: Fix the English in the message (Line 110)
* Issue 8: Refactor review_questions method (Line 119)

===Issues in late_policies_controller===
* Issue 9: Create public & private late policies
* Issue 10: Fix duplicate code in create and update method.
* Issue 11: create and update method need comments and better identifier naming

== Modifications made to student_quizzes_controller ==
=== Issue 1 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Issue 2 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Issue 3 ===
----
Method: finished_quiz

The code under consideration is the following <pre>@participant = AssignmentTeam.find(@map.reviewee_id).participants.first</pre>

We get the first participant from the list of participants from AssignmentTeam, which is stored in the variable @participant. Therefore no refactor is required for this issue.

=== Issue 4 ===
----
Updated the method comment to better explain its purpose. 
Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Issue 5 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Issue 6 ===
----
Added method comment to record response to describe its purpose. 
Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Issue 7 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Issue 8 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Issue 9 ===
----
Update the method comment to better describe review_questions. 
Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

== Modifications made to late_policies_controller ==

=== Issue 1 ===
----
< Add description here >

=== Issue 2 ===
----
We started by exploring the create and update methods in the late_policies_controller. We found out an existing bug in the code. In update, if the new policy name is the name of an existing policy, an error wasn't returned and the call went through, resulting in multiple policies with the same name. We fixed that error.
[[File:UpdateBugExisting.png]]

After the fix, the error message is shown properly when the new policy name is the name of an existing policy.
[[File:UpdateBug.png]]

We also moved the duplicate code from update and create to a validator function which validates the policy name and penality points per unit for both create and update. The fix was done in the controller itself because view already handled duplicate code using partial form.

Before Refactoring

<pre>
# POST /late_policies
# POST /late_policies.xml
def create
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
if same_policy_name != LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
same_policy_name = true
end
if !invalid_penalty_per_unit && !same_policy_name
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
# if name has changed then only check for this
if params[:late_policy][:policy_name] != @penalty_policy.policy_name
if same_policy_name == LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "The policy could not be updated because a policy with the same name already exists."
end
end
if !same_policy_name && !invalid_penalty_per_unit
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif invalid_penalty_per_unit
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif same_policy_name
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

After Refactoring

<pre>
# validate checks if the entered penalty per unit and policy name is valid
def validate(params, is_update, current_policy_name)
valid = {}
# penalty per unit cannot be greater than max penalty
valid[:invalid_penalty_per_unit] = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if valid[:invalid_penalty_per_unit]
valid[:policy_name_already_exists] = false
# entered policy name cannot be same as an existing one
if (is_update && current_policy_name != params[:late_policy][:policy_name]) || !is_update
if LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
valid[:policy_name_already_exists] = true
end
end
valid
end
# POST /late_policies
# POST /late_policies.xml
def create
valid = validate(params, false, "")
if !valid[:invalid_penalty_per_unit] && !valid[:policy_name_already_exists]
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
valid = validate(params, true, @penalty_policy.policy_name)
if !valid[:policy_name_already_exists] && !valid[:invalid_penalty_per_unit]
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif valid[:invalid_penalty_per_unit]
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif valid[:policy_name_already_exists]
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

=== Issue 3 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T07:08:45Z

Adas9: /* Lines 53-96 */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
===Background===
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc). It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the student_quizzes_controller and late_policies_controller. In this Wiki Page, we would be explaining the changes that we have made for the same.
===Motivation===
This project in particular intends that the students collaborate with each other and work on making enhancements to the code base by applying the concepts of Rails, RSpec, DRY code, Test-driven development, etc. This provides an opportunity for students to contribute to an open-source project and learn further about software deployment etc.

student_quizzes_controller needs several comments to explain the methods and the code in general while late_policies_controller has code duplication which could be refactored to make it DRY and follow the Ruby style guide and Rails 4 syntax.
===Issues in student_quizzes_controller===
* Issue 1: finished_quiz method needs a comment describing its purpose (Line 23)
* Issue 2: Update .first to .last (Line 24)
* Issue 3: Check @participant variable name (Line 28)
* Issue 4: Fix method comment for self.take_quiz (Line 34)
* Issue 5: Refactor calculate_score method (Line 53-96 and Line 108)
* Issue 6: record_response needs a method comment (Line 98)
* Issue 7: Fix the English in the message (Line 110)
* Issue 8: Refactor review_questions method (Line 119)

===Issues in late_policies_controller===
* Issue 9: Create public & private late policies
* Issue 10: Fix duplicate code in create and update method.
* Issue 11: create and update method need comments and better identifier naming

== Modifications made to student_quizzes_controller ==
=== Issue 1 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Issue 2 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Issue 3 ===
----
Method: finished_quiz

The code under consideration is the following <pre>@participant = AssignmentTeam.find(@map.reviewee_id).participants.first</pre>

We get the first participant from the list of participants from AssignmentTeam, which is stored in the variable @participant. Therefore no refactor is required for this issue.

=== Issue 4 ===
----
Updated the method comment to better explain its purpose. 
Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Issue 5 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Line 98 ===
----
Added method comment to record response to describe its purpose. 
Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Line 108 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Line 110 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Line 119 ===
----
Update the method comment to better describe review_questions. 
Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

== Modifications made to late_policies_controller ==

=== Issue 1 ===
----
< Add description here >

=== Issue 2 ===
----
We started by exploring the create and update methods in the late_policies_controller. We found out an existing bug in the code. In update, if the new policy name is the name of an existing policy, an error wasn't returned and the call went through, resulting in multiple policies with the same name. We fixed that error.
[[File:UpdateBugExisting.png]]

After the fix, the error message is shown properly when the new policy name is the name of an existing policy.
[[File:UpdateBug.png]]

We also moved the duplicate code from update and create to a validator function which validates the policy name and penality points per unit for both create and update. The fix was done in the controller itself because view already handled duplicate code using partial form.

Before Refactoring

<pre>
# POST /late_policies
# POST /late_policies.xml
def create
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
if same_policy_name != LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
same_policy_name = true
end
if !invalid_penalty_per_unit && !same_policy_name
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
# if name has changed then only check for this
if params[:late_policy][:policy_name] != @penalty_policy.policy_name
if same_policy_name == LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "The policy could not be updated because a policy with the same name already exists."
end
end
if !same_policy_name && !invalid_penalty_per_unit
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif invalid_penalty_per_unit
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif same_policy_name
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

After Refactoring

<pre>
# validate checks if the entered penalty per unit and policy name is valid
def validate(params, is_update, current_policy_name)
valid = {}
# penalty per unit cannot be greater than max penalty
valid[:invalid_penalty_per_unit] = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if valid[:invalid_penalty_per_unit]
valid[:policy_name_already_exists] = false
# entered policy name cannot be same as an existing one
if (is_update && current_policy_name != params[:late_policy][:policy_name]) || !is_update
if LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
valid[:policy_name_already_exists] = true
end
end
valid
end
# POST /late_policies
# POST /late_policies.xml
def create
valid = validate(params, false, "")
if !valid[:invalid_penalty_per_unit] && !valid[:policy_name_already_exists]
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
valid = validate(params, true, @penalty_policy.policy_name)
if !valid[:policy_name_already_exists] && !valid[:invalid_penalty_per_unit]
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif valid[:invalid_penalty_per_unit]
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif valid[:policy_name_already_exists]
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

=== Issue 3 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T07:08:25Z

Adas9: /* Line 34 */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
===Background===
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc). It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the student_quizzes_controller and late_policies_controller. In this Wiki Page, we would be explaining the changes that we have made for the same.
===Motivation===
This project in particular intends that the students collaborate with each other and work on making enhancements to the code base by applying the concepts of Rails, RSpec, DRY code, Test-driven development, etc. This provides an opportunity for students to contribute to an open-source project and learn further about software deployment etc.

student_quizzes_controller needs several comments to explain the methods and the code in general while late_policies_controller has code duplication which could be refactored to make it DRY and follow the Ruby style guide and Rails 4 syntax.
===Issues in student_quizzes_controller===
* Issue 1: finished_quiz method needs a comment describing its purpose (Line 23)
* Issue 2: Update .first to .last (Line 24)
* Issue 3: Check @participant variable name (Line 28)
* Issue 4: Fix method comment for self.take_quiz (Line 34)
* Issue 5: Refactor calculate_score method (Line 53-96 and Line 108)
* Issue 6: record_response needs a method comment (Line 98)
* Issue 7: Fix the English in the message (Line 110)
* Issue 8: Refactor review_questions method (Line 119)

===Issues in late_policies_controller===
* Issue 9: Create public & private late policies
* Issue 10: Fix duplicate code in create and update method.
* Issue 11: create and update method need comments and better identifier naming

== Modifications made to student_quizzes_controller ==
=== Issue 1 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Issue 2 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Issue 3 ===
----
Method: finished_quiz

The code under consideration is the following <pre>@participant = AssignmentTeam.find(@map.reviewee_id).participants.first</pre>

We get the first participant from the list of participants from AssignmentTeam, which is stored in the variable @participant. Therefore no refactor is required for this issue.

=== Issue 4 ===
----
Updated the method comment to better explain its purpose. 
Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Lines 53-96 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Line 98 ===
----
Added method comment to record response to describe its purpose. 
Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Line 108 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Line 110 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Line 119 ===
----
Update the method comment to better describe review_questions. 
Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

== Modifications made to late_policies_controller ==

=== Issue 1 ===
----
< Add description here >

=== Issue 2 ===
----
We started by exploring the create and update methods in the late_policies_controller. We found out an existing bug in the code. In update, if the new policy name is the name of an existing policy, an error wasn't returned and the call went through, resulting in multiple policies with the same name. We fixed that error.
[[File:UpdateBugExisting.png]]

After the fix, the error message is shown properly when the new policy name is the name of an existing policy.
[[File:UpdateBug.png]]

We also moved the duplicate code from update and create to a validator function which validates the policy name and penality points per unit for both create and update. The fix was done in the controller itself because view already handled duplicate code using partial form.

Before Refactoring

<pre>
# POST /late_policies
# POST /late_policies.xml
def create
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
if same_policy_name != LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
same_policy_name = true
end
if !invalid_penalty_per_unit && !same_policy_name
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
# if name has changed then only check for this
if params[:late_policy][:policy_name] != @penalty_policy.policy_name
if same_policy_name == LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "The policy could not be updated because a policy with the same name already exists."
end
end
if !same_policy_name && !invalid_penalty_per_unit
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif invalid_penalty_per_unit
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif same_policy_name
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

After Refactoring

<pre>
# validate checks if the entered penalty per unit and policy name is valid
def validate(params, is_update, current_policy_name)
valid = {}
# penalty per unit cannot be greater than max penalty
valid[:invalid_penalty_per_unit] = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if valid[:invalid_penalty_per_unit]
valid[:policy_name_already_exists] = false
# entered policy name cannot be same as an existing one
if (is_update && current_policy_name != params[:late_policy][:policy_name]) || !is_update
if LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
valid[:policy_name_already_exists] = true
end
end
valid
end
# POST /late_policies
# POST /late_policies.xml
def create
valid = validate(params, false, "")
if !valid[:invalid_penalty_per_unit] && !valid[:policy_name_already_exists]
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
valid = validate(params, true, @penalty_policy.policy_name)
if !valid[:policy_name_already_exists] && !valid[:invalid_penalty_per_unit]
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif valid[:invalid_penalty_per_unit]
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif valid[:policy_name_already_exists]
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

=== Issue 3 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T07:08:10Z

Adas9: /* Line 28 */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
===Background===
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc). It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the student_quizzes_controller and late_policies_controller. In this Wiki Page, we would be explaining the changes that we have made for the same.
===Motivation===
This project in particular intends that the students collaborate with each other and work on making enhancements to the code base by applying the concepts of Rails, RSpec, DRY code, Test-driven development, etc. This provides an opportunity for students to contribute to an open-source project and learn further about software deployment etc.

student_quizzes_controller needs several comments to explain the methods and the code in general while late_policies_controller has code duplication which could be refactored to make it DRY and follow the Ruby style guide and Rails 4 syntax.
===Issues in student_quizzes_controller===
* Issue 1: finished_quiz method needs a comment describing its purpose (Line 23)
* Issue 2: Update .first to .last (Line 24)
* Issue 3: Check @participant variable name (Line 28)
* Issue 4: Fix method comment for self.take_quiz (Line 34)
* Issue 5: Refactor calculate_score method (Line 53-96 and Line 108)
* Issue 6: record_response needs a method comment (Line 98)
* Issue 7: Fix the English in the message (Line 110)
* Issue 8: Refactor review_questions method (Line 119)

===Issues in late_policies_controller===
* Issue 9: Create public & private late policies
* Issue 10: Fix duplicate code in create and update method.
* Issue 11: create and update method need comments and better identifier naming

== Modifications made to student_quizzes_controller ==
=== Issue 1 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Issue 2 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Issue 3 ===
----
Method: finished_quiz

The code under consideration is the following <pre>@participant = AssignmentTeam.find(@map.reviewee_id).participants.first</pre>

We get the first participant from the list of participants from AssignmentTeam, which is stored in the variable @participant. Therefore no refactor is required for this issue.

=== Line 34 ===
----
Updated the method comment to better explain its purpose. 
Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Lines 53-96 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Line 98 ===
----
Added method comment to record response to describe its purpose. 
Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Line 108 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Line 110 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Line 119 ===
----
Update the method comment to better describe review_questions. 
Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

== Modifications made to late_policies_controller ==

=== Issue 1 ===
----
< Add description here >

=== Issue 2 ===
----
We started by exploring the create and update methods in the late_policies_controller. We found out an existing bug in the code. In update, if the new policy name is the name of an existing policy, an error wasn't returned and the call went through, resulting in multiple policies with the same name. We fixed that error.
[[File:UpdateBugExisting.png]]

After the fix, the error message is shown properly when the new policy name is the name of an existing policy.
[[File:UpdateBug.png]]

We also moved the duplicate code from update and create to a validator function which validates the policy name and penality points per unit for both create and update. The fix was done in the controller itself because view already handled duplicate code using partial form.

Before Refactoring

<pre>
# POST /late_policies
# POST /late_policies.xml
def create
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
if same_policy_name != LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
same_policy_name = true
end
if !invalid_penalty_per_unit && !same_policy_name
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
# if name has changed then only check for this
if params[:late_policy][:policy_name] != @penalty_policy.policy_name
if same_policy_name == LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "The policy could not be updated because a policy with the same name already exists."
end
end
if !same_policy_name && !invalid_penalty_per_unit
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif invalid_penalty_per_unit
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif same_policy_name
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

After Refactoring

<pre>
# validate checks if the entered penalty per unit and policy name is valid
def validate(params, is_update, current_policy_name)
valid = {}
# penalty per unit cannot be greater than max penalty
valid[:invalid_penalty_per_unit] = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if valid[:invalid_penalty_per_unit]
valid[:policy_name_already_exists] = false
# entered policy name cannot be same as an existing one
if (is_update && current_policy_name != params[:late_policy][:policy_name]) || !is_update
if LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
valid[:policy_name_already_exists] = true
end
end
valid
end
# POST /late_policies
# POST /late_policies.xml
def create
valid = validate(params, false, "")
if !valid[:invalid_penalty_per_unit] && !valid[:policy_name_already_exists]
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
valid = validate(params, true, @penalty_policy.policy_name)
if !valid[:policy_name_already_exists] && !valid[:invalid_penalty_per_unit]
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif valid[:invalid_penalty_per_unit]
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif valid[:policy_name_already_exists]
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

=== Issue 3 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T07:07:53Z

Adas9: /* Line 24 */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
===Background===
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc). It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the student_quizzes_controller and late_policies_controller. In this Wiki Page, we would be explaining the changes that we have made for the same.
===Motivation===
This project in particular intends that the students collaborate with each other and work on making enhancements to the code base by applying the concepts of Rails, RSpec, DRY code, Test-driven development, etc. This provides an opportunity for students to contribute to an open-source project and learn further about software deployment etc.

student_quizzes_controller needs several comments to explain the methods and the code in general while late_policies_controller has code duplication which could be refactored to make it DRY and follow the Ruby style guide and Rails 4 syntax.
===Issues in student_quizzes_controller===
* Issue 1: finished_quiz method needs a comment describing its purpose (Line 23)
* Issue 2: Update .first to .last (Line 24)
* Issue 3: Check @participant variable name (Line 28)
* Issue 4: Fix method comment for self.take_quiz (Line 34)
* Issue 5: Refactor calculate_score method (Line 53-96 and Line 108)
* Issue 6: record_response needs a method comment (Line 98)
* Issue 7: Fix the English in the message (Line 110)
* Issue 8: Refactor review_questions method (Line 119)

===Issues in late_policies_controller===
* Issue 9: Create public & private late policies
* Issue 10: Fix duplicate code in create and update method.
* Issue 11: create and update method need comments and better identifier naming

== Modifications made to student_quizzes_controller ==
=== Issue 1 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Issue 2 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Line 28 ===
----
Method: finished_quiz

The code under consideration is the following <pre>@participant = AssignmentTeam.find(@map.reviewee_id).participants.first</pre>

We get the first participant from the list of participants from AssignmentTeam, which is stored in the variable @participant. Therefore no refactor is required for this issue.

=== Line 34 ===
----
Updated the method comment to better explain its purpose. 
Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Lines 53-96 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Line 98 ===
----
Added method comment to record response to describe its purpose. 
Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Line 108 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Line 110 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Line 119 ===
----
Update the method comment to better describe review_questions. 
Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

== Modifications made to late_policies_controller ==

=== Issue 1 ===
----
< Add description here >

=== Issue 2 ===
----
We started by exploring the create and update methods in the late_policies_controller. We found out an existing bug in the code. In update, if the new policy name is the name of an existing policy, an error wasn't returned and the call went through, resulting in multiple policies with the same name. We fixed that error.
[[File:UpdateBugExisting.png]]

After the fix, the error message is shown properly when the new policy name is the name of an existing policy.
[[File:UpdateBug.png]]

We also moved the duplicate code from update and create to a validator function which validates the policy name and penality points per unit for both create and update. The fix was done in the controller itself because view already handled duplicate code using partial form.

Before Refactoring

<pre>
# POST /late_policies
# POST /late_policies.xml
def create
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
if same_policy_name != LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
same_policy_name = true
end
if !invalid_penalty_per_unit && !same_policy_name
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
# if name has changed then only check for this
if params[:late_policy][:policy_name] != @penalty_policy.policy_name
if same_policy_name == LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "The policy could not be updated because a policy with the same name already exists."
end
end
if !same_policy_name && !invalid_penalty_per_unit
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif invalid_penalty_per_unit
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif same_policy_name
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

After Refactoring

<pre>
# validate checks if the entered penalty per unit and policy name is valid
def validate(params, is_update, current_policy_name)
valid = {}
# penalty per unit cannot be greater than max penalty
valid[:invalid_penalty_per_unit] = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if valid[:invalid_penalty_per_unit]
valid[:policy_name_already_exists] = false
# entered policy name cannot be same as an existing one
if (is_update && current_policy_name != params[:late_policy][:policy_name]) || !is_update
if LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
valid[:policy_name_already_exists] = true
end
end
valid
end
# POST /late_policies
# POST /late_policies.xml
def create
valid = validate(params, false, "")
if !valid[:invalid_penalty_per_unit] && !valid[:policy_name_already_exists]
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
valid = validate(params, true, @penalty_policy.policy_name)
if !valid[:policy_name_already_exists] && !valid[:invalid_penalty_per_unit]
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif valid[:invalid_penalty_per_unit]
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif valid[:policy_name_already_exists]
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

=== Issue 3 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T07:07:41Z

Adas9: /* Line 23 */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
===Background===
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc). It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the student_quizzes_controller and late_policies_controller. In this Wiki Page, we would be explaining the changes that we have made for the same.
===Motivation===
This project in particular intends that the students collaborate with each other and work on making enhancements to the code base by applying the concepts of Rails, RSpec, DRY code, Test-driven development, etc. This provides an opportunity for students to contribute to an open-source project and learn further about software deployment etc.

student_quizzes_controller needs several comments to explain the methods and the code in general while late_policies_controller has code duplication which could be refactored to make it DRY and follow the Ruby style guide and Rails 4 syntax.
===Issues in student_quizzes_controller===
* Issue 1: finished_quiz method needs a comment describing its purpose (Line 23)
* Issue 2: Update .first to .last (Line 24)
* Issue 3: Check @participant variable name (Line 28)
* Issue 4: Fix method comment for self.take_quiz (Line 34)
* Issue 5: Refactor calculate_score method (Line 53-96 and Line 108)
* Issue 6: record_response needs a method comment (Line 98)
* Issue 7: Fix the English in the message (Line 110)
* Issue 8: Refactor review_questions method (Line 119)

===Issues in late_policies_controller===
* Issue 9: Create public & private late policies
* Issue 10: Fix duplicate code in create and update method.
* Issue 11: create and update method need comments and better identifier naming

== Modifications made to student_quizzes_controller ==
=== Issue 1 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Line 24 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Line 28 ===
----
Method: finished_quiz

The code under consideration is the following <pre>@participant = AssignmentTeam.find(@map.reviewee_id).participants.first</pre>

We get the first participant from the list of participants from AssignmentTeam, which is stored in the variable @participant. Therefore no refactor is required for this issue.

=== Line 34 ===
----
Updated the method comment to better explain its purpose. 
Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Lines 53-96 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Line 98 ===
----
Added method comment to record response to describe its purpose. 
Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Line 108 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Line 110 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Line 119 ===
----
Update the method comment to better describe review_questions. 
Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

== Modifications made to late_policies_controller ==

=== Issue 1 ===
----
< Add description here >

=== Issue 2 ===
----
We started by exploring the create and update methods in the late_policies_controller. We found out an existing bug in the code. In update, if the new policy name is the name of an existing policy, an error wasn't returned and the call went through, resulting in multiple policies with the same name. We fixed that error.
[[File:UpdateBugExisting.png]]

After the fix, the error message is shown properly when the new policy name is the name of an existing policy.
[[File:UpdateBug.png]]

We also moved the duplicate code from update and create to a validator function which validates the policy name and penality points per unit for both create and update. The fix was done in the controller itself because view already handled duplicate code using partial form.

Before Refactoring

<pre>
# POST /late_policies
# POST /late_policies.xml
def create
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
if same_policy_name != LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
same_policy_name = true
end
if !invalid_penalty_per_unit && !same_policy_name
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
# if name has changed then only check for this
if params[:late_policy][:policy_name] != @penalty_policy.policy_name
if same_policy_name == LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "The policy could not be updated because a policy with the same name already exists."
end
end
if !same_policy_name && !invalid_penalty_per_unit
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif invalid_penalty_per_unit
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif same_policy_name
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

After Refactoring

<pre>
# validate checks if the entered penalty per unit and policy name is valid
def validate(params, is_update, current_policy_name)
valid = {}
# penalty per unit cannot be greater than max penalty
valid[:invalid_penalty_per_unit] = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if valid[:invalid_penalty_per_unit]
valid[:policy_name_already_exists] = false
# entered policy name cannot be same as an existing one
if (is_update && current_policy_name != params[:late_policy][:policy_name]) || !is_update
if LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
valid[:policy_name_already_exists] = true
end
end
valid
end
# POST /late_policies
# POST /late_policies.xml
def create
valid = validate(params, false, "")
if !valid[:invalid_penalty_per_unit] && !valid[:policy_name_already_exists]
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
valid = validate(params, true, @penalty_policy.policy_name)
if !valid[:policy_name_already_exists] && !valid[:invalid_penalty_per_unit]
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif valid[:invalid_penalty_per_unit]
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif valid[:policy_name_already_exists]
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

=== Issue 3 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T07:07:22Z

Adas9: /* Issues in late_policies_controller */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
===Background===
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc). It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the student_quizzes_controller and late_policies_controller. In this Wiki Page, we would be explaining the changes that we have made for the same.
===Motivation===
This project in particular intends that the students collaborate with each other and work on making enhancements to the code base by applying the concepts of Rails, RSpec, DRY code, Test-driven development, etc. This provides an opportunity for students to contribute to an open-source project and learn further about software deployment etc.

student_quizzes_controller needs several comments to explain the methods and the code in general while late_policies_controller has code duplication which could be refactored to make it DRY and follow the Ruby style guide and Rails 4 syntax.
===Issues in student_quizzes_controller===
* Issue 1: finished_quiz method needs a comment describing its purpose (Line 23)
* Issue 2: Update .first to .last (Line 24)
* Issue 3: Check @participant variable name (Line 28)
* Issue 4: Fix method comment for self.take_quiz (Line 34)
* Issue 5: Refactor calculate_score method (Line 53-96 and Line 108)
* Issue 6: record_response needs a method comment (Line 98)
* Issue 7: Fix the English in the message (Line 110)
* Issue 8: Refactor review_questions method (Line 119)

===Issues in late_policies_controller===
* Issue 9: Create public & private late policies
* Issue 10: Fix duplicate code in create and update method.
* Issue 11: create and update method need comments and better identifier naming

== Modifications made to student_quizzes_controller ==
=== Line 23 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Line 24 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Line 28 ===
----
Method: finished_quiz

The code under consideration is the following <pre>@participant = AssignmentTeam.find(@map.reviewee_id).participants.first</pre>

We get the first participant from the list of participants from AssignmentTeam, which is stored in the variable @participant. Therefore no refactor is required for this issue.

=== Line 34 ===
----
Updated the method comment to better explain its purpose. 
Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Lines 53-96 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Line 98 ===
----
Added method comment to record response to describe its purpose. 
Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Line 108 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Line 110 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Line 119 ===
----
Update the method comment to better describe review_questions. 
Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

== Modifications made to late_policies_controller ==

=== Issue 1 ===
----
< Add description here >

=== Issue 2 ===
----
We started by exploring the create and update methods in the late_policies_controller. We found out an existing bug in the code. In update, if the new policy name is the name of an existing policy, an error wasn't returned and the call went through, resulting in multiple policies with the same name. We fixed that error.
[[File:UpdateBugExisting.png]]

After the fix, the error message is shown properly when the new policy name is the name of an existing policy.
[[File:UpdateBug.png]]

We also moved the duplicate code from update and create to a validator function which validates the policy name and penality points per unit for both create and update. The fix was done in the controller itself because view already handled duplicate code using partial form.

Before Refactoring

<pre>
# POST /late_policies
# POST /late_policies.xml
def create
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
if same_policy_name != LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
same_policy_name = true
end
if !invalid_penalty_per_unit && !same_policy_name
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
# if name has changed then only check for this
if params[:late_policy][:policy_name] != @penalty_policy.policy_name
if same_policy_name == LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "The policy could not be updated because a policy with the same name already exists."
end
end
if !same_policy_name && !invalid_penalty_per_unit
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif invalid_penalty_per_unit
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif same_policy_name
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

After Refactoring

<pre>
# validate checks if the entered penalty per unit and policy name is valid
def validate(params, is_update, current_policy_name)
valid = {}
# penalty per unit cannot be greater than max penalty
valid[:invalid_penalty_per_unit] = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if valid[:invalid_penalty_per_unit]
valid[:policy_name_already_exists] = false
# entered policy name cannot be same as an existing one
if (is_update && current_policy_name != params[:late_policy][:policy_name]) || !is_update
if LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
valid[:policy_name_already_exists] = true
end
end
valid
end
# POST /late_policies
# POST /late_policies.xml
def create
valid = validate(params, false, "")
if !valid[:invalid_penalty_per_unit] && !valid[:policy_name_already_exists]
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
valid = validate(params, true, @penalty_policy.policy_name)
if !valid[:policy_name_already_exists] && !valid[:invalid_penalty_per_unit]
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif valid[:invalid_penalty_per_unit]
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif valid[:policy_name_already_exists]
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

=== Issue 3 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T07:06:59Z

Adas9: /* Issues in student_quizzes_controller */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
===Background===
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc). It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the student_quizzes_controller and late_policies_controller. In this Wiki Page, we would be explaining the changes that we have made for the same.
===Motivation===
This project in particular intends that the students collaborate with each other and work on making enhancements to the code base by applying the concepts of Rails, RSpec, DRY code, Test-driven development, etc. This provides an opportunity for students to contribute to an open-source project and learn further about software deployment etc.

student_quizzes_controller needs several comments to explain the methods and the code in general while late_policies_controller has code duplication which could be refactored to make it DRY and follow the Ruby style guide and Rails 4 syntax.
===Issues in student_quizzes_controller===
* Issue 1: finished_quiz method needs a comment describing its purpose (Line 23)
* Issue 2: Update .first to .last (Line 24)
* Issue 3: Check @participant variable name (Line 28)
* Issue 4: Fix method comment for self.take_quiz (Line 34)
* Issue 5: Refactor calculate_score method (Line 53-96 and Line 108)
* Issue 6: record_response needs a method comment (Line 98)
* Issue 7: Fix the English in the message (Line 110)
* Issue 8: Refactor review_questions method (Line 119)

===Issues in late_policies_controller===
* Create public & private late policies
* Fix duplicate code in create and update method.
* create and update method need comments and better identifier naming

== Modifications made to student_quizzes_controller ==
=== Line 23 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Line 24 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Line 28 ===
----
Method: finished_quiz

The code under consideration is the following <pre>@participant = AssignmentTeam.find(@map.reviewee_id).participants.first</pre>

We get the first participant from the list of participants from AssignmentTeam, which is stored in the variable @participant. Therefore no refactor is required for this issue.

=== Line 34 ===
----
Updated the method comment to better explain its purpose. 
Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Lines 53-96 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Line 98 ===
----
Added method comment to record response to describe its purpose. 
Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Line 108 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Line 110 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Line 119 ===
----
Update the method comment to better describe review_questions. 
Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

== Modifications made to late_policies_controller ==

=== Issue 1 ===
----
< Add description here >

=== Issue 2 ===
----
We started by exploring the create and update methods in the late_policies_controller. We found out an existing bug in the code. In update, if the new policy name is the name of an existing policy, an error wasn't returned and the call went through, resulting in multiple policies with the same name. We fixed that error.
[[File:UpdateBugExisting.png]]

After the fix, the error message is shown properly when the new policy name is the name of an existing policy.
[[File:UpdateBug.png]]

We also moved the duplicate code from update and create to a validator function which validates the policy name and penality points per unit for both create and update. The fix was done in the controller itself because view already handled duplicate code using partial form.

Before Refactoring

<pre>
# POST /late_policies
# POST /late_policies.xml
def create
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
if same_policy_name != LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
same_policy_name = true
end
if !invalid_penalty_per_unit && !same_policy_name
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
invalid_penalty_per_unit = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if invalid_penalty_per_unit
same_policy_name = false
# if name has changed then only check for this
if params[:late_policy][:policy_name] != @penalty_policy.policy_name
if same_policy_name == LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "The policy could not be updated because a policy with the same name already exists."
end
end
if !same_policy_name && !invalid_penalty_per_unit
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif invalid_penalty_per_unit
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif same_policy_name
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

After Refactoring

<pre>
# validate checks if the entered penalty per unit and policy name is valid
def validate(params, is_update, current_policy_name)
valid = {}
# penalty per unit cannot be greater than max penalty
valid[:invalid_penalty_per_unit] = params[:late_policy][:max_penalty].to_i < params[:late_policy][:penalty_per_unit].to_i
flash[:error] = "The maximum penalty cannot be less than penalty per unit." if valid[:invalid_penalty_per_unit]
valid[:policy_name_already_exists] = false
# entered policy name cannot be same as an existing one
if (is_update && current_policy_name != params[:late_policy][:policy_name]) || !is_update
if LatePolicy.check_policy_with_same_name(params[:late_policy][:policy_name], instructor_id)
flash[:error] = "A policy with the same name already exists."
valid[:policy_name_already_exists] = true
end
end
valid
end
# POST /late_policies
# POST /late_policies.xml
def create
valid = validate(params, false, "")
if !valid[:invalid_penalty_per_unit] && !valid[:policy_name_already_exists]
@late_policy = LatePolicy.new(late_policy_params)
@late_policy.instructor_id = instructor_id
begin
@late_policy.save!
flash[:notice] = "The penalty policy was successfully created."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while saving the penalty policy: "
redirect_to action: 'new'
end
else
redirect_to action: 'new'
end
end

# PUT /late_policies/1
# PUT /late_policies/1.xml
def update
@penalty_policy = LatePolicy.find(params[:id])
valid = validate(params, true, @penalty_policy.policy_name)
if !valid[:policy_name_already_exists] && !valid[:invalid_penalty_per_unit]
begin
@penalty_policy.update_attributes(late_policy_params)
@penalty_policy.save!
LatePolicy.update_calculated_penalty_objects(@penalty_policy)
flash[:notice] = "The late policy was successfully updated."
redirect_to action: 'index'
rescue StandardError
flash[:error] = "The following error occurred while updating the penalty policy: "
redirect_to action: 'edit', id: params[:id]
end
elsif valid[:invalid_penalty_per_unit]
flash[:error] = "Cannot edit the policy. The maximum penalty cannot be less than penalty per unit."
redirect_to action: 'edit', id: params[:id]
elsif valid[:policy_name_already_exists]
flash[:error] = "Cannot edit the policy. A policy with the same name " + params[:late_policy][:policy_name] + " already exists."
redirect_to action: 'edit', id: params[:id]
end
end
</pre>

=== Issue 3 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T07:04:52Z

Adas9: /* Introduction */

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T03:35:43Z

Adas9: /* Modifications made to student_quizzes_controller */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc)[https://github.com/expertiza/expertiza Expertiza on GitHub] [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Wiki Page]. It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the StudentQuiz controller and LatePolicies Controller. In this Wiki Page, we would be explaining the changes that we have made for the same.

== Modifications made to student_quizzes_controller ==
=== Line 23 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Line 24 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Line 28 ===
----
Method: finished_quiz

The code under consideration is the following <pre>@participant = AssignmentTeam.find(@map.reviewee_id).participants.first</pre>

We get the first participant from the list of participants from AssignmentTeam, which is stored in the variable @participant. Therefore no refactor is required for this issue.

=== Line 34 ===
----
Updated the method comment to better explain its purpose. 
Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Lines 53-96 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Line 98 ===
----
Added method comment to record response to describe its purpose. 
Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Line 108 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Line 110 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Line 119 ===
----
Update the method comment to better describe review_questions. 
Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

== Modifications made to late_policies_controller ==

=== Issue 1 ===
----
< Add description here >

=== Issue 2 ===
----
< Add description here >

=== Issue 3 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T02:32:38Z

Adas9:

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc)[https://github.com/expertiza/expertiza Expertiza on GitHub] [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Wiki Page]. It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the StudentQuiz controller and LatePolicies Controller. In this Wiki Page, we would be explaining the changes that we have made for the same.

== Modifications made to student_quizzes_controller ==
=== Line 23 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Line 24 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Line 34 ===
----
Updated the method comment to better explain its purpose. 
Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Lines 53-96 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Line 98 ===
----
Added method comment to record response to describe its purpose. 
Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Line 108 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Line 110 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Line 119 ===
----
Update the method comment to better describe review_questions. 
Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

== Modifications made to late_policies_controller ==

=== Issue 1 ===
----
< Add description here >

=== Issue 2 ===
----
< Add description here >

=== Issue 3 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T02:30:55Z

Adas9: /* Line 34 */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc)[https://github.com/expertiza/expertiza Expertiza on GitHub] [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Wiki Page]. It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the StudentQuiz controller and LatePolicies Controller. In this Wiki Page, we would be explaining the changes that we have made for the same.

== Modifications made to student_quizzes_controller ==
=== Line 23 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Line 24 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
 Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Line 34 ===
----
Updated the method comment to better explain its purpose. 
Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Lines 53-96 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Line 98 ===
----
Added method comment to record response to describe its purpose. 

Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Line 108 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Line 110 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
 Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Line 119 ===
----
Update the method comment to better describe review_questions. 

Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

== Modifications made to late_policies_controller ==

=== Issue 1 ===
----
< Add description here >

=== Issue 2 ===
----
< Add description here >

=== Issue 3 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T02:30:20Z

Adas9: /* Modifications made to student_quizzes_controller */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc)[https://github.com/expertiza/expertiza Expertiza on GitHub] [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Wiki Page]. It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the StudentQuiz controller and LatePolicies Controller. In this Wiki Page, we would be explaining the changes that we have made for the same.

== Modifications made to student_quizzes_controller ==
=== Line 23 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Line 24 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
 Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Line 34 ===
----
Updated the method comment to better explain its purpose. 

Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Lines 53-96 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Line 98 ===
----
Added method comment to record response to describe its purpose. 

Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Line 108 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Line 110 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
 Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Line 119 ===
----
Update the method comment to better describe review_questions. 

Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

== Modifications made to late_policies_controller ==

=== Issue 1 ===
----
< Add description here >

=== Issue 2 ===
----
< Add description here >

=== Issue 3 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T02:23:27Z

Adas9: /* Line 108 */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc)[https://github.com/expertiza/expertiza Expertiza on GitHub] [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Wiki Page]. It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the StudentQuiz controller and LatePolicies Controller. In this Wiki Page, we would be explaining the changes that we have made for the same.

== Modifications made to student_quizzes_controller ==
=== Line 24 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
 Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Line 110 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
 Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Line 98 ===
----
Added method comment to record response to describe its purpose. 

Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Line 34 ===
----
Updated the method comment to better explain its purpose. 

Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Line 23 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Line 119 ===
----
Update the method comment to better describe review_questions. 

Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

=== Line 53-96 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Line 108 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

== Modifications made to late_policies_controller ==

=== Issue 1 ===
----
< Add description here >

=== Issue 2 ===
----
< Add description here >

=== Issue 3 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T02:23:19Z

Adas9: /* Line 53-96 */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc)[https://github.com/expertiza/expertiza Expertiza on GitHub] [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Wiki Page]. It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the StudentQuiz controller and LatePolicies Controller. In this Wiki Page, we would be explaining the changes that we have made for the same.

== Modifications made to student_quizzes_controller ==
=== Line 24 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
 Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Line 110 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
 Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Line 98 ===
----
Added method comment to record response to describe its purpose. 

Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Line 34 ===
----
Updated the method comment to better explain its purpose. 

Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Line 23 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Line 119 ===
----
Update the method comment to better describe review_questions. 

Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

=== Line 53-96 ===
----
As the method calculate_score has not yet been completed, skipping this issue, as directed by Professor Gehringer.

=== Line 108 ===
----
< Add description here >

== Modifications made to late_policies_controller ==

=== Issue 1 ===
----
< Add description here >

=== Issue 2 ===
----
< Add description here >

=== Issue 3 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T02:20:13Z

Adas9: /* Line 119 */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc)[https://github.com/expertiza/expertiza Expertiza on GitHub] [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Wiki Page]. It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the StudentQuiz controller and LatePolicies Controller. In this Wiki Page, we would be explaining the changes that we have made for the same.

== Modifications made to student_quizzes_controller ==
=== Line 24 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
 Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Line 110 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
 Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Line 98 ===
----
Added method comment to record response to describe its purpose. 

Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Line 34 ===
----
Updated the method comment to better explain its purpose. 

Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Line 23 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Line 119 ===
----
Update the method comment to better describe review_questions. 

Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

=== Line 53-96 ===
----
< Add description here >

=== Line 108 ===
----
< Add description here >

== Modifications made to late_policies_controller ==

=== Issue 1 ===
----
< Add description here >

=== Issue 2 ===
----
< Add description here >

=== Issue 3 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T02:18:22Z

Adas9: /* Line 23 */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc)[https://github.com/expertiza/expertiza Expertiza on GitHub] [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Wiki Page]. It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the StudentQuiz controller and LatePolicies Controller. In this Wiki Page, we would be explaining the changes that we have made for the same.

== Modifications made to student_quizzes_controller ==
=== Line 24 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
 Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Line 110 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
 Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Line 98 ===
----
Added method comment to record response to describe its purpose. 

Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Line 34 ===
----
Updated the method comment to better explain its purpose. 

Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Line 23 ===
----
Added a method comment to better describe the purpose of finished_quiz method. 
Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Line 119 ===
----
< Add description here >
 Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

=== Line 53-96 ===
----
< Add description here >

=== Line 108 ===
----
< Add description here >

== Modifications made to late_policies_controller ==

=== Issue 1 ===
----
< Add description here >

=== Issue 2 ===
----
< Add description here >

=== Issue 3 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T02:16:30Z

Adas9: /* Line 34 */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc)[https://github.com/expertiza/expertiza Expertiza on GitHub] [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Wiki Page]. It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the StudentQuiz controller and LatePolicies Controller. In this Wiki Page, we would be explaining the changes that we have made for the same.

== Modifications made to student_quizzes_controller ==
=== Line 24 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
 Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Line 110 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
 Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Line 98 ===
----
Added method comment to record response to describe its purpose. 

Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Line 34 ===
----
Updated the method comment to better explain its purpose. 

Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Line 23 ===
----
< Add description here >
 Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Line 119 ===
----
< Add description here >
 Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

=== Line 53-96 ===
----
< Add description here >

=== Line 108 ===
----
< Add description here >

== Modifications made to late_policies_controller ==

=== Issue 1 ===
----
< Add description here >

=== Issue 2 ===
----
< Add description here >

=== Issue 3 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T02:14:40Z

Adas9: /* Line 98 */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc)[https://github.com/expertiza/expertiza Expertiza on GitHub] [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Wiki Page]. It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the StudentQuiz controller and LatePolicies Controller. In this Wiki Page, we would be explaining the changes that we have made for the same.

== Modifications made to student_quizzes_controller ==
=== Line 24 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
 Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Line 110 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
 Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Line 98 ===
----
Added method comment to record response to describe its purpose. 

Method : record_response

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Line 34 ===
----
< Add description here >
 Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Line 23 ===
----
< Add description here >
 Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Line 119 ===
----
< Add description here >
 Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

=== Line 53-96 ===
----
< Add description here >

=== Line 108 ===
----
< Add description here >

== Modifications made to late_policies_controller ==

=== Issue 1 ===
----
< Add description here >

=== Issue 2 ===
----
< Add description here >

=== Issue 3 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T02:12:36Z

Adas9: /* Line 24 */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc)[https://github.com/expertiza/expertiza Expertiza on GitHub] [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Wiki Page]. It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the StudentQuiz controller and LatePolicies Controller. In this Wiki Page, we would be explaining the changes that we have made for the same.

== Modifications made to student_quizzes_controller ==
=== Line 24 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times. 
 Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Line 110 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
 Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Line 98 ===
----
< Add description here >

Method : calculate_score

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Line 34 ===
----
< Add description here >
 Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Line 23 ===
----
< Add description here >
 Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Line 119 ===
----
< Add description here >
 Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

=== Line 53-96 ===
----
< Add description here >

=== Line 108 ===
----
< Add description here >

== Modifications made to late_policies_controller ==

=== Issue 1 ===
----
< Add description here >

=== Issue 2 ===
----
< Add description here >

=== Issue 3 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T02:12:17Z

Adas9: /* Line 110 */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc)[https://github.com/expertiza/expertiza Expertiza on GitHub] [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Wiki Page]. It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the StudentQuiz controller and LatePolicies Controller. In this Wiki Page, we would be explaining the changes that we have made for the same.

== Modifications made to student_quizzes_controller ==
=== Line 24 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times.
 Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Line 110 ===
----
Fixed the english of the flash message as the word records was ambiguous. 
 Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Line 98 ===
----
< Add description here >

Method : calculate_score

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Line 34 ===
----
< Add description here >
 Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Line 23 ===
----
< Add description here >
 Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Line 119 ===
----
< Add description here >
 Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

=== Line 53-96 ===
----
< Add description here >

=== Line 108 ===
----
< Add description here >

== Modifications made to late_policies_controller ==

=== Issue 1 ===
----
< Add description here >

=== Issue 2 ===
----
< Add description here >

=== Issue 3 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T02:10:04Z

Adas9: /* Line 24 */

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc)[https://github.com/expertiza/expertiza Expertiza on GitHub] [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Wiki Page]. It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the StudentQuiz controller and LatePolicies Controller. In this Wiki Page, we would be explaining the changes that we have made for the same.

== Modifications made to student_quizzes_controller ==
=== Line 24 ===
----
Updated the query from .first to .last as we want to get the latest score and not the first score, in the case a team/student submitted the quiz multiple times.
 Method : finished_quiz 
Before Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Line 110 ===
----
< Add description here >
 Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Line 98 ===
----
< Add description here >

Method : calculate_score

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Line 34 ===
----
< Add description here >
 Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Line 23 ===
----
< Add description here >
 Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Line 119 ===
----
< Add description here >
 Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

=== Line 53-96 ===
----
< Add description here >

=== Line 108 ===
----
< Add description here >

== Modifications made to late_policies_controller ==

=== Issue 1 ===
----
< Add description here >

=== Issue 2 ===
----
< Add description here >

=== Issue 3 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-21T01:57:46Z

Adas9:

This wiki page is for the description of changes made under E2128 OSS assignment for Fall 2021, CSC/ECE 517.
__TOC__
==Introduction==
Expertiza is a web application developed using Ruby on Rails that serves as a peer-review system. The application allows students to submit and peer-review learning objects (articles, code, websites, etc)[https://github.com/expertiza/expertiza Expertiza on GitHub] [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Wiki Page]. It is an open-source project and its codebase is maintained on GitHub. We are contributing to Expertiza as a part of our Object-Oriented Design and Development's Open-Source Software (OSS) Project. Our goal in this project is to refactor the StudentQuiz controller and LatePolicies Controller. In this Wiki Page, we would be explaining the changes that we have made for the same.

== Modifications made to student_quizzes_controller ==
=== Line 24 ===
----
< Add description here > 
Before Refactoring
 Method : finished_quiz

<pre> @response = Response.where(map_id: params[:map_id]).first </pre>

After Refactoring

<pre> @response = Response.where(map_id: params[:map_id]).last # Get the last score if a student took a quiz multiple times </pre>

=== Line 110 ===
----
< Add description here >
 Method : record_response 
Before Refactoring

<pre> flash[:error] = "You have already taken this quiz, below are the records for your responses." </pre>

After Refactoring

<pre> flash[:error] = "You have already taken this quiz. Please find your previous submission below." </pre>

=== Line 98 ===
----
< Add description here >

Method : calculate_score

After Refactoring

<pre> # Saves the response by the student only if the student has not taken the quiz before. </pre>

=== Line 34 ===
----
< Add description here >
 Method : self.take_quiz 
Before Refactoring

<pre> # Create an array of candidate quizzes for current reviewer </pre>

After Refactoring

<pre> # Returns an array of candidate quizzes for current reviewer </pre>

=== Line 23 ===
----
< Add description here >
 Method : finished_quiz 

After Refactoring

<pre> # Gets the last submission for a quiz by a student </pre>

=== Line 119 ===
----
< Add description here >
 Method : review_questions 

Before Refactoring

<pre> # This method is only for quiz questionnaires, it is called when instructors click "view quiz questions" on the pop-up panel. </pre>

After Refactoring

<pre> # Gets all the questionnaire responses by all the teams for a particular assignment </pre>

=== Line 53-96 ===
----
< Add description here >

=== Line 108 ===
----
< Add description here >

== Modifications made to late_policies_controller ==

=== Issue 1 ===
----
< Add description here >

=== Issue 2 ===
----
< Add description here >

=== Issue 3 ===
----
< Add description here >

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-20T06:58:23Z

Adas9:

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-20T06:57:06Z

Adas9:

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-13T21:23:49Z

Adas9:

CSC/ECE 517 Fall 2021 - E2128. Refactor student quizzes controller.rb & late policies controller.rb

2021-10-13T21:22:09Z

Adas9: