Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-30T01:21:45Z

Aamajumd: /* Description about project */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 23.08% coverage

* teammate_review_response_map.rb <- no coverage

* response_map.rb <----------------- 74.47% coverage

This project aims to get all the response maps to at least a 80% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
Currently this file is 92.5% covered and there are no plans to cover it further.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We will test if this string is the same as typed out.

<pre>
def get_title
"Metareview"
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We will test that the information is properly exported to the csv file.<br>
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We will test to see that these three columns are properly returned.<br>
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview.<br>
[[File:E2170-import.jpg]]

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We will test to make sure the email is sent to the correct participant.<br>
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

<pre>
def get_title
"Teammate Review"
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID.

<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate.

<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>

==== comparator ====
Compares two Responses version numbers and returns a -1,0, or 1 depending on which version number is greater. If there is no version number for the first response, -1 is returned, otherwise 1 is returned.

<pre>
def comparator(m1, m2)
if m1.version_num and m2.version_num
m2.version_num <=> m1.version_num
elsif m1.version_num
-1
else
1
end
end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.

<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review).

<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec ./spec/models/<test file name>
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-14T20:20:14Z

Aamajumd: /* Description about project */

== Description about project ==
This page is a description of Expertiza final project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 23.08% coverage

* teammate_review_response_map.rb <- no coverage

* response_map.rb <----------------- 74.47% coverage

This project aims to get all the response maps to at least a 90% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
Currently this file is 92.5% covered and there are no plans to cover it further.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We will test if this string is the same as typed out.

<pre>
def get_title
"Metareview"
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We will test that the information is properly exported to the csv file.<br>
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We will test to see that these three columns are properly returned.<br>
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview.<br>
[[File:E2170-import.jpg]]

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We will test to make sure the email is sent to the correct participant.<br>
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

<pre>
def get_title
"Teammate Review"
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID.

<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate.

<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>

==== comparator ====
Compares two Responses version numbers and returns a -1,0, or 1 depending on which version number is greater. If there is no version number for the first response, -1 is returned, otherwise 1 is returned.

<pre>
def comparator(m1, m2)
if m1.version_num and m2.version_num
m2.version_num <=> m1.version_num
elsif m1.version_num
-1
else
1
end
end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.

<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review).

<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec ./spec/models/<test file name>
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-14T20:02:44Z

Aamajumd: /* Running Tests */

== Description about project ==
This page is a description of Expertiza OSS project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 23.08% coverage

* teammate_review_response_map.rb <- no coverage

* response_map.rb <----------------- 74.47% coverage

This project aims to get all the response maps to at least a 90% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
Currently this file is 92.5% covered and there are no plans to cover it further.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We will test if this string is the same as typed out.

<pre>
def get_title
"Metareview"
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We will test that the information is properly exported to the csv file.<br>
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We will test to see that these three columns are properly returned.<br>
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview.<br>
[[File:E2170-import.jpg]]

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We will test to make sure the email is sent to the correct participant.<br>
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'TeammateReviewQuestionnaire')
end
</pre>

==== get_title ====
This function returns the string "Teammate Review".

<pre>
def get_title
"Teammate Review"
end
</pre>

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID.

<pre>
def self.teammate_response_report(id)
TeammateReviewResponseMap.select("DISTINCT reviewer_id").where("reviewed_object_id = ?", id)
end
</pre>

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate.

<pre>
# Send Teammate Review Emails
# Refactored from email method in response.rb
def email(defn, participant, assignment)
defn[:body][:type] = "Teammate Review"
participant = AssignmentParticipant.find(reviewee_id)
topic_id = SignedUpTeam.topic_id(participant.parent_id, participant.user_id)
defn[:body][:obj_name] = assignment.name
user = User.find(participant.user_id)
defn[:body][:first_name] = user.fullname
defn[:to] = user.email
Mailer.sync_message(defn).deliver
end
</pre>

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]
<pre>
# return latest versions of the responses
def self.assessments_for(team)
responses = []
# stime = Time.now
if team
@array_sort = []
@sort_to = []
maps = where(reviewee_id: team.id)
maps.each do |map|
next if map.response.empty?
@all_resp = Response.where(map_id: map.map_id).last
if map.type.eql?('ReviewResponseMap')
# If its ReviewResponseMap then only consider those response which are submitted.
@array_sort << @all_resp if @all_resp.is_submitted
else
@array_sort << @all_resp
end
# sort all versions in descending order and get the latest one.
# @sort_to=@array_sort.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@sort_to = @array_sort.sort # { |m1, m2| (m1.updated_at and m2.updated_at) ? m2.updated_at <=> m1.updated_at : (m1.version_num ? -1 : 1) }
responses << @sort_to[0] unless @sort_to[0].nil?
@array_sort.clear
@sort_to.clear
end
responses = responses.sort {|a, b| a.map.reviewer.fullname <=> b.map.reviewer.fullname }
end
responses
end
</pre>

==== comparator ====
Compares two Responses version numbers and returns a -1,0, or 1 depending on which version number is greater. If there is no version number for the first response, -1 is returned, otherwise 1 is returned.

<pre>
def comparator(m1, m2)
if m1.version_num and m2.version_num
m2.version_num <=> m1.version_num
elsif m1.version_num
-1
else
1
end
end
</pre>

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.

<pre>
# return latest versions of the response given by reviewer
def self.reviewer_assessments_for(team, reviewer)
# get_reviewer may return an AssignmentParticipant or an AssignmentTeam
map = where(reviewee_id: team.id, reviewer_id: reviewer.get_reviewer.id)
Response.where(map_id: map).sort {|m1, m2| self.comparator(m1, m2) }[0]
end
</pre>

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed
<pre>
# Evaluates whether this response_map was metareviewed by metareviewer
# @param[in] metareviewer AssignmentParticipant object
def metareviewed_by?(metareviewer)
MetareviewResponseMap.where(reviewee_id: self.reviewer.id, reviewer_id: metareviewer.id, reviewed_object_id: self.id).count > 0
end
</pre>

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review).

<pre>
# Assigns a metareviewer to this review (response)
# @param[in] metareviewer AssignmentParticipant object
def assign_metareviewer(metareviewer)
MetareviewResponseMap.create(reviewed_object_id: self.id,
reviewer_id: metareviewer.id, reviewee_id: reviewer.id)
end
</pre>

==== find_team_member ====
This function returns the team that the reviewer is part of.

<pre>
def find_team_member
# ACS Have metareviews done for all teams
if self.type.to_s == "MetareviewResponseMap"
review_mapping = ResponseMap.find_by(id: map.reviewed_object_id)
team = AssignmentTeam.find_by(id: review_mapping.reviewee_id)
else
team = AssignmentTeam.find(self.reviewee_id)
end
end
</pre>

== Running Tests ==

<pre>
rspec ./spec/models/<test file name>
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-09T03:28:00Z

Aamajumd: /* metareview_response_map_spec.rb */

== Description about project ==
This page is a description of Expertiza OSS project E2170 which aims to adequately test several files regarding the ResponseMap model. Here is a description of what response maps do:
*In Expertiza, response maps establish a relationship between a reviewer, a reviewee, and an object to be reviewed. The reviewer is an assignment_participant, the reviewee is an assignment_team, and the reviewed object is either an assignment or another response_map. Each (reviewer, reviewee) pair will have a separate response map. Every time a new review is performed (e.g, every round), a new Response object is created whose map_id is that response map.

The breakdown of the ResponseMap model can be found [https://expertiza.csc.ncsu.edu/index.php/Response_maps here]. There are several types of ResponseMaps that extend functionality of the original ResponseMap. None of which including the superclass are adequately tested. These files include:

* review_response_map.rb <--------- 92.5% coverage

* metareview_response_map.rb <------ 23.08% coverage

* teammate_review_response_map.rb <- no coverage

* response_map.rb <----------------- 74.47% coverage

This project aims to get all the response maps to at least a 90% level of coverage for every Response Map file by writing unit tests for each uncovered method listed in the next section.

== Team ==

* Connor Smith (cpsmith6)

* Abir Majumder (aamajumd)

* Quinn Dibble (qdibble)

* Alex Carruth (agcarrut)

== Test Files Involved ==
There are 4 test files involved in this project:
* review_response_map_spec.rb

* metareview_response_map_spec.rb

* teammate_review_response_map_spec.rb

* response_map_spec.rb
of these files, only review_response_map_spec.rb currently exists; the rest will be added.

== Methods Tested Per File ==

=== review_response_map_spec.rb ===
Currently this file is 92.5% covered and there are no plans to cover it further.

=== metareview_response_map_spec.rb ===
The functions for metareview_response_map.rb that will be tested are:
====get_all_versions====
This returns a sorted array of all the different versions of what is being reviewed in this response map. This means for a test, we will need to create a reviewer, a reviewee, several types of reviews of different versions to be sorted correctly.

<pre>
# return all the versions available for a response map.
# a person who is doing meta review has to be able to see all the versions of review.
def get_all_versions
if self.review_mapping.response
@sorted_array = []
@prev = Response.all
@prev.each do |element|
@sorted_array << element if element.map_id == self.review_mapping.map_id
end
@sorted = @sorted_array.sort {|m1, m2| m1.version_num || if m2.version_num
m1.version_num <=> m2.version_num
else
m1.version_num ? -1 : 1
end }
# return all the lists in ascending order.
@sorted
end
end
</pre>

====contributor====
Returns the team associated with the ReviewResponseMap that is to be metareviewed. We will need to create a ReviewResponseMap that has a team associated with it. Then we must create MetareviewResponseMap that points to a created ReviewResponseMap via the reviewed_object_id attribute. We will test if it indeed returns the team associated with ReviewResponseMap.

<pre>
# First, find the "ReviewResponseMap" to be metareviewed;
# Second, find the team in the "ReviewResponseMap" record.
def contributor
team_review_map = ReviewResponseMap.find(self.reviewed_object_id)
AssignmentTeam.find(team_review_map.reviewee_id)
end
</pre>

====questionnaire====
Returns all questionnaires associated to the assignment of this MetareviewResponseMap that is of type 'MetareviewQuestionnaire'. We will need to create a valid MetareviewResponseMap including at least one MetareviewQuestionnaire that can be returned.

<pre>
def questionnaire
self.assignment.questionnaires.find_by(type: 'MetareviewQuestionnaire')
end
</pre>

====get_title====
Returns string "Metareview". We will test if this string is the same as typed out.

<pre>
def get_title
"Metareview"
end
</pre>

====exports====
This function takes 3 parameters: csv (the csv file that will contain the exported metareview information), parent_id (the assignment ID containing the requested metareviews), and _options. The function sends all the information about the metareviews to a csv file. We will test that the information is properly exported to the csv file.<br>
<pre>
def self.export(csv, parent_id, _options)
mappings = Assignment.find(parent_id).metareview_mappings
mappings = mappings.sort_by {|a| [a.review_mapping.reviewee.name, a.reviewee.name, a.reviewer.name] }
mappings.each do |map|
csv << [
map.review_mapping.reviewee.name,
map.reviewee.name,
map.reviewer.name
]
end
end
</pre>

====export_fields====
Takes a parameter called "_options" that returns the three field columns associated with metareviews to be exported for use by other controllers. We will test to see that these three columns are properly returned.<br>
<pre>
def self.export_fields(_options)
fields = ["contributor", "reviewed by", "metareviewed by"]
fields
end
</pre>

====import====
This function takes 3 parameters: row_hash (represents the hash of the metareview data we want to import), session, and id (representing the id of the assignment we want to import metareview data for). The function imports the data from the hash map, and if the information is input correctly, the data is extracted from the hash and creates a metareview for the requested assignment, otherwise it flashes an error saying the data was input incorrectly. We will test to make sure the imported data is properly converted into a metareview.<br>
[[File:E2170-import.jpg]]

====email====
This function takes 3 parameters: defn, _participant (the user who will be receiving the email), and assignment (the assignment associated with the metareview). The function sends an email to the participant when they have a new metareview to complete. We will test to make sure the email is sent to the correct participant.<br>
<pre>
def email(defn, _participant, assignment)
defn[:body][:type] = "Metareview"
reviewee_user = Participant.find(reviewee_id)
defn[:body][:obj_name] = assignment.name
defn[:body][:first_name] = User.find(reviewee_user.user_id).fullname
defn[:to] = User.find(reviewee_user.user_id).email
Mailer.sync_message(defn).deliver
end
</pre>

=== teammate_review_response_map_spec.rb ===
The functions for teammate_review_response_map.rb that will be tested are:
==== questionnaire ====
This function searches for a TeammateReviewQuestionnaire object and returns it.

[[File:E2170-teammate review response map-questionnaire.PNG]]

==== get_title ====
This function returns the string "Teammate Review".

[[File:E2170-teammate_review_response_map-get_title.png]]

==== teammate_response_report ====
This function returns the teammate response report given the reviewer ID.

[[File:E2170-teammate_review_response_map-teammate_response_report.PNG]]

==== email ====
This function sends a notification email to a student who has been reviewed by their teammate.

[[File:E2170-teammate_review_response_map-email.png]]

=== response_map_spec.rb ===
The functions for response_map.rb that will be tested are:
==== self.assessments_for(team) ====
Gets all submitted Review Responses or all regular Responses for a team, sorts the responses by version, and returns the latest Responses.

[[File:E2170-assessments_for.png]]

==== comparator ====
Compares two Responses version numbers and returns a -1,0, or 1 depending on which version number is greater. If there is no version number for the first response, -1 is returned, otherwise 1 is returned.

[[File:E2170-comparator.png]]

==== self.reviewer_assessments_for(team, reviewer) ====
Gets the Responses for a team reviewed by a specific reviewer and returns the latest response.

[[File:E2170-reviewer_assessments_for.png]]

==== metareviewed_by? ====
Returns whether the Response Map has been metareviewed

[[File:E2170-metareviewed_by.png]]

==== assign_metareviewer ====
This function is in charge of assigning a metareviewer to this review (i.e. a reviewer to review the review).

[[File:E2170-response_map-assign_metareviewer.png]]

==== find_team_member ====
This function returns the team that the reviewer is part of.

[[File:E2170-response_map-find_team_member.png]]

== Running Tests ==

<pre>
rspec ./spec/controllers/<test file name>
</pre>

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-08T20:31:36Z

Aamajumd: /* Methods Tested Per File */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-08T20:30:18Z

Aamajumd: /* metareview_response_map_spec.rb */

File:E2170-get title.PNG

2021-11-08T20:29:57Z

Aamajumd:

File:E2170-questionnaire.PNG

2021-11-08T20:29:33Z

Aamajumd:

File:E2170-get all versions.PNG

2021-11-08T20:29:03Z

Aamajumd:

File:E2170-contributor.PNG

2021-11-08T20:27:16Z

Aamajumd:

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-08T20:11:16Z

Aamajumd: /* metareview_response_map_spec.rb */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-08T19:13:48Z

Aamajumd: /* Description of modifications/additions */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-08T19:10:53Z

Aamajumd: /* Description about project */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-02T21:07:11Z

Aamajumd: /* Description about project */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-02T21:06:59Z

Aamajumd: /* Description about project */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-02T17:10:04Z

Aamajumd:

CSC/ECE 517 Fall 2021

2021-11-01T18:58:45Z

Aamajumd: /* Final Projects */

== OSS Projects ==

* [[CSC/ECE 517 Fall 2021 - E2117. Refactor questionaires_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2128. Refactor student_quizzes_controller.rb & late_policies_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2129. Refactor auth_controller.rb & password_retrieval_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2132. Add tests cases for review mapping helper.rb]]
* [[CSC/ECE 517 Fall 2021 - E2134. Write unit tests for admin_controller.rb and institution_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2138. Auto-generate submission directory names based on assignment]]
* [[CSC/ECE 517 Fall 2021 - E2142. Improve e-mail notifications]]
* [[CSC/ECE 517 Fall 2021 - E2133. Write tests for popup_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2120. Refactor reputation_web_service_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2139. Remove multiple topics at a time]]
* [[CSC/ECE 517 Fall 2021 - E2131. Improve assessment360_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2121. Refactor suggestion_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2122. Refactor impersonate_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2123. Refactor sign_up_sheet_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2126. Refactor account_request_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2124. Refactor review_mapping_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2125. Refactor review_mapping_helper.rb]]
* [[CSC/ECE 517 Fall 2021 - E2127. Refactor teams_controller]]
* [[CSC/ECE 517 Fall 2021 - E2130. Refactor submitted_content_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2140. Create new late policy successfully and fix Bank link]]
* [[CSC/ECE 517 Fall 2021 - E2141. OSS project Finklestein: Instructors & Institutions]]
* [[CSC/ECE 517 Fall 2021 - E2144. Refactor delayed mailer and scheduled task]]
* [[CSC/ECE 517 Fall 2021 - E2147. Role-based reviewing]]
* [[CSC/ECE 517 Fall 2021 - E2145. OSS Project Beige]]
* [[CSC/ECE 517 Fall 2021 - E2146. Introduce a Student View for instructors]]
* [[CSC/ECE 517 Fall 2021 - Refactor Evaluation of SQL Queries]]
* [[CSC/ECE 517 Fall 2021 - E2135. Email notification to reviewers and instructors]]
* [[CSC/ECE 517 Fall 2021 - E2168. Testing - Reputations]]
* [[CSC/ECE 517 Fall 2021 - E2166. Testing - Scoring & Grades]]
* [[CSC/ECE 517 Fall 2021 - E2149. Finish Github metrics integration - Reputations]]
* [[CSC/ECE 517 Fall 2021 - E2161. Merge code for role-based reviewing with code for topic-specific rubrics]]

== Final Projects ==
* [https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Fall_2021_-_E2170._Testing_-_Response_Maps#Description_about_project CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps]

CSC/ECE 517 Fall 2021

2021-11-01T18:58:03Z

Aamajumd: /* Final Projects */

== OSS Projects ==

* [[CSC/ECE 517 Fall 2021 - E2117. Refactor questionaires_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2128. Refactor student_quizzes_controller.rb & late_policies_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2129. Refactor auth_controller.rb & password_retrieval_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2132. Add tests cases for review mapping helper.rb]]
* [[CSC/ECE 517 Fall 2021 - E2134. Write unit tests for admin_controller.rb and institution_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2138. Auto-generate submission directory names based on assignment]]
* [[CSC/ECE 517 Fall 2021 - E2142. Improve e-mail notifications]]
* [[CSC/ECE 517 Fall 2021 - E2133. Write tests for popup_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2120. Refactor reputation_web_service_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2139. Remove multiple topics at a time]]
* [[CSC/ECE 517 Fall 2021 - E2131. Improve assessment360_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2121. Refactor suggestion_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2122. Refactor impersonate_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2123. Refactor sign_up_sheet_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2126. Refactor account_request_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2124. Refactor review_mapping_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2125. Refactor review_mapping_helper.rb]]
* [[CSC/ECE 517 Fall 2021 - E2127. Refactor teams_controller]]
* [[CSC/ECE 517 Fall 2021 - E2130. Refactor submitted_content_controller.rb]]
* [[CSC/ECE 517 Fall 2021 - E2140. Create new late policy successfully and fix Bank link]]
* [[CSC/ECE 517 Fall 2021 - E2141. OSS project Finklestein: Instructors & Institutions]]
* [[CSC/ECE 517 Fall 2021 - E2144. Refactor delayed mailer and scheduled task]]
* [[CSC/ECE 517 Fall 2021 - E2147. Role-based reviewing]]
* [[CSC/ECE 517 Fall 2021 - E2145. OSS Project Beige]]
* [[CSC/ECE 517 Fall 2021 - E2146. Introduce a Student View for instructors]]
* [[CSC/ECE 517 Fall 2021 - Refactor Evaluation of SQL Queries]]
* [[CSC/ECE 517 Fall 2021 - E2135. Email notification to reviewers and instructors]]
* [[CSC/ECE 517 Fall 2021 - E2168. Testing - Reputations]]
* [[CSC/ECE 517 Fall 2021 - E2166. Testing - Scoring & Grades]]
* [[CSC/ECE 517 Fall 2021 - E2149. Finish Github metrics integration - Reputations]]
* [[CSC/ECE 517 Fall 2021 - E2161. Merge code for role-based reviewing with code for topic-specific rubrics]]

== Final Projects ==
* [https://expertiza.csc.ncsu.edu/index.php/CSC/ECE_517_Fall_2021_-_E2170._Testing_-_Response_Maps#Description_about_project ECE 517 Fall 2021 - E2170. Testing - Response Maps]

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-01T18:57:11Z

Aamajumd: /* Description about project */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-01T18:55:52Z

Aamajumd: /* Description about project */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-01T18:54:40Z

Aamajumd: /* Description about project */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-01T18:47:35Z

Aamajumd: /* Description about project */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-01T18:47:04Z

Aamajumd: /* Test Files Involved */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-01T18:46:55Z

Aamajumd: /* Files Involved */

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-01T18:45:37Z

Aamajumd:

CSC/ECE 517 Fall 2021 - E2170. Testing - Response Maps

2021-11-01T18:41:06Z

Aamajumd: Created page with "== About Expertiza== [http://expertiza.ncsu.edu/ Expertiza] is an open source project based on [http://rubyonrails.org/ Ruby on Rails] framework that supports submission acro..."

== About Expertiza==

[http://expertiza.ncsu.edu/ Expertiza] is an open source project based on [http://rubyonrails.org/ Ruby on Rails] framework that supports submission across different document types, including theURLs and wiki pages. It allows the instructor not only to create and customize new or existing assignments but also to create a list of topics the students can sign up for. Students can form teams in Expertiza to work on various projects and assignments. Students can also peer review other students' submissions.

== Description about project ==
This page is a description of Expertiza OSS project E2126 which refactoring the account_request_controller.rb file. This file allows Super Administrators to manage the approval process for new users. Our job was to refactor some of the longer methods in this file, make error messages more intuitive, and add a security captcha when requesting the page to make a new user.

''DISCLAIMER:
*Some of the issues handed to us were already fixed when we looked at them from a previous project, so this page is only documenting the ones that we worked on. It can be assumed that the other undocumented issues are already done.
*'''THIS PROJECT IS NOT ABOUT MAKING A NEW USER.''' The purpose of the captcha is to verify if the user CAN BE REDIRECTED to the request new user page. The actual act of requesting a new user will error out due to some complications with the internal system's mailing system which is out of the scope of our assignments for this project. If you attempt to create a user, you are testing functionality that we were not assigned to fix.
''
=== Team ===

Connor Smith (cpsmith6)

Abir Majumder (aamajumd)

Joshua Myers (jamyers3)

=== Files Involved ===

account_request_controller.rb

=== Super Admin Login===

*Despite the username, this user is not an instructor. The role was changed in the database to give instructor6 super admin privileges.
Username: instructor6
Password: password

=== Running Tests ===

<pre>
rspec ./spec/controllers/account_request_controller.rb
</pre>

== Relevant Methods ==

* action_allowed?
* create_approved_user
* create_requested_user_record

=== action_allowed? ===

This method validates if the user is allowed to be redirected to the appropriate page. The task for this project is to add a captcha system before the user requests new. This happens when the user hits the "Request account" button on the login page. This project's repo already has the "recaptcha" gem installed. Future developers need to keep in mind that functionality of the captcha depends on the developer updating the site key and secret key of the Google ReCaptcha API. Installation instructions of the gem and integrating the recaptcha API key can be found [https://github.com/ambethia/recaptcha here].

There was one change to the frontend to display the captcha at _login.html.erb.

'''Front end change /app/views/_login.html.erb'''
<pre>
...
...
<% end %>
<p>

</p>
<br/>
</div>
<%= form_tag({:controller => 'account_request', :role => "Instructor", :action => 'new'}, :method => "get") do %>
<div>
<%= recaptcha_tags %> <------ Displays reCaptcha widget
</div>
<%= submit_tag "Request account", :class => 'btn btn-danger', :style => 'width:100%; margin-left:auto; margin-right:auto;' %>

<% end %>
<% end %>
</pre>

'''action_allowed? changes'''
<pre>
def action_allowed?
case params[:action]
when 'list_pending_requested'
current_user_has_admin_privileges?
when 'new'
verify_recaptcha <---- function provided by recaptcha gem; validates frontend recaptcha input
when 'create_requested_user_record'
true
when 'keys'
current_user_has_student_privileges?
else
current_user_has_ta_privileges?
end
end
</pre>

=== create_approved_user ===

This method allows a Super Admin to approve or reject new users, and gives them an error message if the incorrect steps are taken during that process.
<br>
====Login info:====
Username: instructor6 Password: password
<br>
There has been a database change where the role of instructor6 was bumped up to Super Admin.

==== Original Method ====
<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end
</pre>

==== Refactored Method ====

This method was refactored so the creation of the new user is handled in a separate method called '''"user_new"'''

<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
puts "Here"
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
user_new(requested_user)
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end

def user_new(requested_user)
puts requested_user.inspect
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
end
</pre>

=== create_requested_user_record ===

create_requested_user creates a new account request for a user (if they are not a duplicate user) so that it may be approved by a higher level user.

==== Original Method ====

<pre>
def create_requested_user_record

requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested

if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!

#
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects

user_existed = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
requested_user_saved = requested_user.save
#Stores a boolean value with respect to whether the user data is saved or not

if !user_existed and requested_user_saved
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
redirect_to '/instructions/home'
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful

return
elsif user_existed
flash[:error] = "The account you are requesting has already existed in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end
</pre>

==== Refactored Method ====

The new create_requested_user_record now only handles the different cases that can happen when a user requests an account (New user and request goes through, duplicate user and request doesn't go through, or some other error in the saving process. The new method save_requested_user creates the request object, validates it has all needed fields and tries to save it to the database. The new method notify_supers_new_request sends an email to the Super-Administrators that new user account request has been successfully created. Some variable names and error messages have been reworded to improve readability as well.

<pre>
def create_requested_user_record
requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested
user_exists = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
requested_user_saved = save_requested_user(requested_user, params)
#Stores a boolean value with respect to whether the user data is saved or not
if !user_exists and requested_user_saved
notify_supers_new_request(requested_user)
redirect_to '/instructions/home'
return
elsif user_exists
flash[:error] = "The account you are requesting already exists in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end

def save_requested_user(requested_user, params)
if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
return requested_user.save
end

def notify_supers_new_request(requested_user)
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful
end
</pre>

== Results ==

12 out of 12 tests in the account_request_controller_spec.rb test file.

Here is a image of our tests passing:<br>
[[File:Passing Test.jpg]]

=== Relevant Links ===

Main Expertiza Repository can be found [https://github.com/expertiza/expertiza here].

Our forked Repository can be found [https://github.com/majuabir/expertiza/tree/beta here].

Our pull request to the beta branch can be found [https://github.com/expertiza/expertiza/pull/2117 here].

CSC/ECE 517 Fall 2021

2021-11-01T17:59:05Z

Aamajumd: /* OSS Projects */

CSC/ECE 517 Fall 2021 - E2126. Refactor account request controller.rb

2021-10-30T19:48:43Z

Aamajumd: /* Relevant Links */

CSC/ECE 517 Fall 2021 - E2126. Refactor account request controller.rb

2021-10-28T15:16:54Z

Aamajumd: /* Description about project */

CSC/ECE 517 Fall 2021 - E2126. Refactor account request controller.rb

2021-10-25T20:59:07Z

Aamajumd: /* Login info: */

== About Expertiza==

[http://expertiza.ncsu.edu/ Expertiza] is an open source project based on [http://rubyonrails.org/ Ruby on Rails] framework that supports submission across different document types, including theURLs and wiki pages. It allows the instructor not only to create and customize new or existing assignments but also to create a list of topics the students can sign up for. Students can form teams in Expertiza to work on various projects and assignments. Students can also peer review other students' submissions.

== Description about project ==
This page is a description of Expertiza OSS project E2126 which refactoring the account_request_controller.rb file. This file allows Super Administrators to manage the approval process for new users. Our job was to refactor some of the longer methods in this file, make error messages more intuitive, and add a security captcha to the approval/rejection process.

''DISCLAIMER: Some of the issues handed to us were already fixed when we looked at them from a previous project, so this page is only documenting the ones that we worked on. It can be assumed that the other undocumented issues are already done.
''
=== Team ===

Connor Smith (cpsmith6)

Abir Majumder (aamajumd)

Joshua Myers (jamyers3)

=== Files Involved ===

account_request_controller.rb

=== Super Admin Login===

*Despite the username, this user is not an instructor. The role was changed in the database to give instructor6 super admin privileges.
Username: instructor6
Password: password

=== Running Tests ===

<pre>
rspec ./spec/controllers/account_request_controller.rb
</pre>

== Relevant Methods ==

* action_allowed?
* create_approved_user
* create_requested_user_record

=== action_allowed? ===

This method validates if the user is allowed to be redirected to the appropriate page. The task for this project is to add a captcha system before the user requests new. This happens when the user hits the "Request account" button on the login page. This project's repo already has the "recaptcha" gem installed. Future developers need to keep in mind that functionality of the captcha depends on the developer updating the site key and secret key of the Google ReCaptcha API. Installation instructions of the gem and integrating the recaptcha API key can be found [https://github.com/ambethia/recaptcha here].

There was one change to the frontend to display the captcha at _login.html.erb.

'''Front end change /app/views/_login.html.erb'''
<pre>
...
...
<% end %>
<p>

</p>
<br/>
</div>
<%= form_tag({:controller => 'account_request', :role => "Instructor", :action => 'new'}, :method => "get") do %>
<div>
<%= recaptcha_tags %> <------ Displays reCaptcha widget
</div>
<%= submit_tag "Request account", :class => 'btn btn-danger', :style => 'width:100%; margin-left:auto; margin-right:auto;' %>

<% end %>
<% end %>
</pre>

'''action_allowed? changes'''
<pre>
def action_allowed?
case params[:action]
when 'list_pending_requested'
current_user_has_admin_privileges?
when 'new'
verify_recaptcha <---- function provided by recaptcha gem; validates frontend recaptcha input
when 'create_requested_user_record'
true
when 'keys'
current_user_has_student_privileges?
else
current_user_has_ta_privileges?
end
end
</pre>

=== create_approved_user ===

This method allows a Super Admin to approve or reject new users, and gives them an error message if the incorrect steps are taken during that process.
<br>
====Login info:====
Username: instructor6 Password: password
<br>
There has been a database change where the role of instructor6 was bumped up to Super Admin.

==== Original Method ====
<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end
</pre>

==== Refactored Method ====

This method was refactored so the creation of the new user is handled in a separate method called '''"user_new"'''

<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
puts "Here"
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
user_new(requested_user)
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end

def user_new(requested_user)
puts requested_user.inspect
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
end
</pre>

=== create_requested_user_record ===

create_requested_user creates a new account request for a user (if they are not a duplicate user) so that it may be approved by a higher level user.

==== Original Method ====

<pre>
def create_requested_user_record

requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested

if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!

#
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects

user_existed = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
requested_user_saved = requested_user.save
#Stores a boolean value with respect to whether the user data is saved or not

if !user_existed and requested_user_saved
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
redirect_to '/instructions/home'
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful

return
elsif user_existed
flash[:error] = "The account you are requesting has already existed in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end
</pre>

==== Refactored Method ====

The new create_requested_user_record now only handles the different cases that can happen when a user requests an account (New user and request goes through, duplicate user and request doesn't go through, or some other error in the saving process. The new method save_requested_user creates the request object, validates it has all needed fields and tries to save it to the database. The new method notify_supers_new_request sends an email to the Super-Administrators that new user account request has been successfully created. Some variable names and error messages have been reworded to improve readability as well.

<pre>
def create_requested_user_record
requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested
user_exists = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
requested_user_saved = save_requested_user(requested_user, params)
#Stores a boolean value with respect to whether the user data is saved or not
if !user_exists and requested_user_saved
notify_supers_new_request(requested_user)
redirect_to '/instructions/home'
return
elsif user_exists
flash[:error] = "The account you are requesting already exists in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end

def save_requested_user(requested_user, params)
if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
return requested_user.save
end

def notify_supers_new_request(requested_user)
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful
end
</pre>

== Results ==

12 out of 12 tests in the account_request_controller_spec.rb test file.

Here is a image of our tests passing:<br>
[[File:Passing Test.jpg]]

=== Relevant Links ===

Main Expertiza Repository can be found [https://github.com/expertiza/expertiza here].

Our forked Repository can be found [https://github.com/majuabir/expertiza/tree/beta here].

CSC/ECE 517 Fall 2021 - E2126. Refactor account request controller.rb

2021-10-25T20:58:48Z

Aamajumd: /* Login info: */

== About Expertiza==

[http://expertiza.ncsu.edu/ Expertiza] is an open source project based on [http://rubyonrails.org/ Ruby on Rails] framework that supports submission across different document types, including theURLs and wiki pages. It allows the instructor not only to create and customize new or existing assignments but also to create a list of topics the students can sign up for. Students can form teams in Expertiza to work on various projects and assignments. Students can also peer review other students' submissions.

== Description about project ==
This page is a description of Expertiza OSS project E2126 which refactoring the account_request_controller.rb file. This file allows Super Administrators to manage the approval process for new users. Our job was to refactor some of the longer methods in this file, make error messages more intuitive, and add a security captcha to the approval/rejection process.

''DISCLAIMER: Some of the issues handed to us were already fixed when we looked at them from a previous project, so this page is only documenting the ones that we worked on. It can be assumed that the other undocumented issues are already done.
''
=== Team ===

Connor Smith (cpsmith6)

Abir Majumder (aamajumd)

Joshua Myers (jamyers3)

=== Files Involved ===

account_request_controller.rb

=== Super Admin Login===

*Despite the username, this user is not an instructor. The role was changed in the database to give instructor6 super admin privileges.
Username: instructor6
Password: password

=== Running Tests ===

<pre>
rspec ./spec/controllers/account_request_controller.rb
</pre>

== Relevant Methods ==

* action_allowed?
* create_approved_user
* create_requested_user_record

=== action_allowed? ===

This method validates if the user is allowed to be redirected to the appropriate page. The task for this project is to add a captcha system before the user requests new. This happens when the user hits the "Request account" button on the login page. This project's repo already has the "recaptcha" gem installed. Future developers need to keep in mind that functionality of the captcha depends on the developer updating the site key and secret key of the Google ReCaptcha API. Installation instructions of the gem and integrating the recaptcha API key can be found [https://github.com/ambethia/recaptcha here].

There was one change to the frontend to display the captcha at _login.html.erb.

'''Front end change /app/views/_login.html.erb'''
<pre>
...
...
<% end %>
<p>

</p>
<br/>
</div>
<%= form_tag({:controller => 'account_request', :role => "Instructor", :action => 'new'}, :method => "get") do %>
<div>
<%= recaptcha_tags %> <------ Displays reCaptcha widget
</div>
<%= submit_tag "Request account", :class => 'btn btn-danger', :style => 'width:100%; margin-left:auto; margin-right:auto;' %>

<% end %>
<% end %>
</pre>

'''action_allowed? changes'''
<pre>
def action_allowed?
case params[:action]
when 'list_pending_requested'
current_user_has_admin_privileges?
when 'new'
verify_recaptcha <---- function provided by recaptcha gem; validates frontend recaptcha input
when 'create_requested_user_record'
true
when 'keys'
current_user_has_student_privileges?
else
current_user_has_ta_privileges?
end
end
</pre>

=== create_approved_user ===

This method allows a Super Admin to approve or reject new users, and gives them an error message if the incorrect steps are taken during that process.
<br>
====Login info:====
Username: instructor6 Password: password
There has been a database change where the role of instructor6 was bumped up to Super Admin.

==== Original Method ====
<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end
</pre>

==== Refactored Method ====

This method was refactored so the creation of the new user is handled in a separate method called '''"user_new"'''

<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
puts "Here"
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
user_new(requested_user)
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end

def user_new(requested_user)
puts requested_user.inspect
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
end
</pre>

=== create_requested_user_record ===

create_requested_user creates a new account request for a user (if they are not a duplicate user) so that it may be approved by a higher level user.

==== Original Method ====

<pre>
def create_requested_user_record

requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested

if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!

#
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects

user_existed = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
requested_user_saved = requested_user.save
#Stores a boolean value with respect to whether the user data is saved or not

if !user_existed and requested_user_saved
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
redirect_to '/instructions/home'
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful

return
elsif user_existed
flash[:error] = "The account you are requesting has already existed in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end
</pre>

==== Refactored Method ====

The new create_requested_user_record now only handles the different cases that can happen when a user requests an account (New user and request goes through, duplicate user and request doesn't go through, or some other error in the saving process. The new method save_requested_user creates the request object, validates it has all needed fields and tries to save it to the database. The new method notify_supers_new_request sends an email to the Super-Administrators that new user account request has been successfully created. Some variable names and error messages have been reworded to improve readability as well.

<pre>
def create_requested_user_record
requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested
user_exists = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
requested_user_saved = save_requested_user(requested_user, params)
#Stores a boolean value with respect to whether the user data is saved or not
if !user_exists and requested_user_saved
notify_supers_new_request(requested_user)
redirect_to '/instructions/home'
return
elsif user_exists
flash[:error] = "The account you are requesting already exists in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end

def save_requested_user(requested_user, params)
if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
return requested_user.save
end

def notify_supers_new_request(requested_user)
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful
end
</pre>

== Results ==

12 out of 12 tests in the account_request_controller_spec.rb test file.

Here is a image of our tests passing:<br>
[[File:Passing Test.jpg]]

=== Relevant Links ===

Main Expertiza Repository can be found [https://github.com/expertiza/expertiza here].

Our forked Repository can be found [https://github.com/majuabir/expertiza/tree/beta here].

CSC/ECE 517 Fall 2021 - E2126. Refactor account request controller.rb

2021-10-25T20:58:31Z

Aamajumd: /* create_approved_user */

== About Expertiza==

[http://expertiza.ncsu.edu/ Expertiza] is an open source project based on [http://rubyonrails.org/ Ruby on Rails] framework that supports submission across different document types, including theURLs and wiki pages. It allows the instructor not only to create and customize new or existing assignments but also to create a list of topics the students can sign up for. Students can form teams in Expertiza to work on various projects and assignments. Students can also peer review other students' submissions.

== Description about project ==
This page is a description of Expertiza OSS project E2126 which refactoring the account_request_controller.rb file. This file allows Super Administrators to manage the approval process for new users. Our job was to refactor some of the longer methods in this file, make error messages more intuitive, and add a security captcha to the approval/rejection process.

''DISCLAIMER: Some of the issues handed to us were already fixed when we looked at them from a previous project, so this page is only documenting the ones that we worked on. It can be assumed that the other undocumented issues are already done.
''
=== Team ===

Connor Smith (cpsmith6)

Abir Majumder (aamajumd)

Joshua Myers (jamyers3)

=== Files Involved ===

account_request_controller.rb

=== Super Admin Login===

*Despite the username, this user is not an instructor. The role was changed in the database to give instructor6 super admin privileges.
Username: instructor6
Password: password

=== Running Tests ===

<pre>
rspec ./spec/controllers/account_request_controller.rb
</pre>

== Relevant Methods ==

* action_allowed?
* create_approved_user
* create_requested_user_record

=== action_allowed? ===

This method validates if the user is allowed to be redirected to the appropriate page. The task for this project is to add a captcha system before the user requests new. This happens when the user hits the "Request account" button on the login page. This project's repo already has the "recaptcha" gem installed. Future developers need to keep in mind that functionality of the captcha depends on the developer updating the site key and secret key of the Google ReCaptcha API. Installation instructions of the gem and integrating the recaptcha API key can be found [https://github.com/ambethia/recaptcha here].

There was one change to the frontend to display the captcha at _login.html.erb.

'''Front end change /app/views/_login.html.erb'''
<pre>
...
...
<% end %>
<p>

</p>
<br/>
</div>
<%= form_tag({:controller => 'account_request', :role => "Instructor", :action => 'new'}, :method => "get") do %>
<div>
<%= recaptcha_tags %> <------ Displays reCaptcha widget
</div>
<%= submit_tag "Request account", :class => 'btn btn-danger', :style => 'width:100%; margin-left:auto; margin-right:auto;' %>

<% end %>
<% end %>
</pre>

'''action_allowed? changes'''
<pre>
def action_allowed?
case params[:action]
when 'list_pending_requested'
current_user_has_admin_privileges?
when 'new'
verify_recaptcha <---- function provided by recaptcha gem; validates frontend recaptcha input
when 'create_requested_user_record'
true
when 'keys'
current_user_has_student_privileges?
else
current_user_has_ta_privileges?
end
end
</pre>

=== create_approved_user ===

This method allows a Super Admin to approve or reject new users, and gives them an error message if the incorrect steps are taken during that process.
<br>
==Login info:==
Username: instructor6 Password: password
There has been a database change where the role of instructor6 was bumped up to Super Admin.

==== Original Method ====
<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end
</pre>

==== Refactored Method ====

This method was refactored so the creation of the new user is handled in a separate method called '''"user_new"'''

<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
puts "Here"
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
user_new(requested_user)
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end

def user_new(requested_user)
puts requested_user.inspect
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
end
</pre>

=== create_requested_user_record ===

create_requested_user creates a new account request for a user (if they are not a duplicate user) so that it may be approved by a higher level user.

==== Original Method ====

<pre>
def create_requested_user_record

requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested

if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!

#
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects

user_existed = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
requested_user_saved = requested_user.save
#Stores a boolean value with respect to whether the user data is saved or not

if !user_existed and requested_user_saved
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
redirect_to '/instructions/home'
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful

return
elsif user_existed
flash[:error] = "The account you are requesting has already existed in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end
</pre>

==== Refactored Method ====

The new create_requested_user_record now only handles the different cases that can happen when a user requests an account (New user and request goes through, duplicate user and request doesn't go through, or some other error in the saving process. The new method save_requested_user creates the request object, validates it has all needed fields and tries to save it to the database. The new method notify_supers_new_request sends an email to the Super-Administrators that new user account request has been successfully created. Some variable names and error messages have been reworded to improve readability as well.

<pre>
def create_requested_user_record
requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested
user_exists = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
requested_user_saved = save_requested_user(requested_user, params)
#Stores a boolean value with respect to whether the user data is saved or not
if !user_exists and requested_user_saved
notify_supers_new_request(requested_user)
redirect_to '/instructions/home'
return
elsif user_exists
flash[:error] = "The account you are requesting already exists in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end

def save_requested_user(requested_user, params)
if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
return requested_user.save
end

def notify_supers_new_request(requested_user)
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful
end
</pre>

== Results ==

12 out of 12 tests in the account_request_controller_spec.rb test file.

Here is a image of our tests passing:<br>
[[File:Passing Test.jpg]]

=== Relevant Links ===

Main Expertiza Repository can be found [https://github.com/expertiza/expertiza here].

Our forked Repository can be found [https://github.com/majuabir/expertiza/tree/beta here].

CSC/ECE 517 Fall 2021 - E2126. Refactor account request controller.rb

2021-10-25T20:58:01Z

Aamajumd: /* create_approved_user */

== About Expertiza==

[http://expertiza.ncsu.edu/ Expertiza] is an open source project based on [http://rubyonrails.org/ Ruby on Rails] framework that supports submission across different document types, including theURLs and wiki pages. It allows the instructor not only to create and customize new or existing assignments but also to create a list of topics the students can sign up for. Students can form teams in Expertiza to work on various projects and assignments. Students can also peer review other students' submissions.

== Description about project ==
This page is a description of Expertiza OSS project E2126 which refactoring the account_request_controller.rb file. This file allows Super Administrators to manage the approval process for new users. Our job was to refactor some of the longer methods in this file, make error messages more intuitive, and add a security captcha to the approval/rejection process.

''DISCLAIMER: Some of the issues handed to us were already fixed when we looked at them from a previous project, so this page is only documenting the ones that we worked on. It can be assumed that the other undocumented issues are already done.
''
=== Team ===

Connor Smith (cpsmith6)

Abir Majumder (aamajumd)

Joshua Myers (jamyers3)

=== Files Involved ===

account_request_controller.rb

=== Super Admin Login===

*Despite the username, this user is not an instructor. The role was changed in the database to give instructor6 super admin privileges.
Username: instructor6
Password: password

=== Running Tests ===

<pre>
rspec ./spec/controllers/account_request_controller.rb
</pre>

== Relevant Methods ==

* action_allowed?
* create_approved_user
* create_requested_user_record

=== action_allowed? ===

This method validates if the user is allowed to be redirected to the appropriate page. The task for this project is to add a captcha system before the user requests new. This happens when the user hits the "Request account" button on the login page. This project's repo already has the "recaptcha" gem installed. Future developers need to keep in mind that functionality of the captcha depends on the developer updating the site key and secret key of the Google ReCaptcha API. Installation instructions of the gem and integrating the recaptcha API key can be found [https://github.com/ambethia/recaptcha here].

There was one change to the frontend to display the captcha at _login.html.erb.

'''Front end change /app/views/_login.html.erb'''
<pre>
...
...
<% end %>
<p>

</p>
<br/>
</div>
<%= form_tag({:controller => 'account_request', :role => "Instructor", :action => 'new'}, :method => "get") do %>
<div>
<%= recaptcha_tags %> <------ Displays reCaptcha widget
</div>
<%= submit_tag "Request account", :class => 'btn btn-danger', :style => 'width:100%; margin-left:auto; margin-right:auto;' %>

<% end %>
<% end %>
</pre>

'''action_allowed? changes'''
<pre>
def action_allowed?
case params[:action]
when 'list_pending_requested'
current_user_has_admin_privileges?
when 'new'
verify_recaptcha <---- function provided by recaptcha gem; validates frontend recaptcha input
when 'create_requested_user_record'
true
when 'keys'
current_user_has_student_privileges?
else
current_user_has_ta_privileges?
end
end
</pre>

=== create_approved_user ===

This method allows a Super Admin to approve or reject new users, and gives them an error message if the incorrect steps are taken during that process.
Login info:
Username: instructor6 Password: password
There has been a database change where the role of instructor6 was bumped up to Super Admin.

==== Original Method ====
<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end
</pre>

==== Refactored Method ====

This method was refactored so the creation of the new user is handled in a separate method called '''"user_new"'''

<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
puts "Here"
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
user_new(requested_user)
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end

def user_new(requested_user)
puts requested_user.inspect
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
end
</pre>

=== create_requested_user_record ===

create_requested_user creates a new account request for a user (if they are not a duplicate user) so that it may be approved by a higher level user.

==== Original Method ====

<pre>
def create_requested_user_record

requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested

if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!

#
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects

user_existed = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
requested_user_saved = requested_user.save
#Stores a boolean value with respect to whether the user data is saved or not

if !user_existed and requested_user_saved
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
redirect_to '/instructions/home'
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful

return
elsif user_existed
flash[:error] = "The account you are requesting has already existed in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end
</pre>

==== Refactored Method ====

The new create_requested_user_record now only handles the different cases that can happen when a user requests an account (New user and request goes through, duplicate user and request doesn't go through, or some other error in the saving process. The new method save_requested_user creates the request object, validates it has all needed fields and tries to save it to the database. The new method notify_supers_new_request sends an email to the Super-Administrators that new user account request has been successfully created. Some variable names and error messages have been reworded to improve readability as well.

<pre>
def create_requested_user_record
requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested
user_exists = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
requested_user_saved = save_requested_user(requested_user, params)
#Stores a boolean value with respect to whether the user data is saved or not
if !user_exists and requested_user_saved
notify_supers_new_request(requested_user)
redirect_to '/instructions/home'
return
elsif user_exists
flash[:error] = "The account you are requesting already exists in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end

def save_requested_user(requested_user, params)
if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
return requested_user.save
end

def notify_supers_new_request(requested_user)
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful
end
</pre>

== Results ==

12 out of 12 tests in the account_request_controller_spec.rb test file.

Here is a image of our tests passing:<br>
[[File:Passing Test.jpg]]

=== Relevant Links ===

Main Expertiza Repository can be found [https://github.com/expertiza/expertiza here].

Our forked Repository can be found [https://github.com/majuabir/expertiza/tree/beta here].

CSC/ECE 517 Fall 2021 - E2126. Refactor account request controller.rb

2021-10-25T20:56:26Z

Aamajumd: /* Description about project */

== About Expertiza==

[http://expertiza.ncsu.edu/ Expertiza] is an open source project based on [http://rubyonrails.org/ Ruby on Rails] framework that supports submission across different document types, including theURLs and wiki pages. It allows the instructor not only to create and customize new or existing assignments but also to create a list of topics the students can sign up for. Students can form teams in Expertiza to work on various projects and assignments. Students can also peer review other students' submissions.

== Description about project ==
This page is a description of Expertiza OSS project E2126 which refactoring the account_request_controller.rb file. This file allows Super Administrators to manage the approval process for new users. Our job was to refactor some of the longer methods in this file, make error messages more intuitive, and add a security captcha to the approval/rejection process.

''DISCLAIMER: Some of the issues handed to us were already fixed when we looked at them from a previous project, so this page is only documenting the ones that we worked on. It can be assumed that the other undocumented issues are already done.
''
=== Team ===

Connor Smith (cpsmith6)

Abir Majumder (aamajumd)

Joshua Myers (jamyers3)

=== Files Involved ===

account_request_controller.rb

=== Super Admin Login===

*Despite the username, this user is not an instructor. The role was changed in the database to give instructor6 super admin privileges.
Username: instructor6
Password: password

=== Running Tests ===

<pre>
rspec ./spec/controllers/account_request_controller.rb
</pre>

== Relevant Methods ==

* action_allowed?
* create_approved_user
* create_requested_user_record

=== action_allowed? ===

This method validates if the user is allowed to be redirected to the appropriate page. The task for this project is to add a captcha system before the user requests new. This happens when the user hits the "Request account" button on the login page. This project's repo already has the "recaptcha" gem installed. Future developers need to keep in mind that functionality of the captcha depends on the developer updating the site key and secret key of the Google ReCaptcha API. Installation instructions of the gem and integrating the recaptcha API key can be found [https://github.com/ambethia/recaptcha here].

There was one change to the frontend to display the captcha at _login.html.erb.

'''Front end change /app/views/_login.html.erb'''
<pre>
...
...
<% end %>
<p>

</p>
<br/>
</div>
<%= form_tag({:controller => 'account_request', :role => "Instructor", :action => 'new'}, :method => "get") do %>
<div>
<%= recaptcha_tags %> <------ Displays reCaptcha widget
</div>
<%= submit_tag "Request account", :class => 'btn btn-danger', :style => 'width:100%; margin-left:auto; margin-right:auto;' %>

<% end %>
<% end %>
</pre>

'''action_allowed? changes'''
<pre>
def action_allowed?
case params[:action]
when 'list_pending_requested'
current_user_has_admin_privileges?
when 'new'
verify_recaptcha <---- function provided by recaptcha gem; validates frontend recaptcha input
when 'create_requested_user_record'
true
when 'keys'
current_user_has_student_privileges?
else
current_user_has_ta_privileges?
end
end
</pre>

=== create_approved_user ===

This method allows a Super Admin to approve or reject new users, and gives them an error message if the incorrect steps are taken during that process

==== Original Method ====
<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end
</pre>

==== Refactored Method ====

This method was refactored so the creation of the new user is handled in a separate method called '''"user_new"'''

<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
puts "Here"
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
user_new(requested_user)
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end

def user_new(requested_user)
puts requested_user.inspect
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
end
</pre>

=== create_requested_user_record ===

create_requested_user creates a new account request for a user (if they are not a duplicate user) so that it may be approved by a higher level user.

==== Original Method ====

<pre>
def create_requested_user_record

requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested

if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!

#
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects

user_existed = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
requested_user_saved = requested_user.save
#Stores a boolean value with respect to whether the user data is saved or not

if !user_existed and requested_user_saved
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
redirect_to '/instructions/home'
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful

return
elsif user_existed
flash[:error] = "The account you are requesting has already existed in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end
</pre>

==== Refactored Method ====

The new create_requested_user_record now only handles the different cases that can happen when a user requests an account (New user and request goes through, duplicate user and request doesn't go through, or some other error in the saving process. The new method save_requested_user creates the request object, validates it has all needed fields and tries to save it to the database. The new method notify_supers_new_request sends an email to the Super-Administrators that new user account request has been successfully created. Some variable names and error messages have been reworded to improve readability as well.

<pre>
def create_requested_user_record
requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested
user_exists = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
requested_user_saved = save_requested_user(requested_user, params)
#Stores a boolean value with respect to whether the user data is saved or not
if !user_exists and requested_user_saved
notify_supers_new_request(requested_user)
redirect_to '/instructions/home'
return
elsif user_exists
flash[:error] = "The account you are requesting already exists in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end

def save_requested_user(requested_user, params)
if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
return requested_user.save
end

def notify_supers_new_request(requested_user)
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful
end
</pre>

== Results ==

12 out of 12 tests in the account_request_controller_spec.rb test file.

Here is a image of our tests passing:<br>
[[File:Passing Test.jpg]]

=== Relevant Links ===

Main Expertiza Repository can be found [https://github.com/expertiza/expertiza here].

Our forked Repository can be found [https://github.com/majuabir/expertiza/tree/beta here].

CSC/ECE 517 Fall 2021 - E2126. Refactor account request controller.rb

2021-10-25T20:39:45Z

Aamajumd:

== About Expertiza==

[http://expertiza.ncsu.edu/ Expertiza] is an open source project based on [http://rubyonrails.org/ Ruby on Rails] framework that supports submission across different document types, including theURLs and wiki pages. It allows the instructor not only to create and customize new or existing assignments but also to create a list of topics the students can sign up for. Students can form teams in Expertiza to work on various projects and assignments. Students can also peer review other students' submissions.

== Description about project ==
This page is a description of Expertiza OSS project E2126 which refactoring the account_request_controller.rb file. This file allows Super Administrators to manage the approval process for new users. Our job was to refactor some of the longer methods in this file, make error messages more intuitive, and add a security captcha to the approval/rejection process.

''DISCLAIMER: Some of the issues handed to us were already fixed when we looked at them from a previous project, so this page is only documenting the ones that we worked on. It can be assumed that the other undocumented issues are already done.
''
=== Team ===

Connor Smith (cpsmith6)

Abir Majumder (aamajumd)

Joshua Myers (jamyers3)

=== Files Involved ===

account_request_controller.rb

=== Running Tests ===

<pre>
rspec ./spec/controllers/account_request_controller.rb
</pre>

== Relevant Methods ==

* action_allowed?
* create_approved_user
* create_requested_user_record

=== action_allowed? ===

This method validates if the user is allowed to be redirected to the appropriate page. The task for this project is to add a captcha system before the user requests new. This happens when the user hits the "Request account" button on the login page. This project's repo already has the "recaptcha" gem installed. Future developers need to keep in mind that functionality of the captcha depends on the developer updating the site key and secret key of the Google ReCaptcha API. Installation instructions of the gem and integrating the recaptcha API key can be found [https://github.com/ambethia/recaptcha here].

There was one change to the frontend to display the captcha at _login.html.erb.

'''Front end change /app/views/_login.html.erb'''
<pre>
...
...
<% end %>
<p>

</p>
<br/>
</div>
<%= form_tag({:controller => 'account_request', :role => "Instructor", :action => 'new'}, :method => "get") do %>
<div>
<%= recaptcha_tags %> <------ Displays reCaptcha widget
</div>
<%= submit_tag "Request account", :class => 'btn btn-danger', :style => 'width:100%; margin-left:auto; margin-right:auto;' %>

<% end %>
<% end %>
</pre>

'''action_allowed? changes'''
<pre>
def action_allowed?
case params[:action]
when 'list_pending_requested'
current_user_has_admin_privileges?
when 'new'
verify_recaptcha <---- function provided by recaptcha gem; validates frontend recaptcha input
when 'create_requested_user_record'
true
when 'keys'
current_user_has_student_privileges?
else
current_user_has_ta_privileges?
end
end
</pre>

=== create_approved_user ===

This method allows a Super Admin to approve or reject new users, and gives them an error message if the incorrect steps are taken during that process

==== Original Method ====
<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end
</pre>

==== Refactored Method ====

This method was refactored so the creation of the new user is handled in a separate method called '''"user_new"'''

<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
puts "Here"
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
user_new(requested_user)
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end

def user_new(requested_user)
puts requested_user.inspect
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
end
</pre>

=== create_requested_user_record ===

create_requested_user creates a new account request for a user (if they are not a duplicate user) so that it may be approved by a higher level user.

==== Original Method ====

<pre>
def create_requested_user_record

requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested

if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!

#
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects

user_existed = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
requested_user_saved = requested_user.save
#Stores a boolean value with respect to whether the user data is saved or not

if !user_existed and requested_user_saved
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
redirect_to '/instructions/home'
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful

return
elsif user_existed
flash[:error] = "The account you are requesting has already existed in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end
</pre>

==== Refactored Method ====

The new create_requested_user_record now only handles the different cases that can happen when a user requests an account (New user and request goes through, duplicate user and request doesn't go through, or some other error in the saving process. The new method save_requested_user creates the request object, validates it has all needed fields and tries to save it to the database. The new method notify_supers_new_request sends an email to the Super-Administrators that new user account request has been successfully created. Some variable names and error messages have been reworded to improve readability as well.

<pre>
def create_requested_user_record
requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested
user_exists = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
requested_user_saved = save_requested_user(requested_user, params)
#Stores a boolean value with respect to whether the user data is saved or not
if !user_exists and requested_user_saved
notify_supers_new_request(requested_user)
redirect_to '/instructions/home'
return
elsif user_exists
flash[:error] = "The account you are requesting already exists in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end

def save_requested_user(requested_user, params)
if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
return requested_user.save
end

def notify_supers_new_request(requested_user)
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful
end
</pre>

== Results ==

12 out of 12 tests in the account_request_controller_spec.rb test file.

Here is a image of our tests passing:<br>
[[File:Passing Test.jpg]]

=== Relevant Links ===

Main Expertiza Repository can be found [https://github.com/expertiza/expertiza here].

Our forked Repository can be found [https://github.com/majuabir/expertiza/tree/beta here].

CSC/ECE 517 Fall 2021 - E2126. Refactor account request controller.rb

2021-10-21T03:36:19Z

Aamajumd: /* Description about project */

== About Expertiza==

[http://expertiza.ncsu.edu/ Expertiza] is an open source project based on [http://rubyonrails.org/ Ruby on Rails] framework that supports submission across different document types, including theURLs and wiki pages. It allows the instructor not only to create and customize new or existing assignments but also to create a list of topics the students can sign up for. Students can form teams in Expertiza to work on various projects and assignments. Students can also peer review other students' submissions.

== Description about project ==
This page is a description of Expertiza OSS project E2126 which refactoring the account_request_controller.rb file. This file allows Super Administrators to manage the approval process for new users. Our job was to refactor some of the longer methods in this file, make error messages more intuitive, and add a security captcha to the approval/rejection process.

''DISCLAIMER: Some of the issues handed to us were already fixed when we looked at them from a previous project, so this page is only documenting the ones that we worked on. It can be assumed that the other undocumented issues are already done.
''
=== Team ===

Connor Smith (cpsmith6)

Abir Majumder (aamajumd)

Joshua Myers (jamyers3)

=== Files Involved ===

account_request_controller.rb

=== Running Tests ===

<pre>
rspec ./spec/controllers/account_request_controller.rb
</pre>

== Relevant Methods ==

* action_allowed?
* create_approved_user
* create_requested_user_record

=== action_allowed? ===

This method validates if the user is allowed to be redirected to the appropriate page. The task for this project is to add a captcha system before the user requests new. This happens when the user hits the "Request account" button on the login page. This project's repo already has the "recaptcha" gem installed. Future developers need to keep in mind that functionality of the captcha depends on the developer updating the site key and secret key of the Google ReCaptcha API. Installation of the gem and getting the key instructions can be found [https://github.com/ambethia/recaptcha here].

There was one change to the frontend to display the captcha at _login.html.erb.

'''Front end change /app/views/_login.html.erb'''
<pre>
...
...
<% end %>
<p>
<%= link_to "Request account",{:controller => 'account_request',:role => "Instructor", :action => 'new'}, :class => 'btn btn-danger', :style => 'color:white;width:100%;margin-left:auto;margin-right:auto;' %>
<div>
<%= recaptcha_tags %> <<--=-----displays recaptcha widget
</div>
</p>
<br/>
</div>

<% end %>
</pre>

'''action_allowed? changes'''
<pre>
def captcha_test
valid = true
@something
if verify_recaptcha(model: @something) == true
valid = true
end
return valid
end

def action_allowed?
case params[:action]
when 'list_pending_requested'
current_user_has_admin_privileges?
when 'new'
captcha_test
when 'create_requested_user_record'
true
when 'keys'
current_user_has_student_privileges?
else
current_user_has_ta_privileges?
end
end
</pre>

=== create_approved_user ===

This method allows a Super Admin to approve or reject new users, and gives them an error message if the incorrect steps are taken during that process

==== Original Method ====
<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end
</pre>

==== Refactored Method ====

This method was refactored so the creation of the new user is handled in a separate method called '''"user_new"'''

<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
puts "Here"
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
user_new(requested_user)
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end

def user_new(requested_user)
puts requested_user.inspect
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
end
</pre>

=== create_requested_user_record ===

create_requested_user creates a new account request for a user (if they are not a duplicate user) so that it may be approved by a higher level user.

==== Original Method ====

<pre>
def create_requested_user_record

requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested

if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!

#
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects

user_existed = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
requested_user_saved = requested_user.save
#Stores a boolean value with respect to whether the user data is saved or not

if !user_existed and requested_user_saved
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
redirect_to '/instructions/home'
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful

return
elsif user_existed
flash[:error] = "The account you are requesting has already existed in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end
</pre>

==== Refactored Method ====

The new create_requested_user_record now only handles the different cases that can happen when a user requests an account (New user and request goes through, duplicate user and request doesn't go through, or some other error in the saving process. The new method save_requested_user creates the request object, validates it has all needed fields and tries to save it to the database. The new method notify_supers_new_request sends an email to the Super-Administrators that new user account request has been successfully created. Some variable names and error messages have been reworded to improve readability as well.

<pre>
def create_requested_user_record
requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested
user_exists = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
requested_user_saved = save_requested_user(requested_user, params)
#Stores a boolean value with respect to whether the user data is saved or not
if !user_exists and requested_user_saved
notify_supers_new_request(requested_user)
redirect_to '/instructions/home'
return
elsif user_exists
flash[:error] = "The account you are requesting already exists in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end

def save_requested_user(requested_user, params)
if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
return requested_user.save
end

def notify_supers_new_request(requested_user)
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful
end
</pre>

== Results ==

12 out of 12 tests in the account_request_controller_spec.rb test file.

Here is a image of our tests passing:<br>
[[File:Passing Test.jpg]]

=== Relevant Links ===

Main Expertiza Repository can be found [https://github.com/expertiza/expertiza here].

Our forked Repository can be found [https://github.com/majuabir/expertiza/tree/beta here].

CSC/ECE 517 Fall 2021 - E2126. Refactor account request controller.rb

2021-10-21T03:35:24Z

Aamajumd: /* Description about project */

== About Expertiza==

[http://expertiza.ncsu.edu/ Expertiza] is an open source project based on [http://rubyonrails.org/ Ruby on Rails] framework that supports submission across different document types, including theURLs and wiki pages. It allows the instructor not only to create and customize new or existing assignments but also to create a list of topics the students can sign up for. Students can form teams in Expertiza to work on various projects and assignments. Students can also peer review other students' submissions.

== Description about project ==
This page is a description of Expertiza OSS project E2126 which refactoring the account_request_controller.rb file. This file allows Super Administrators to manage the approval process for new users. Our job was to refactor some of the longer methods in this file, make error messages more intuitive, and add a security captcha to the approval/rejection process.

''DISCLAIMER: Some of the issues handed to us were already fixed when we looked at them, so this page is only documenting the ones that initially remained needing to be fixed.
''
=== Team ===

Connor Smith (cpsmith6)

Abir Majumder (aamajumd)

Joshua Myers (jamyers3)

=== Files Involved ===

account_request_controller.rb

=== Running Tests ===

<pre>
rspec ./spec/controllers/account_request_controller.rb
</pre>

== Relevant Methods ==

* action_allowed?
* create_approved_user
* create_requested_user_record

=== action_allowed? ===

This method validates if the user is allowed to be redirected to the appropriate page. The task for this project is to add a captcha system before the user requests new. This happens when the user hits the "Request account" button on the login page. This project's repo already has the "recaptcha" gem installed. Future developers need to keep in mind that functionality of the captcha depends on the developer updating the site key and secret key of the Google ReCaptcha API. Installation of the gem and getting the key instructions can be found [https://github.com/ambethia/recaptcha here].

There was one change to the frontend to display the captcha at _login.html.erb.

'''Front end change /app/views/_login.html.erb'''
<pre>
...
...
<% end %>
<p>
<%= link_to "Request account",{:controller => 'account_request',:role => "Instructor", :action => 'new'}, :class => 'btn btn-danger', :style => 'color:white;width:100%;margin-left:auto;margin-right:auto;' %>
<div>
<%= recaptcha_tags %> <<--=-----displays recaptcha widget
</div>
</p>
<br/>
</div>

<% end %>
</pre>

'''action_allowed? changes'''
<pre>
def captcha_test
valid = true
@something
if verify_recaptcha(model: @something) == true
valid = true
end
return valid
end

def action_allowed?
case params[:action]
when 'list_pending_requested'
current_user_has_admin_privileges?
when 'new'
captcha_test
when 'create_requested_user_record'
true
when 'keys'
current_user_has_student_privileges?
else
current_user_has_ta_privileges?
end
end
</pre>

=== create_approved_user ===

This method allows a Super Admin to approve or reject new users, and gives them an error message if the incorrect steps are taken during that process

==== Original Method ====
<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end
</pre>

==== Refactored Method ====

This method was refactored so the creation of the new user is handled in a separate method called '''"user_new"'''

<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
puts "Here"
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
user_new(requested_user)
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end

def user_new(requested_user)
puts requested_user.inspect
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
end
</pre>

=== create_requested_user_record ===

create_requested_user creates a new account request for a user (if they are not a duplicate user) so that it may be approved by a higher level user.

==== Original Method ====

<pre>
def create_requested_user_record

requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested

if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!

#
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects

user_existed = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
requested_user_saved = requested_user.save
#Stores a boolean value with respect to whether the user data is saved or not

if !user_existed and requested_user_saved
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
redirect_to '/instructions/home'
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful

return
elsif user_existed
flash[:error] = "The account you are requesting has already existed in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end
</pre>

==== Refactored Method ====

The new create_requested_user_record now only handles the different cases that can happen when a user requests an account (New user and request goes through, duplicate user and request doesn't go through, or some other error in the saving process. The new method save_requested_user creates the request object, validates it has all needed fields and tries to save it to the database. The new method notify_supers_new_request sends an email to the Super-Administrators that new user account request has been successfully created. Some variable names and error messages have been reworded to improve readability as well.

<pre>
def create_requested_user_record
requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested
user_exists = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
requested_user_saved = save_requested_user(requested_user, params)
#Stores a boolean value with respect to whether the user data is saved or not
if !user_exists and requested_user_saved
notify_supers_new_request(requested_user)
redirect_to '/instructions/home'
return
elsif user_exists
flash[:error] = "The account you are requesting already exists in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end

def save_requested_user(requested_user, params)
if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
return requested_user.save
end

def notify_supers_new_request(requested_user)
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful
end
</pre>

== Results ==

12 out of 12 tests in the account_request_controller_spec.rb test file.

Here is a image of our tests passing:<br>
[[File:Passing Test.jpg]]

=== Relevant Links ===

Main Expertiza Repository can be found [https://github.com/expertiza/expertiza here].

Our forked Repository can be found [https://github.com/majuabir/expertiza/tree/beta here].

CSC/ECE 517 Fall 2021 - E2126. Refactor account request controller.rb

2021-10-21T03:35:07Z

Aamajumd: /* Description about project */

== About Expertiza==

[http://expertiza.ncsu.edu/ Expertiza] is an open source project based on [http://rubyonrails.org/ Ruby on Rails] framework that supports submission across different document types, including theURLs and wiki pages. It allows the instructor not only to create and customize new or existing assignments but also to create a list of topics the students can sign up for. Students can form teams in Expertiza to work on various projects and assignments. Students can also peer review other students' submissions.

== Description about project ==
This page is a description of Expertiza OSS project E2126 which refactoring the account_request_controller.rb file. This file allows Super Administrators to manage the approval process for new users. Our job was to refactor some of the longer methods in this file, make error messages more intuitive, and add a security captcha to the approval/rejection process.

DISCLAIMER: Some of the issues handed to us were already fixed when we looked at them, so this page is only documenting the ones that initially remained needing to be fixed.

=== Team ===

Connor Smith (cpsmith6)

Abir Majumder (aamajumd)

Joshua Myers (jamyers3)

=== Files Involved ===

account_request_controller.rb

=== Running Tests ===

<pre>
rspec ./spec/controllers/account_request_controller.rb
</pre>

== Relevant Methods ==

* action_allowed?
* create_approved_user
* create_requested_user_record

=== action_allowed? ===

This method validates if the user is allowed to be redirected to the appropriate page. The task for this project is to add a captcha system before the user requests new. This happens when the user hits the "Request account" button on the login page. This project's repo already has the "recaptcha" gem installed. Future developers need to keep in mind that functionality of the captcha depends on the developer updating the site key and secret key of the Google ReCaptcha API. Installation of the gem and getting the key instructions can be found [https://github.com/ambethia/recaptcha here].

There was one change to the frontend to display the captcha at _login.html.erb.

'''Front end change /app/views/_login.html.erb'''
<pre>
...
...
<% end %>
<p>
<%= link_to "Request account",{:controller => 'account_request',:role => "Instructor", :action => 'new'}, :class => 'btn btn-danger', :style => 'color:white;width:100%;margin-left:auto;margin-right:auto;' %>
<div>
<%= recaptcha_tags %> <<--=-----displays recaptcha widget
</div>
</p>
<br/>
</div>

<% end %>
</pre>

'''action_allowed? changes'''
<pre>
def captcha_test
valid = true
@something
if verify_recaptcha(model: @something) == true
valid = true
end
return valid
end

def action_allowed?
case params[:action]
when 'list_pending_requested'
current_user_has_admin_privileges?
when 'new'
captcha_test
when 'create_requested_user_record'
true
when 'keys'
current_user_has_student_privileges?
else
current_user_has_ta_privileges?
end
end
</pre>

=== create_approved_user ===

This method allows a Super Admin to approve or reject new users, and gives them an error message if the incorrect steps are taken during that process

==== Original Method ====
<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end
</pre>

==== Refactored Method ====

This method was refactored so the creation of the new user is handled in a separate method called '''"user_new"'''

<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
puts "Here"
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
user_new(requested_user)
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end

def user_new(requested_user)
puts requested_user.inspect
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
end
</pre>

=== create_requested_user_record ===

create_requested_user creates a new account request for a user (if they are not a duplicate user) so that it may be approved by a higher level user.

==== Original Method ====

<pre>
def create_requested_user_record

requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested

if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!

#
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects

user_existed = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
requested_user_saved = requested_user.save
#Stores a boolean value with respect to whether the user data is saved or not

if !user_existed and requested_user_saved
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
redirect_to '/instructions/home'
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful

return
elsif user_existed
flash[:error] = "The account you are requesting has already existed in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end
</pre>

==== Refactored Method ====

The new create_requested_user_record now only handles the different cases that can happen when a user requests an account (New user and request goes through, duplicate user and request doesn't go through, or some other error in the saving process. The new method save_requested_user creates the request object, validates it has all needed fields and tries to save it to the database. The new method notify_supers_new_request sends an email to the Super-Administrators that new user account request has been successfully created. Some variable names and error messages have been reworded to improve readability as well.

<pre>
def create_requested_user_record
requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested
user_exists = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
requested_user_saved = save_requested_user(requested_user, params)
#Stores a boolean value with respect to whether the user data is saved or not
if !user_exists and requested_user_saved
notify_supers_new_request(requested_user)
redirect_to '/instructions/home'
return
elsif user_exists
flash[:error] = "The account you are requesting already exists in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end

def save_requested_user(requested_user, params)
if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
return requested_user.save
end

def notify_supers_new_request(requested_user)
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful
end
</pre>

== Results ==

12 out of 12 tests in the account_request_controller_spec.rb test file.

Here is a image of our tests passing:<br>
[[File:Passing Test.jpg]]

=== Relevant Links ===

Main Expertiza Repository can be found [https://github.com/expertiza/expertiza here].

Our forked Repository can be found [https://github.com/majuabir/expertiza/tree/beta here].

CSC/ECE 517 Fall 2021 - E2126. Refactor account request controller.rb

2021-10-21T03:24:42Z

Aamajumd: /* action_allowed? */

== About Expertiza==

[http://expertiza.ncsu.edu/ Expertiza] is an open source project based on [http://rubyonrails.org/ Ruby on Rails] framework that supports submission across different document types, including theURLs and wiki pages. It allows the instructor not only to create and customize new or existing assignments but also to create a list of topics the students can sign up for. Students can form teams in Expertiza to work on various projects and assignments. Students can also peer review other students' submissions.

== Description about project ==
This page is a description of Expertiza OSS project E2126 which refactoring the account_request_controller.rb file. This file allows Super Administrators to manage the approval process for new users. Our job was to refactor some of the longer methods in this file, make error messages more intuitive, and add a security captcha to the approval/rejection process.

=== Team ===

Connor Smith (cpsmith6)

Abir Majumder (aamajumd)

Joshua Myers (jamyers3)

=== Files Involved ===

account_request_controller.rb

=== Running Tests ===

<pre>
rspec ./spec/controllers/account_request_controller.rb
</pre>

== Relevant Methods ==

* action_allowed?
* create_approved_user
* create_requested_user_record

=== action_allowed? ===

This method validates if the user is allowed to be redirected to the appropriate page. The task for this project is to add a captcha system before the user requests new. This happens when the user hits the "Request account" button on the login page. This project's repo already has the "recaptcha" gem installed. Future developers need to keep in mind that functionality of the captcha depends on the developer updating the site key and secret key of the Google ReCaptcha API. Installation of the gem and getting the key instructions can be found [https://github.com/ambethia/recaptcha here].

There was one change to the frontend to display the captcha at _login.html.erb.

'''Front end change /app/views/_login.html.erb'''
<pre>
...
...
<% end %>
<p>
<%= link_to "Request account",{:controller => 'account_request',:role => "Instructor", :action => 'new'}, :class => 'btn btn-danger', :style => 'color:white;width:100%;margin-left:auto;margin-right:auto;' %>
<div>
<%= recaptcha_tags %> <<--=-----displays recaptcha widget
</div>
</p>
<br/>
</div>

<% end %>
</pre>

'''action_allowed? changes'''
<pre>
def captcha_test
valid = true
@something
if verify_recaptcha(model: @something) == true
valid = true
end
return valid
end

def action_allowed?
case params[:action]
when 'list_pending_requested'
current_user_has_admin_privileges?
when 'new'
captcha_test
when 'create_requested_user_record'
true
when 'keys'
current_user_has_student_privileges?
else
current_user_has_ta_privileges?
end
end
</pre>

=== create_approved_user ===

This method allows a Super Admin to approve or reject new users, and gives them an error message if the incorrect steps are taken during that process

==== Original Method ====
<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end
</pre>

==== Refactored Method ====

This method was refactored so the creation of the new user is handled in a separate method called '''"user_new"'''

<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
puts "Here"
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
user_new(requested_user)
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end

def user_new(requested_user)
puts requested_user.inspect
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
end
</pre>

=== create_requested_user_record ===

create_requested_user creates a new account request for a user (if they are not a duplicate user) so that it may be approved by a higher level user.

==== Original Method ====

<pre>
def create_requested_user_record

requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested

if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!

#
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects

user_existed = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
requested_user_saved = requested_user.save
#Stores a boolean value with respect to whether the user data is saved or not

if !user_existed and requested_user_saved
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
redirect_to '/instructions/home'
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful

return
elsif user_existed
flash[:error] = "The account you are requesting has already existed in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end
</pre>

==== Refactored Method ====

The new create_requested_user_record now only handles the different cases that can happen when a user requests an account (New user and request goes through, duplicate user and request doesn't go through, or some other error in the saving process. The new method save_requested_user creates the request object, validates it has all needed fields and tries to save it to the database. The new method notify_supers_new_request sends an email to the Super-Administrators that new user account request has been successfully created. Some variable names and error messages have been reworded to improve readability as well.

<pre>
def create_requested_user_record
requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested
user_exists = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
requested_user_saved = save_requested_user(requested_user, params)
#Stores a boolean value with respect to whether the user data is saved or not
if !user_exists and requested_user_saved
notify_supers_new_request(requested_user)
redirect_to '/instructions/home'
return
elsif user_exists
flash[:error] = "The account you are requesting already exists in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end

def save_requested_user(requested_user, params)
if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
return requested_user.save
end

def notify_supers_new_request(requested_user)
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful
end
</pre>

== Results ==

12 out of 12 tests in the account_request_controller_spec.rb test file.

Our code changes can be viewed [https://github.com/expertiza/expertiza/pull/2094/files here].

Here is a image of our tests passing:<br>
[[File:Passing Test.jpg]]

=== Relevant Links ===

Main Expertiza Repository can be found [https://github.com/expertiza/expertiza here].

Our forked Repository can be found [https://github.com/majuabir/expertiza/tree/beta here].

CSC/ECE 517 Fall 2021 - E2126. Refactor account request controller.rb

2021-10-21T03:22:51Z

Aamajumd: /* action_allowed? */

== About Expertiza==

[http://expertiza.ncsu.edu/ Expertiza] is an open source project based on [http://rubyonrails.org/ Ruby on Rails] framework that supports submission across different document types, including theURLs and wiki pages. It allows the instructor not only to create and customize new or existing assignments but also to create a list of topics the students can sign up for. Students can form teams in Expertiza to work on various projects and assignments. Students can also peer review other students' submissions.

== Description about project ==
This page is a description of Expertiza OSS project E2126 which refactoring the account_request_controller.rb file. This file allows Super Administrators to manage the approval process for new users. Our job was to refactor some of the longer methods in this file, make error messages more intuitive, and add a security captcha to the approval/rejection process.

=== Team ===

Connor Smith (cpsmith6)

Abir Majumder (aamajumd)

Joshua Myers (jamyers3)

=== Files Involved ===

account_request_controller.rb

=== Running Tests ===

<pre>
rspec ./spec/controllers/account_request_controller.rb
</pre>

== Relevant Methods ==

* action_allowed?
* create_approved_user
* create_requested_user_record

=== action_allowed? ===

This method validates if the user is allowed to be redirected to the appropriate page. The task for this project is to add a captcha system before the user requests new. This happens when the user hits the "Request account" button on the login page. This project's repo already has the "recaptcha" gem installed. Future developers need to keep in mind that functionality of the captcha depends on the developer updating the site key and secret key of the Google ReCaptcha API. Installation of the gem and getting the key instructions can be found [https://github.com/ambethia/recaptcha here].

There was one change to the frontend to display the captcha at _login.html.erb.

<pre>
...
...
<% end %>
<p>
<%= link_to "Request account",{:controller => 'account_request',:role => "Instructor", :action => 'new'}, :class => 'btn btn-danger', :style => 'color:white;width:100%;margin-left:auto;margin-right:auto;' %>
<div>
<%= recaptcha_tags %> <<--=-----displays recaptcha widget
</div>
</p>
<br/>
</div>

<% end %>
</pre>

<pre>
def captcha_test
valid = true
@something
if verify_recaptcha(model: @something) == true
valid = true
end
return valid
end

def action_allowed?
case params[:action]
when 'list_pending_requested'
current_user_has_admin_privileges?
when 'new'
captcha_test
when 'create_requested_user_record'
true
when 'keys'
current_user_has_student_privileges?
else
current_user_has_ta_privileges?
end
end
</pre>

=== create_approved_user ===

This method allows a Super Admin to approve or reject new users, and gives them an error message if the incorrect steps are taken during that process

==== Original Method ====
<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end
</pre>

==== Refactored Method ====

This method was refactored so the creation of the new user is handled in a separate method called '''"user_new"'''

<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
puts "Here"
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
user_new(requested_user)
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end

def user_new(requested_user)
puts requested_user.inspect
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
end
</pre>

=== create_requested_user_record ===

create_requested_user creates a new account request for a user (if they are not a duplicate user) so that it may be approved by a higher level user.

==== Original Method ====

<pre>
def create_requested_user_record

requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested

if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!

#
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects

user_existed = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
requested_user_saved = requested_user.save
#Stores a boolean value with respect to whether the user data is saved or not

if !user_existed and requested_user_saved
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
redirect_to '/instructions/home'
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful

return
elsif user_existed
flash[:error] = "The account you are requesting has already existed in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end
</pre>

==== Refactored Method ====

The new create_requested_user_record now only handles the different cases that can happen when a user requests an account (New user and request goes through, duplicate user and request doesn't go through, or some other error in the saving process. The new method save_requested_user creates the request object, validates it has all needed fields and tries to save it to the database. The new method notify_supers_new_request sends an email to the Super-Administrators that new user account request has been successfully created. Some variable names and error messages have been reworded to improve readability as well.

<pre>
def create_requested_user_record
requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested
user_exists = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
requested_user_saved = save_requested_user(requested_user, params)
#Stores a boolean value with respect to whether the user data is saved or not
if !user_exists and requested_user_saved
notify_supers_new_request(requested_user)
redirect_to '/instructions/home'
return
elsif user_exists
flash[:error] = "The account you are requesting already exists in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end

def save_requested_user(requested_user, params)
if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
return requested_user.save
end

def notify_supers_new_request(requested_user)
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful
end
</pre>

== Results ==

12 out of 12 tests in the account_request_controller_spec.rb test file.

Our code changes can be viewed [https://github.com/expertiza/expertiza/pull/2094/files here].

Here is a image of our tests passing:<br>
[[File:Passing Test.jpg]]

=== Relevant Links ===

Main Expertiza Repository can be found [https://github.com/expertiza/expertiza here].

Our forked Repository can be found [https://github.com/majuabir/expertiza/tree/beta here].

CSC/ECE 517 Fall 2021 - E2126. Refactor account request controller.rb

2021-10-21T03:21:52Z

Aamajumd: /* action_allowed? */

== About Expertiza==

[http://expertiza.ncsu.edu/ Expertiza] is an open source project based on [http://rubyonrails.org/ Ruby on Rails] framework that supports submission across different document types, including theURLs and wiki pages. It allows the instructor not only to create and customize new or existing assignments but also to create a list of topics the students can sign up for. Students can form teams in Expertiza to work on various projects and assignments. Students can also peer review other students' submissions.

== Description about project ==
This page is a description of Expertiza OSS project E2126 which refactoring the account_request_controller.rb file. This file allows Super Administrators to manage the approval process for new users. Our job was to refactor some of the longer methods in this file, make error messages more intuitive, and add a security captcha to the approval/rejection process.

=== Team ===

Connor Smith (cpsmith6)

Abir Majumder (aamajumd)

Joshua Myers (jamyers3)

=== Files Involved ===

account_request_controller.rb

=== Running Tests ===

<pre>
rspec ./spec/controllers/account_request_controller.rb
</pre>

== Relevant Methods ==

* action_allowed?
* create_approved_user
* create_requested_user_record

=== action_allowed? ===

This method validates if the user is allowed to be redirected to the appropriate page. The task for this project is to add a captcha system before the user requests new. This happens when the user hits the "Request account" button on the login page. This project's repo already has the "recaptcha" gem installed. Future developers need to keep in mind that functionality of the captcha depends on the developer updating the site key and secret key of the Google ReCaptcha API. Installation of the gem and getting the key instructions can be found [https://github.com/ambethia/recaptcha here].

There was one change to the frontend to display the captcha at _login.html.erb.
<pre>
...
...
<% end %>
<p>
<%= link_to "Request account",{:controller => 'account_request',:role => "Instructor", :action => 'new'}, :class => 'btn btn-danger', :style => 'color:white;width:100%;margin-left:auto;margin-right:auto;' %>
<div>
<%= recaptcha_tags %> <<--=-----displays recaptcha widget
</div>
</p>
<br/>
</div>

<% end %>
</pre>

<pre>
def captcha_test
valid = true
@something
if verify_recaptcha(model: @something) == true
valid = true
end
return valid
end

def action_allowed?
case params[:action]
when 'list_pending_requested'
current_user_has_admin_privileges?
when 'new'
captcha_test
when 'create_requested_user_record'
true
when 'keys'
current_user_has_student_privileges?
else
current_user_has_ta_privileges?
end
end
</pre>

=== create_approved_user ===

This method allows a Super Admin to approve or reject new users, and gives them an error message if the incorrect steps are taken during that process

==== Original Method ====
<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end
</pre>

==== Refactored Method ====

This method was refactored so the creation of the new user is handled in a separate method called '''"user_new"'''

<pre>
def create_approved_user
if params[:selection] == nil
flash[:error] = "Please Approve or Reject before submitting"
redirect_to action: 'list_pending_requested'
return
end
is_approved = (params[:commit] == "Accept"? "Approved" : "Rejected")
users = params[:selection]
users.each do |user|
requested_user = AccountRequest.find_by(id: user.first)
requested_user.status = is_approved
puts "Here"
if requested_user.status.nil?
flash[:error] = "Please Approve or Reject before submitting"
elsif requested_user.update_attributes(params[:user])
flash[:success] = "The user \"#{requested_user.name}\" has been successfully updated."
end
if requested_user.status == "Approved"
user_new(requested_user)
elsif requested_user.status == "Rejected"
# If the user request has been rejected, a flash message is shown and redirected to review page
if requested_user.update_columns(status: is_approved)
flash[:success] = "The user \"#{requested_user.name}\" has been Rejected."
# redirect_to action: 'list_pending_requested'
# return
else
flash[:error] = "Error processing request."
end
end
end
redirect_to action: 'list_pending_requested'
end

def user_new(requested_user)
puts requested_user.inspect
new_user = User.new
new_user.name = requested_user.name
new_user.role_id = requested_user.role_id
new_user.institution_id = requested_user.institution_id
new_user.fullname = requested_user.fullname
new_user.email = requested_user.email
new_user.parent_id = session[:user].id
new_user.timezonepref = User.find_by(id: new_user.parent_id).timezonepref
if new_user.save
password = new_user.reset_password
# Mail is sent to the user with a new password
prepared_mail = MailerHelper.send_mail_to_user(new_user, "Your Expertiza account and password have been created.", "user_welcome", password)
prepared_mail.deliver_now
flash[:success] = "A new password has been sent to new user's e-mail address."
undo_link("The user \"#{requested_user.name}\" has been successfully created. ")
else
foreign
end
end
</pre>

=== create_requested_user_record ===

create_requested_user creates a new account request for a user (if they are not a duplicate user) so that it may be approved by a higher level user.

==== Original Method ====

<pre>
def create_requested_user_record

requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested

if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!

#
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects

user_existed = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
requested_user_saved = requested_user.save
#Stores a boolean value with respect to whether the user data is saved or not

if !user_existed and requested_user_saved
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
redirect_to '/instructions/home'
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful

return
elsif user_existed
flash[:error] = "The account you are requesting has already existed in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end
</pre>

==== Refactored Method ====

The new create_requested_user_record now only handles the different cases that can happen when a user requests an account (New user and request goes through, duplicate user and request doesn't go through, or some other error in the saving process. The new method save_requested_user creates the request object, validates it has all needed fields and tries to save it to the database. The new method notify_supers_new_request sends an email to the Super-Administrators that new user account request has been successfully created. Some variable names and error messages have been reworded to improve readability as well.

<pre>
def create_requested_user_record
requested_user = AccountRequest.new(requested_user_params)
#An object is created with respect to AccountRequest model inorder to populate the users information when account is requested
user_exists = User.find_by(name: requested_user.name) or User.find_by(name: requested_user.email)
requested_user_saved = save_requested_user(requested_user, params)
#Stores a boolean value with respect to whether the user data is saved or not
if !user_exists and requested_user_saved
notify_supers_new_request(requested_user)
redirect_to '/instructions/home'
return
elsif user_exists
flash[:error] = "The account you are requesting already exists in Expertiza."
#If the user account already exists, log error to the user
else
flash[:error] = requested_user.errors.full_messages.to_sentence
#If saving in the AccountRequests model has failed
end
ExpertizaLogger.error LoggerMessage.new(controller_name, requested_user.name, flash[:error], request)
redirect_to controller: 'account_request', action: 'new', role: 'Student'
#if the first if clause fails, redirect back to the account requests page!
end

def save_requested_user(requested_user, params)
if params[:user][:institution_id].empty?
institution = Institution.find_or_create_by(name: params[:institution][:name])
requested_user.institution_id = institution.id
end
#If user enters others and adds a new institution, an institution id will be created with respect to the institution model.
#This institution_attribute will be added to the AccountRequest model under institution_id attribute!
requested_user.status = 'Under Review'
#The status is by default 'Under Review' until the super admin approves or rejects
# default to instructor role
if requested_user.role_id == nil
requested_user.role_id = Role.where(:name => "Instructor")[0].id
end
return requested_user.save
end

def notify_supers_new_request(requested_user)
super_users = User.joins(:role).where('roles.name = ?', 'Super-Administrator')
super_users.each do |super_user|
prepared_mail = MailerHelper.send_mail_to_all_super_users(super_user, requested_user, 'New account Request')
prepared_mail.deliver
end
#Notifying an email to the administrator regarding the new user request!
ExpertizaLogger.info LoggerMessage.new(controller_name, requested_user.name, 'The account you are requesting has been created successfully.', request)
flash[:success] = "User signup for \"#{requested_user.name}\" has been successfully requested."
#Print out the acknowledgement message to the user and redirect to /instructors/home page when successful
end
</pre>

== Results ==

12 out of 12 tests in the account_request_controller_spec.rb test file.

Our code changes can be viewed [https://github.com/expertiza/expertiza/pull/2094/files here].

Here is a image of our tests passing:<br>
[[File:Passing Test.jpg]]

=== Relevant Links ===

Main Expertiza Repository can be found [https://github.com/expertiza/expertiza here].

Our forked Repository can be found [https://github.com/majuabir/expertiza/tree/beta here].