Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Spring 2015 E1526

2015-05-04T04:14:13Z

Rlcoble: /* Code Details */

E1526. Responsive web design for Expertiza 

__TOC__

= Strategy =

We analyzed the three Expertiza pages that we need to modify for this project, as well as all of their dependencies, and tried to identify all the tasks that we need to complete for this project. It became clear to us that a large majority of this project will be based on AngularJS, while the small fraction will be related to Bootstrap. Therefore, our strategy was to jumpstart this project by having all 4 team members work together on adding AngularJS to the Login page. Once the Login page was completed, we split in two groups. One group worked on implementing AngularJS on Manage-course page, while the other group worked on introducing AngularJS to Manage-User page.
The reasoning behind this strategy was that all of us working together on the Login page first allowed us to obtain some basic understanding of AngularJS and feel more comfortable using this impressively useful and powerful framework. We completed AngularJS constituents first by connecting some of the Rails controllers to AngularJS controllers and then, as a final step, we add Bootstrap. Our decision was based on the fact that Bootstrap does not require much work to be completed and it can be considered to be a pretty straight-forward element of the project.

= Guide for future students =
1. Learn how to integrate AngularJS into Rails, using Rails original routing system.

2. Learn AngularJS and Coffeescript, since the app.js is written in Coffeescript now.

3. Learn Bootstrap, including the grid system, responsive design and etc.

4. Read the code written by us, to know

a. how to pass data from Rails controller and view to AngularJS;
b. how to pass data back to Rails view from AngularJS;
c. how to convert JSON formatted data using in AngularJS to Rails hash and vice versa.
d. how to present the data to Rails view

= Integration =
This section represent the cornerstone of this project. It consciously explains how Angular and Rails can be integrated into a powerful system capable of providing solid control over both the backend and frontend development of your application.

== Steps to interconnect Rails and AngularJS ==

These guidelines assume that you have a Rails project in place and that you are intending to add AngularJS to it now. Please follow the steps bellow:

1. In the Gemfile, ADD gem ‘bower-rails’ AND gem ‘angular-rails-templates’, then REMOVE ‘gem turbolinks'

2. run <pre> bundle install</pre>

3. Create a Bowerfile. It is used by AngularJS and it can be thought of as the Gemfile that Rails uses.

4. In the Bowerfile, ADD asset ‘angular’ , asset ‘bootstrap-sass-official’, asset ‘angular-route’ AND asset ‘angular-boostrap’(for ui.bootstrap injection)

5. run <pre> rake bower:install </pre>. Bower installs dependencies in vender/assets/bower_components.

6. ADD the following content to the config/application.rb
<pre>
config.assets.paths << Rails.root.join("vendor","assets","bower_components")

config.assets.paths << Rails.root.join("vendor","assets","bower_components","bootstrap-sass-official","assets","fonts")

config.assets.precompile << %r(.*.(?:eot|svg|ttf|woff|woff2)$)

</pre>

7. REMOVE //= require turbolinks AND ADD
<pre>
//= require angular/angular
//= require angular-route/angular-route
//= require angular-rails-templates
//= require angular-bootstrap
</pre>
to assets/javascripts/application.js

8. Rename assets/stylesheets/application.css to assets/stylesheets/application.css.scss.

9. ADD
<pre>
@import "bootstrap-sass-official/assets/stylesheets/bootstrap-sprockets"; and
@import "bootstrap-sass-official/assets/stylesheets/bootstrap";
</pre>
to application.css.scss

Since we are did not get to build a new website using AngularJS from scratch, it was a good idea to retain the routing system of Rails rather than implement it in AngularJS.
So, we added a new tag <code> div ng-app='MPApp'</code> into the app/views/layout/application.html.erb to include all pages into the scope of our AngularJS app, named ‘MPApp’.
Then, for the home page app/views/content_pages/view.html.erb, we added a tag to make this page controlled by ‘testCtrl’, which was defined in app.coffee.

== AngularJS's point of view ==

1. Retrieving data from database
Because it is not appropriate to let AngularJS to directly fetch data from the MySQL database, the only way we could load data was through a Rails controller. For example, it is possible to do a http get/post request(GET /users/fetch_10_users) from AngularJS controller using $http injection or jQuery AJAX, which calls a new method ‘def fetch_10_users’ in the users_controller, which execute some database query via accessing methods in the user model, and returns json formatted data to the AngularJS controller. After getting the returning data, the AngularJS controller can present the data to the screen.

2. Build custom directives
Instead of using the original Rails page, we decided to replace some forms and components using AngularJS directives, which enabled us to do some live modifications to the pages without loading.

== Rails' point of view ==
The initial problem was how to provide entries from the database to AngularJS. We decided to create methods in Rails controller which will listen to the incoming AngulaJS and use a select statement to fetch a couple of entries from the database. These entries are then stored in a hash, converted to json and passed to AngularJS controller. AngularJS will then send another query request to Rails for the next set of entries. This strategy greatly reduces the loading time, making the time needed for representing the page kept at the minimum.

=The specifics=
This section explains the very detailed actions and their results related to the 3 specific pages that were used to integrate AngularJS. Numerous snapshots are provided with the goal to make our approach very clear.

== Login Page and Navigation Bar ==
Login procedure:
‘Login’ button clicked → auth_controller#login → auth_controller#after_login(user) → if user.role != ‘student’ → tree_display#drill → tree_display#list 
If session[:menu] is defined, that is, when a user is logging in, the page will render the content of variable session[:menu].
<pre>
<ul class="nav navbar-nav">
<% if session[:menu] %>
<%= render :partial => 'menu_items/suckerfish',
:locals => { items: session[:menu].get_menu(0), level: 0 } %>
<% end %>
</ul>

<ul class="nav navbar-nav">
<% if session[:menu] %>
<%= render :partial => 'menu_items/suckerfish',
:locals => { items: session[:menu].get_menu(0), level: 0 } %>
<% end %>
</ul>
</pre>

For each menu item in the nav bar, it is a dropdown menu now. For different level of dropdown menu, we apply different CSS style to it.
<pre>
<% level += 1 %>
<% items.each do |item_id|
item = session[:menu].get_item(item_id)
selected = session[:menu].selected?(item.id)
long_name = item.name.split(/\W/).collect{|word| word.capitalize}.join(' ')
%>
<% if level == 1 %>
<li class="dropdown first-level">
<% elsif level == 2 %>
<li class="dropdown-submenu">
<% else %>
<li class="dropdown">
<% end %>
<a href=<%= URI.encode("/menu/#{item.name}") %>
<%= if item.children
' class="daddy"'
end %>title='<%= long_name %>'><%= item.label.html_safe %></a>
<% if item.children -%>
<% if level == 1 %>
<ul class="dropdown-menu multi-level">
<%= render :partial => 'menu_items/suckerfish', :locals => {:items => item.children, :level => level} %>
</ul>
<% else %>
<ul class="dropdown-menu">
<%= render :partial => 'menu_items/suckerfish', :locals => {:items => item.children, :level => level} %>
</ul>
<% end %>
<% end -%>
</li>
<% end -%>
</pre>
Please also refer to app/assets/application.css.scss for further details.

== Manage-course page ==
=== Design ===
After logging in, only the table frame is loaded into the page by rails. Then AngularJS takes over in the background and populate the content into the table. After all first-level content is populated into the table, in this case, all courses info belongs to the first level and their assignment is the second-level content.

After all first level content is loaded into the table, the Angular controller starts to initialize POST request for second level content.

In all, rendering the tree_display page is divided into 3 steps: 
1. render the table frame, 
2. render the first level table content. 
3. fetch deeper level data. 

In the past, these 3 steps are done before rendering the page, which takes about 10-20 seconds. But now, it takes only 2-3 seconds to finish the first 2 steps, and 2 more seconds for the 3rd step.

Moreover, the sorting and table record filtering is integrated into the table. No redirecting or re-rendering is needed for sorting or filtering, which was needed in the past.

=== Code details ===
Pass Rails controller params to view in tree_display_controller#list
<pre>
angularParams = {}
angularParams[:search] = @search
angularParams[:show] = @show
angularParams[:child_nodes] = @child_nodes
angularParams[:sortvar] = @sortvar
angularParams[:sortorder] = @sortorder
angularParams[:user_id] = session[:user].id
angularParams[:nodeType] = 'FolderNode'
@angularParamsJSON = angularParams.to_json
</pre>

Then the view passes to AngularJS
<pre>
<div ng-controller='TreeCtrl'>
<div ng-init="init('<%= @angularParamsJSON %>')"></div>
</pre>

AngularJS handles it, after all basic elements are loaded onto the page. Then AngularJS initializes a POST request for retrieving more data to populate the table.
<pre>
$scope.init = (value) ->
$scope.angularParams = JSON.parse(value)
$http.post('/tree_display/get_children_node_ng', {
"angularParams": $scope.angularParams
})
.success((data) ->
$scope.tableContent = {}
$scope.displayTableContent = {}
$scope.lastLoadNum = {}
$scope.typeList = []
console.log data
for nodeType, outerNode of data
$scope.tableContent[nodeType] = []
$scope.lastLoadNum[nodeType] = 0
$scope.displayTableContent[nodeType] = []
$scope.typeList.push nodeType
# outerNode is the Assignments/Courses/Questionnaires
for node in outerNode
$scope.tableContent[nodeType].push node
$scope.fetchCellContent(nodeType, node)
$scope.getMoreContent(nodeType, 1)
)
</pre>

Fetch table cell content recursively and put them into a hash
<pre>
$scope.fetchCellContent = (nodeType, node) ->
$scope.newParams = {}
$scope.newParams["sortvar"] = $scope.angularParams["sortvar"]
$scope.newParams["sortorder"] = $scope.angularParams["sortorder"]
$scope.newParams["search"] = $scope.angularParams["search"]
$scope.newParams["show"] = $scope.angularParams["show"]
$scope.newParams["user_id"] = $scope.angularParams["user_id"]
key = node.name + "|" + node.directory
$scope.newParams["key"] = key
# console.log key
if nodeType == 'Assignments'
$scope.newParams["nodeType"] = 'AssignmentNode'
else if nodeType == 'Courses'
$scope.newParams["nodeType"] = 'CourseNode'
else if nodeType == 'Questionnaires'
$scope.newParams["nodeType"] = 'FolderNode'
else
$scope.newParams["nodeType"] = nodeType

$scope.newParams["child_nodes"] = node.nodeinfo
$http.post('/tree_display/get_children_node_2_ng', {
"angularParams": $scope.newParams
})
.success((data) ->
if data.length > 0
for newNode in data
if not $scope.allData[newNode.key]
$scope.allData[newNode.key] = []
$scope.display[newNode.key] = false
$scope.allData[newNode.key].push newNode
$scope.fetchCellContent(newNode.type, newNode)

)
</pre>

After all data is fetched, the Rails view is able to presenting them onto the page!
<pre>
<tbody ng-repeat="record in displayTableContent['Courses'] | filter:searchText | orderBy:predicate:reverse">
<tr ng-click="showCellContent(record.name, record.directory)" class="clickable-row">
<td>{{record.name}}</td>
<td>{{record.directory}}</td>
<td>{{record.creation_date}}</td>
<td>{{record.updated_date}}</td>
<td>

</td>

</tr>
<tr class="no-cursor-tr no-color-tr" ng-if="display[record.name+'|'+record.directory] && allData[record.name+'|'+record.directory]">
<td colspan="3">
<table class="normal-table table table-bordered table-striped compact-table" ng-repeat="cell in cellContent">
<tbody>
<tr class="no-cursor-tr no-color-tr">
<td>Name: {{cell.name}}</td>
</tr>
<tr class="no-cursor-tr no-color-tr">
<td>Directory: {{cell.directory}}</td>
</tr>
<tr class="no-cursor-tr no-color-tr">
<td>Creation Date: {{cell.creation_date}}</td>
</tr>
<tr class="no-cursor-tr no-color-tr">
<td>Modified Date: {{cell.updated_date}}</td>
</tr>
</tbody>
</table>
</td>
</tr>
</tbody>
</pre>

== Manage Users page ==

===Design===

Once logged in, choosing Manage/users option from the navbar, gets us routed to /users page which is defined in list.html.erb file. This file can be broken down to 5 constituents:

1) Fetching Users 
2) Paginating Users 
3) Searching Users 
4) Showing Users 
5) Editing and Deleting Users 

===Code Details===

1) Fetching Users
Fetching users was challenging at first due to an extremely large number of user entries (total of 5300). Fetch of such large data produced a very long delay that was one of the major UX problems in legacy version of Expertiza. This problem has been solved with Angular by sending a post request that gets 300 users and then another post request which gets all the users. This approach provides a quick response and the first 300 users can be seen right away in the form of 3 pages (default set to 100 users per page). While the user is looking at the first couple of entries, the rest of the entries are fetched in the background. This allows for a fast response, full functionality as well as complete data.

In app/assets/javascripts/app.coffee:

<pre>
$scope.getUsers = (fn) ->

$http.post('/users/get_users_ng', {
'fetchNumber': fn
})
.success((receivedUsers) ->
console.log receivedUsers
for user in receivedUsers
$scope.users.push user
$scope.user_display[user.object.id] = false
$scope.editProfileVisible[user.object.id] = false

$scope.fetchNumber+=1
console.log $scope.users.length
console.log $scope.listSize

if $scope.users.length < $scope.listSize
$scope.getUsers($scope.fetchNumber)
)

$scope.getUserListSize = () ->
$http.get('/users/get_users_list_ng')
.success((listSize) ->
$scope.listSize = listSize
)
</pre>

This process is initiated by init() command shown bellow:

<pre>
$scope.init = (value) ->
$scope.user_display = {}
$scope.editProfileVisible = {}
if $scope.users.length == $scope.listSize
return
else if $scope.users.length == 0
$scope.listSize = 0
$scope.getUserListSize()
$scope.fetchNumber = 0
$scope.getUsers(($scope.fetchNumber))
$scope.currentPage = 0
$scope.pagination(50)
</pre>

2) Paginating Users

[[File:Pag_src.png]]

In order to paginate users, a filter needs to be set in order to limit the number of users being shown:

In views/users/list.html.erb:
<pre>
<tbody ng-repeat="user in users | filter:search | startFrom:currentPage*pageSize | limitTo:pageSize">
<tr ng-click="showUser(user.object.id)">
<td>{{user.object.name}}</td>
<td>{{user.object.fullname}}</td>
<td>{{user.object.email}}</td>
<td>{{user.role}}</td>
<td>{{user.parent}}</td>
<td>{{user.email_on_review}}</td>
<td>{{user.email_on_submission}}</td>
<td>{{user.email_on_review_of_review}}</td>
<td>{{user.leaderboard_privacy}}</td>
</tr>
...
</pre>

The startFrom:currentPage*pageSize portion of the filter calls the custom filter startFrom which simply splits the data to display based on the current page of pagination (currentPage), multiplied by the number of users to display (pageSize, which is set by the user selecting either All, 25, 50, 100, or 250).

In app/assets/javascripts/app.coffee:
<pre>
app.filter 'startFrom', ->
(input, start) ->
start = +start
return input.slice start
</pre>

The limitTo:pageSize is a built in angular filter that says to stop displaying users after pageSize of them have been displayed.

The aforementioned pageSize is set by the user through a dropdown; This code tells the dropdown to set the default paginate value to 100 users per page, and upon an ng-change (user selecting a different value), the pagination method will be called in app.coffee, with the appropriate pageSize:

In views/users/list.html.erb:
<pre>
<label>Paginate By:
<select class="form-control" ng-model="paginate" ng-init="paginate='50'" ng-change="pagination(paginate)">
<option value="0">All</option>
<option value="25">25</option>
<option value="50">50</option>
<option value="100">100</option>
<option value="250">250</option>
</select>
</label>
</pre>

This code is in app.coffee, and it posts the pageSize to the set_page_size method in the users_controller, and then sets various variable values based on the results:

In app/assets/javascripts/app.coffee:
<pre>
$scope.pagination = (ps) ->
$http.post('/users/set_page_size', {
'pageSize': ps
})
.success((value) ->
$scope.pageSize = value[0]
$scope.div = value[1]
$scope.totalSize = value[2]
)
</pre>

This code is in users_controller and it takes in the user defined pageSize variable and then determines how many pages are required to divide the data into based off of the pageSize, then returns that variable, plus others:

In app/controllers/user_controller:
<pre>
def set_page_size
ps = params[:pageSize].to_i
user = session[:user]
role = Role.find(user.role_id)
all_users = User.order('name').where( ['role_id in (?) or id = ?', role.get_available_roles, user.id])
users_length = all_users.length
if ps == 0
pageSize = users_length
else
pageSize = ps
end

div = (users_length/pageSize.to_f).ceil

respond_to do |format|
format.html {render json: [pageSize, div, users_length]}
end
end
</pre>

Once the number of pages and pageSize has been set, those numbers are then used to show the current and remaining pages to go along with the previous and next buttons:

In views/users/list.html.erb:
<pre>

<button class="glyphicon glyphicon-chevron-left" ng-disabled="currentPage == 0" ng-click="currentPage=currentPage-1">
</button>
{{currentPage+1}}/{{div}}
<button class="glyphicon glyphicon-chevron-right" ng-disabled="currentPage >= totalSize/pageSize - 1" ng-click="currentPage=currentPage+1">
</button>

</pre>

3) Searching Users

[[File:Pag_src.png]]

In order to search users, a filter also needs to be set in order to limit the number of users being shown:

In views/users/list.html.erb:
<pre>
<tbody ng-repeat="user in users | filter:search | startFrom:currentPage*pageSize | limitTo:pageSize">
<tr ng-click="showUser(user.object.id)">
<td>{{user.object.name}}</td>
<td>{{user.object.fullname}}</td>
<td>{{user.object.email}}</td>
<td>{{user.role}}</td>
<td>{{user.parent}}</td>
<td>{{user.email_on_review}}</td>
<td>{{user.email_on_submission}}</td>
<td>{{user.email_on_review_of_review}}</td>
<td>{{user.leaderboard_privacy}}</td>
</tr>
...
</pre>

The filter:search portion of this code simply applies the following filter criteria; the type of search is determined a dropdown (either search by any field, name, fullname, or email fields). Based on the dropdown selection, the correct search box will be shown, once that search box is show, the search criteria is set to correspond to the type of search specified by the dropdown:

In views/users/list.html.erb:
<pre>
<div class="pull-right form-group">
<div class="form-inline">
<label>Search By:
<select class="form-control" ng-model="searchtype" ng-init="searchtype='any'">
<option value="any">Any</option>
<option value="name">Name</option>
<option value="fullname">Full Name</option>
<option value="email">Email</option>
</select>
</label>
<input class="form-control" ng-hide="searchtype != 'any'" ng-model="search.object.$">
<input class="form-control" ng-hide="searchtype != 'name'" ng-model="search.object.name">
<input class="form-control" ng-hide="searchtype != 'fullname'" ng-model="search.object.fullname">
<input class="form-control" ng-hide="searchtype != 'email'" ng-model="search.object.email">
</div>
</div>
</pre>

4) Showing Users
Clicking on each user name in the table of users uncovers a template that shows the information about that specific user. This is accomplished in a very simple way by setting the profileVisible flag to true. The information about that specific user is extracted from displayedUser object provided by showUser() method from UsersPageCtrl controller in app.coffee file.

In views/users/list.html.erb:
<pre>
<div ng-if="profileVisible == true">
<h1>User: {{displayedUser.object.name}}</h1>
 
<h3>Full Name: {{displayedUser.object.fullname}}</h3>
<h3>Email Address: {{displayedUser.object.email}}</h3>
<h3>Role: {{displayedUser.role}}</h3>
 

<div>
<button ng-click="showTable(true)" type="button" class="btn btn-primary">Back</button>
<button ng-click="editUser()" type="button" class="btn btn-success">Edit</button>
<button ng-click="deleteUser()" type="button" class="btn btn-danger">Delete</button>
</div>
</div>
</pre>

In app/assets/javascripts/app.coffee:

<pre>
$scope.showUser = (user_id) ->
$scope.user_display[user_id] = !$scope.user_display[user_id]
$scope.editProfileVisible[user_id] = false
</pre>
5) Editing and Deleting Users

Editing Users is implemented in a similar way as showing users. The template contains ng-if statement which allows us to display edit page for each user. editUser() method from UsersPageCtrl controller specified in app.coffee displays information of the displayedUser but only after the Save button is clicked it saves the information from displayedUsers into updatedUser variable. POST request with :id parameter is then sent to update method in users_controller of Rails, which then updates this user information in the database.

<pre>
$scope.editUser = (user) ->
# $scope.showUser(false)
$scope.editProfileVisible[user.object.id] = !$scope.editProfileVisible[user.object.id]
$scope.updatedUser = user
</pre>

File:Pag src.png

2015-05-04T04:11:58Z

Rlcoble:

CSC/ECE 517 Spring 2015 E1526

2015-05-04T04:11:28Z

Rlcoble: /* Code Details */

E1526. Responsive web design for Expertiza 

__TOC__

= Strategy =

We analyzed the three Expertiza pages that we need to modify for this project, as well as all of their dependencies, and tried to identify all the tasks that we need to complete for this project. It became clear to us that a large majority of this project will be based on AngularJS, while the small fraction will be related to Bootstrap. Therefore, our strategy was to jumpstart this project by having all 4 team members work together on adding AngularJS to the Login page. Once the Login page was completed, we split in two groups. One group worked on implementing AngularJS on Manage-course page, while the other group worked on introducing AngularJS to Manage-User page.
The reasoning behind this strategy was that all of us working together on the Login page first allowed us to obtain some basic understanding of AngularJS and feel more comfortable using this impressively useful and powerful framework. We completed AngularJS constituents first by connecting some of the Rails controllers to AngularJS controllers and then, as a final step, we add Bootstrap. Our decision was based on the fact that Bootstrap does not require much work to be completed and it can be considered to be a pretty straight-forward element of the project.

= Guide for future students =
1. Learn how to integrate AngularJS into Rails, using Rails original routing system.

2. Learn AngularJS and Coffeescript, since the app.js is written in Coffeescript now.

3. Learn Bootstrap, including the grid system, responsive design and etc.

4. Read the code written by us, to know

a. how to pass data from Rails controller and view to AngularJS;
b. how to pass data back to Rails view from AngularJS;
c. how to convert JSON formatted data using in AngularJS to Rails hash and vice versa.
d. how to present the data to Rails view

= Integration =
This section represent the cornerstone of this project. It consciously explains how Angular and Rails can be integrated into a powerful system capable of providing solid control over both the backend and frontend development of your application.

== Steps to interconnect Rails and AngularJS ==

These guidelines assume that you have a Rails project in place and that you are intending to add AngularJS to it now. Please follow the steps bellow:

1. In the Gemfile, ADD gem ‘bower-rails’ AND gem ‘angular-rails-templates’, then REMOVE ‘gem turbolinks'

2. run <pre> bundle install</pre>

3. Create a Bowerfile. It is used by AngularJS and it can be thought of as the Gemfile that Rails uses.

4. In the Bowerfile, ADD asset ‘angular’ , asset ‘bootstrap-sass-official’, asset ‘angular-route’ AND asset ‘angular-boostrap’(for ui.bootstrap injection)

5. run <pre> rake bower:install </pre>. Bower installs dependencies in vender/assets/bower_components.

6. ADD the following content to the config/application.rb
<pre>
config.assets.paths << Rails.root.join("vendor","assets","bower_components")

config.assets.paths << Rails.root.join("vendor","assets","bower_components","bootstrap-sass-official","assets","fonts")

config.assets.precompile << %r(.*.(?:eot|svg|ttf|woff|woff2)$)

</pre>

7. REMOVE //= require turbolinks AND ADD
<pre>
//= require angular/angular
//= require angular-route/angular-route
//= require angular-rails-templates
//= require angular-bootstrap
</pre>
to assets/javascripts/application.js

8. Rename assets/stylesheets/application.css to assets/stylesheets/application.css.scss.

9. ADD
<pre>
@import "bootstrap-sass-official/assets/stylesheets/bootstrap-sprockets"; and
@import "bootstrap-sass-official/assets/stylesheets/bootstrap";
</pre>
to application.css.scss

Since we are did not get to build a new website using AngularJS from scratch, it was a good idea to retain the routing system of Rails rather than implement it in AngularJS.
So, we added a new tag <code> div ng-app='MPApp'</code> into the app/views/layout/application.html.erb to include all pages into the scope of our AngularJS app, named ‘MPApp’.
Then, for the home page app/views/content_pages/view.html.erb, we added a tag to make this page controlled by ‘testCtrl’, which was defined in app.coffee.

== AngularJS's point of view ==

1. Retrieving data from database
Because it is not appropriate to let AngularJS to directly fetch data from the MySQL database, the only way we could load data was through a Rails controller. For example, it is possible to do a http get/post request(GET /users/fetch_10_users) from AngularJS controller using $http injection or jQuery AJAX, which calls a new method ‘def fetch_10_users’ in the users_controller, which execute some database query via accessing methods in the user model, and returns json formatted data to the AngularJS controller. After getting the returning data, the AngularJS controller can present the data to the screen.

2. Build custom directives
Instead of using the original Rails page, we decided to replace some forms and components using AngularJS directives, which enabled us to do some live modifications to the pages without loading.

== Rails' point of view ==
The initial problem was how to provide entries from the database to AngularJS. We decided to create methods in Rails controller which will listen to the incoming AngulaJS and use a select statement to fetch a couple of entries from the database. These entries are then stored in a hash, converted to json and passed to AngularJS controller. AngularJS will then send another query request to Rails for the next set of entries. This strategy greatly reduces the loading time, making the time needed for representing the page kept at the minimum.

=The specifics=
This section explains the very detailed actions and their results related to the 3 specific pages that were used to integrate AngularJS. Numerous snapshots are provided with the goal to make our approach very clear.

== Login Page and Navigation Bar ==
Login procedure:
‘Login’ button clicked → auth_controller#login → auth_controller#after_login(user) → if user.role != ‘student’ → tree_display#drill → tree_display#list 
If session[:menu] is defined, that is, when a user is logging in, the page will render the content of variable session[:menu].
<pre>
<ul class="nav navbar-nav">
<% if session[:menu] %>
<%= render :partial => 'menu_items/suckerfish',
:locals => { items: session[:menu].get_menu(0), level: 0 } %>
<% end %>
</ul>

<ul class="nav navbar-nav">
<% if session[:menu] %>
<%= render :partial => 'menu_items/suckerfish',
:locals => { items: session[:menu].get_menu(0), level: 0 } %>
<% end %>
</ul>
</pre>

For each menu item in the nav bar, it is a dropdown menu now. For different level of dropdown menu, we apply different CSS style to it.
<pre>
<% level += 1 %>
<% items.each do |item_id|
item = session[:menu].get_item(item_id)
selected = session[:menu].selected?(item.id)
long_name = item.name.split(/\W/).collect{|word| word.capitalize}.join(' ')
%>
<% if level == 1 %>
<li class="dropdown first-level">
<% elsif level == 2 %>
<li class="dropdown-submenu">
<% else %>
<li class="dropdown">
<% end %>
<a href=<%= URI.encode("/menu/#{item.name}") %>
<%= if item.children
' class="daddy"'
end %>title='<%= long_name %>'><%= item.label.html_safe %></a>
<% if item.children -%>
<% if level == 1 %>
<ul class="dropdown-menu multi-level">
<%= render :partial => 'menu_items/suckerfish', :locals => {:items => item.children, :level => level} %>
</ul>
<% else %>
<ul class="dropdown-menu">
<%= render :partial => 'menu_items/suckerfish', :locals => {:items => item.children, :level => level} %>
</ul>
<% end %>
<% end -%>
</li>
<% end -%>
</pre>
Please also refer to app/assets/application.css.scss for further details.

== Manage-course page ==
=== Design ===
After logging in, only the table frame is loaded into the page by rails. Then AngularJS takes over in the background and populate the content into the table. After all first-level content is populated into the table, in this case, all courses info belongs to the first level and their assignment is the second-level content.

After all first level content is loaded into the table, the Angular controller starts to initialize POST request for second level content.

In all, rendering the tree_display page is divided into 3 steps: 
1. render the table frame, 
2. render the first level table content. 
3. fetch deeper level data. 

In the past, these 3 steps are done before rendering the page, which takes about 10-20 seconds. But now, it takes only 2-3 seconds to finish the first 2 steps, and 2 more seconds for the 3rd step.

Moreover, the sorting and table record filtering is integrated into the table. No redirecting or re-rendering is needed for sorting or filtering, which was needed in the past.

=== Code details ===
Pass Rails controller params to view in tree_display_controller#list
<pre>
angularParams = {}
angularParams[:search] = @search
angularParams[:show] = @show
angularParams[:child_nodes] = @child_nodes
angularParams[:sortvar] = @sortvar
angularParams[:sortorder] = @sortorder
angularParams[:user_id] = session[:user].id
angularParams[:nodeType] = 'FolderNode'
@angularParamsJSON = angularParams.to_json
</pre>

Then the view passes to AngularJS
<pre>
<div ng-controller='TreeCtrl'>
<div ng-init="init('<%= @angularParamsJSON %>')"></div>
</pre>

AngularJS handles it, after all basic elements are loaded onto the page. Then AngularJS initializes a POST request for retrieving more data to populate the table.
<pre>
$scope.init = (value) ->
$scope.angularParams = JSON.parse(value)
$http.post('/tree_display/get_children_node_ng', {
"angularParams": $scope.angularParams
})
.success((data) ->
$scope.tableContent = {}
$scope.displayTableContent = {}
$scope.lastLoadNum = {}
$scope.typeList = []
console.log data
for nodeType, outerNode of data
$scope.tableContent[nodeType] = []
$scope.lastLoadNum[nodeType] = 0
$scope.displayTableContent[nodeType] = []
$scope.typeList.push nodeType
# outerNode is the Assignments/Courses/Questionnaires
for node in outerNode
$scope.tableContent[nodeType].push node
$scope.fetchCellContent(nodeType, node)
$scope.getMoreContent(nodeType, 1)
)
</pre>

Fetch table cell content recursively and put them into a hash
<pre>
$scope.fetchCellContent = (nodeType, node) ->
$scope.newParams = {}
$scope.newParams["sortvar"] = $scope.angularParams["sortvar"]
$scope.newParams["sortorder"] = $scope.angularParams["sortorder"]
$scope.newParams["search"] = $scope.angularParams["search"]
$scope.newParams["show"] = $scope.angularParams["show"]
$scope.newParams["user_id"] = $scope.angularParams["user_id"]
key = node.name + "|" + node.directory
$scope.newParams["key"] = key
# console.log key
if nodeType == 'Assignments'
$scope.newParams["nodeType"] = 'AssignmentNode'
else if nodeType == 'Courses'
$scope.newParams["nodeType"] = 'CourseNode'
else if nodeType == 'Questionnaires'
$scope.newParams["nodeType"] = 'FolderNode'
else
$scope.newParams["nodeType"] = nodeType

$scope.newParams["child_nodes"] = node.nodeinfo
$http.post('/tree_display/get_children_node_2_ng', {
"angularParams": $scope.newParams
})
.success((data) ->
if data.length > 0
for newNode in data
if not $scope.allData[newNode.key]
$scope.allData[newNode.key] = []
$scope.display[newNode.key] = false
$scope.allData[newNode.key].push newNode
$scope.fetchCellContent(newNode.type, newNode)

)
</pre>

After all data is fetched, the Rails view is able to presenting them onto the page!
<pre>
<tbody ng-repeat="record in displayTableContent['Courses'] | filter:searchText | orderBy:predicate:reverse">
<tr ng-click="showCellContent(record.name, record.directory)" class="clickable-row">
<td>{{record.name}}</td>
<td>{{record.directory}}</td>
<td>{{record.creation_date}}</td>
<td>{{record.updated_date}}</td>
<td>

</td>

</tr>
<tr class="no-cursor-tr no-color-tr" ng-if="display[record.name+'|'+record.directory] && allData[record.name+'|'+record.directory]">
<td colspan="3">
<table class="normal-table table table-bordered table-striped compact-table" ng-repeat="cell in cellContent">
<tbody>
<tr class="no-cursor-tr no-color-tr">
<td>Name: {{cell.name}}</td>
</tr>
<tr class="no-cursor-tr no-color-tr">
<td>Directory: {{cell.directory}}</td>
</tr>
<tr class="no-cursor-tr no-color-tr">
<td>Creation Date: {{cell.creation_date}}</td>
</tr>
<tr class="no-cursor-tr no-color-tr">
<td>Modified Date: {{cell.updated_date}}</td>
</tr>
</tbody>
</table>
</td>
</tr>
</tbody>
</pre>

== Manage Users page ==

===Design===

Once logged in, choosing Manage/users option from the navbar, gets us routed to /users page which is defined in list.html.erb file. This file can be broken down to 5 constituents:

1) Fetching Users 
2) Paginating Users 
3) Searching Users 
4) Showing Users 
5) Editing and Deleting Users 

===Code Details===

1) Fetching Users
Fetching users was challenging at first due to an extremely large number of user entries (total of 5300). Fetch of such large data produced a very long delay that was one of the major UX problems in legacy version of Expertiza. This problem has been solved with Angular by sending a post request that gets 300 users and then another post request which gets all the users. This approach provides a quick response and the first 300 users can be seen right away in the form of 3 pages (default set to 100 users per page). While the user is looking at the first couple of entries, the rest of the entries are fetched in the background. This allows for a fast response, full functionality as well as complete data.

In app/assets/javascripts/app.coffee:

<pre>
$scope.getUsers = (fn) ->

$http.post('/users/get_users_ng', {
'fetchNumber': fn
})
.success((receivedUsers) ->
console.log receivedUsers
for user in receivedUsers
$scope.users.push user
$scope.user_display[user.object.id] = false
$scope.editProfileVisible[user.object.id] = false

$scope.fetchNumber+=1
console.log $scope.users.length
console.log $scope.listSize

if $scope.users.length < $scope.listSize
$scope.getUsers($scope.fetchNumber)
)

$scope.getUserListSize = () ->
$http.get('/users/get_users_list_ng')
.success((listSize) ->
$scope.listSize = listSize
)
</pre>

This process is initiated by init() command shown bellow:

<pre>
$scope.init = (value) ->
$scope.user_display = {}
$scope.editProfileVisible = {}
if $scope.users.length == $scope.listSize
return
else if $scope.users.length == 0
$scope.listSize = 0
$scope.getUserListSize()
$scope.fetchNumber = 0
$scope.getUsers(($scope.fetchNumber))
$scope.currentPage = 0
$scope.pagination(50)
</pre>

2) Paginating Users

In order to paginate users, a filter needs to be set in order to limit the number of users being shown:

In views/users/list.html.erb:
<pre>
<tbody ng-repeat="user in users | filter:search | startFrom:currentPage*pageSize | limitTo:pageSize">
<tr ng-click="showUser(user.object.id)">
<td>{{user.object.name}}</td>
<td>{{user.object.fullname}}</td>
<td>{{user.object.email}}</td>
<td>{{user.role}}</td>
<td>{{user.parent}}</td>
<td>{{user.email_on_review}}</td>
<td>{{user.email_on_submission}}</td>
<td>{{user.email_on_review_of_review}}</td>
<td>{{user.leaderboard_privacy}}</td>
</tr>
...
</pre>

The startFrom:currentPage*pageSize portion of the filter calls the custom filter startFrom which simply splits the data to display based on the current page of pagination (currentPage), multiplied by the number of users to display (pageSize, which is set by the user selecting either All, 25, 50, 100, or 250).

In app/assets/javascripts/app.coffee:
<pre>
app.filter 'startFrom', ->
(input, start) ->
start = +start
return input.slice start
</pre>

The limitTo:pageSize is a built in angular filter that says to stop displaying users after pageSize of them have been displayed.

The aforementioned pageSize is set by the user through a dropdown; This code tells the dropdown to set the default paginate value to 100 users per page, and upon an ng-change (user selecting a different value), the pagination method will be called in app.coffee, with the appropriate pageSize:

In views/users/list.html.erb:
<pre>
<label>Paginate By:
<select class="form-control" ng-model="paginate" ng-init="paginate='50'" ng-change="pagination(paginate)">
<option value="0">All</option>
<option value="25">25</option>
<option value="50">50</option>
<option value="100">100</option>
<option value="250">250</option>
</select>
</label>
</pre>

This code is in app.coffee, and it posts the pageSize to the set_page_size method in the users_controller, and then sets various variable values based on the results:

In app/assets/javascripts/app.coffee:
<pre>
$scope.pagination = (ps) ->
$http.post('/users/set_page_size', {
'pageSize': ps
})
.success((value) ->
$scope.pageSize = value[0]
$scope.div = value[1]
$scope.totalSize = value[2]
)
</pre>

This code is in users_controller and it takes in the user defined pageSize variable and then determines how many pages are required to divide the data into based off of the pageSize, then returns that variable, plus others:

In app/controllers/user_controller:
<pre>
def set_page_size
ps = params[:pageSize].to_i
user = session[:user]
role = Role.find(user.role_id)
all_users = User.order('name').where( ['role_id in (?) or id = ?', role.get_available_roles, user.id])
users_length = all_users.length
if ps == 0
pageSize = users_length
else
pageSize = ps
end

div = (users_length/pageSize.to_f).ceil

respond_to do |format|
format.html {render json: [pageSize, div, users_length]}
end
end
</pre>

Once the number of pages and pageSize has been set, those numbers are then used to show the current and remaining pages to go along with the previous and next buttons:

In views/users/list.html.erb:
<pre>

<button class="glyphicon glyphicon-chevron-left" ng-disabled="currentPage == 0" ng-click="currentPage=currentPage-1">
</button>
{{currentPage+1}}/{{div}}
<button class="glyphicon glyphicon-chevron-right" ng-disabled="currentPage >= totalSize/pageSize - 1" ng-click="currentPage=currentPage+1">
</button>

</pre>

3) Searching Users
In order to search users, a filter also needs to be set in order to limit the number of users being shown:

In views/users/list.html.erb:
<pre>
<tbody ng-repeat="user in users | filter:search | startFrom:currentPage*pageSize | limitTo:pageSize">
<tr ng-click="showUser(user.object.id)">
<td>{{user.object.name}}</td>
<td>{{user.object.fullname}}</td>
<td>{{user.object.email}}</td>
<td>{{user.role}}</td>
<td>{{user.parent}}</td>
<td>{{user.email_on_review}}</td>
<td>{{user.email_on_submission}}</td>
<td>{{user.email_on_review_of_review}}</td>
<td>{{user.leaderboard_privacy}}</td>
</tr>
...
</pre>

The filter:search portion of this code simply applies the following filter criteria; the type of search is determined a dropdown (either search by any field, name, fullname, or email fields). Based on the dropdown selection, the correct search box will be shown, once that search box is show, the search criteria is set to correspond to the type of search specified by the dropdown:

In views/users/list.html.erb:
<pre>
<div class="pull-right form-group">
<div class="form-inline">
<label>Search By:
<select class="form-control" ng-model="searchtype" ng-init="searchtype='any'">
<option value="any">Any</option>
<option value="name">Name</option>
<option value="fullname">Full Name</option>
<option value="email">Email</option>
</select>
</label>
<input class="form-control" ng-hide="searchtype != 'any'" ng-model="search.object.$">
<input class="form-control" ng-hide="searchtype != 'name'" ng-model="search.object.name">
<input class="form-control" ng-hide="searchtype != 'fullname'" ng-model="search.object.fullname">
<input class="form-control" ng-hide="searchtype != 'email'" ng-model="search.object.email">
</div>
</div>
</pre>

4) Showing Users
Clicking on each user name in the table of users uncovers a template that shows the information about that specific user. This is accomplished in a very simple way by setting the profileVisible flag to true. The information about that specific user is extracted from displayedUser object provided by showUser() method from UsersPageCtrl controller in app.coffee file.

In views/users/list.html.erb:
<pre>
<div ng-if="profileVisible == true">
<h1>User: {{displayedUser.object.name}}</h1>
 
<h3>Full Name: {{displayedUser.object.fullname}}</h3>
<h3>Email Address: {{displayedUser.object.email}}</h3>
<h3>Role: {{displayedUser.role}}</h3>
 

<div>
<button ng-click="showTable(true)" type="button" class="btn btn-primary">Back</button>
<button ng-click="editUser()" type="button" class="btn btn-success">Edit</button>
<button ng-click="deleteUser()" type="button" class="btn btn-danger">Delete</button>
</div>
</div>
</pre>

In app/assets/javascripts/app.coffee:

<pre>
$scope.showUser = (user_id) ->
$scope.user_display[user_id] = !$scope.user_display[user_id]
$scope.editProfileVisible[user_id] = false
</pre>
5) Editing and Deleting Users

Editing Users is implemented in a similar way as showing users. The template contains ng-if statement which allows us to display edit page for each user. editUser() method from UsersPageCtrl controller specified in app.coffee displays information of the displayedUser but only after the Save button is clicked it saves the information from displayedUsers into updatedUser variable. POST request with :id parameter is then sent to update method in users_controller of Rails, which then updates this user information in the database.

<pre>
$scope.editUser = (user) ->
# $scope.showUser(false)
$scope.editProfileVisible[user.object.id] = !$scope.editProfileVisible[user.object.id]
$scope.updatedUser = user
</pre>

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-24T21:06:52Z

Rlcoble:

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

In order to run our code vist: 152.46.20.14:1 (VNC Viewer) or 152.46.20.14:5801 (browser), and use the password: password to log in. Please leave the system like you found it (with the browser open, and set to localhost:3000).

__TOC__

=Introduction to Expertiza=
Expertiza is a web application where students can submit and peer-review learning objects (articles, code, web sites, etc). The Expertiza project is supported by the National Science Foundation.<ref>[http://expertiza.ncsu.edu/ Expertiza]</ref><ref>[http://wikis.lib.ncsu.edu/index.php/Expertiza Wiki]</ref>

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and deleted all of the previous references (action_allowed? gets called automatically)
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|-
| rereview
| Moved logic for sorting response versions, and for getting the latest response to their own methods. The method had some special code that was moved out. Could not move the logic for creating new reviews out of rereview since the new reviews were not created by rereview but instead was using the create method in response_controller.rb
| The rereview method was becoming too large and confusing
|-
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|-
| get_scores
| Moved from controller (response_controller.rb) to model (response.rb)
| The functionality in get_scores makes more sense to be implemented in the Model rather than in the controller
|-
|}

= Re-factored Code =

==Renaming latestResponseVersion method==
The latestResponseVersion method is misnamed. It fetches all the previous versions of a response and its current name does not reflect its actual functionality. The method was renamed as previous_responses since it better suited the actual functionality.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def latestResponseVersion
#get all previous versions of responses for the response map.
@review_scores=Array.new
@prev=Response.where(map_id: @map.id)
for element in @prev
@review_scores << element
end
end
</pre>
<pre>
In method rereview

for element in @prev
if (element.map.id==@map.map.id)
array_not_empty=1
@review_scores << element
end
end
latestResponseVersion
</pre>
<pre>
In method create

@map = ResponseMap.find(params[:id]) #assignment/review/metareview id is in params id
@res = 0
msg = ""
error_msg = ""
latestResponseVersion
</pre>
|<pre>
def previous_responses
#get all previous versions of responses for the response map.
@review_scores=Array.new
@prev=Response.where(map_id: @map.id)
for element in @prev
@review_scores << element
end
end
</pre>
<pre>
In method rereview

@map=ResponseMap.find(params[:id])
# store response content in map
get_content
previous_responses
</pre>
<pre>
In method create

@map = ResponseMap.find(params[:id]) #assignment/review/metareview id is in params id
@res = 0
msg = ""
error_msg = ""
previous_responses
</pre>
|}

==Removing duplicate methods==
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

==Moving code to the proper place==
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method. Moreover, once this code was moved to the action_allowed? method, all of the references to redirect_when_disallowed were removed (action_allowed? gets called automatically).

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def action_allowed?
current_user
end

def redirect_when_disallowed(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|<pre>
def action_allowed?
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if Response.where(id: params[:id]).empty?
true
elsif
response = Response.find(params[:id])
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
current_user_id?(response.map.reviewer.user_id)
end
end
</pre>
|}

==Moving get_scores to the Response Model==
The get_scores method was being implemented in the controller. Its function fits better in the model.
As such, the method was moved and changed to retain the functionality of code that uses it. Since the variables it requires were no longer in scope, they're passed in as arguments. Also due to scope, the result has to be explicitly returned.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In response_controller.rb

def get_scores
@review_scores = []
@question_type = []
@questions.each do |question|
@review_scores << Score
.where(
response_id: @response.id,
question_id: question.id
).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end
</pre>
|<pre>
In response.rb

def get_scores(response, questions)
review_scores = []
question_type = []
questions.each do |question|
review_scores << Score
.where(
response_id: response.id,
question_id: question.id
).first
question_type << QuestionType.find_by_question_id(question.id)
end
question_type
end

</pre>
<pre>
In response_controller.rb

def view
@response = Response.find(params[:id])
@map = @response.map
get_content
@question_type = @response.get_scores(@response, @questions)
end
</pre>
|}

==Moving the sorting of response versions logic out of rereview method==
The code to sort response versions has been moved from rereview method to a separate method. This was done because the rereview method was becoming very long and confusing.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In method rereview

def rereview
@map=ResponseMap.find(params[:id])
get_content
array_not_empty=0
@review_scores=Array.new
@prev=Response.all
#get all versions and find the latest version
for element in @prev
if (element.map.id==@map.map.id)
array_not_empty=1
@review_scores << element
end
end

latestResponseVersion
#sort all the available versions in descending order.
if @prev.present?
@sorted=@review_scores.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@largest_version_num=@sorted[0]
@latest_phase=@largest_version_num.created_at
due_dates = DueDate.where(["assignment_id = ?", @assignment.id])
@sorted_deadlines=Array.new
@sorted_deadlines=due_dates.sort { |m1, m2| (m1.due_at and m2.due_at) ? m1.due_at <=> m2.due_at : (m1.due_at ? -1 : 1) }
current_time=Time.new.getutc
#get the highest version numbered review
next_due_date=@sorted_deadlines[0]
#check in which phase the latest review was done.
for deadline_version in @sorted_deadlines
if (@largest_version_num.created_at < deadline_version.due_at)
break
end
end
</pre>
|<pre>
In method rereview

def rereview
@map=ResponseMap.find(params[:id])

# store response content in map
get_content

previous_responses
#sort all the available versions in descending order.
if @prev.present?
sortResponseVersion
end
</pre>
<pre>
def sortResponseVersion
@sorted=@review_scores.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@largest_version_num=@sorted[0]
@latest_phase=@largest_version_num.created_at
due_dates = DueDate.where(["assignment_id = ?", @assignment.id])
@sorted_deadlines=Array.new
@sorted_deadlines=due_dates.sort { |m1, m2| (m1.due_at and m2.due_at) ? m1.due_at <=> m2.due_at : (m1.due_at ? -1 : 1) }
current_time=Time.new.getutc
#get the highest version numbered review
next_due_date=@sorted_deadlines[0]
#check in which phase the latest review was done.
for deadline_version in @sorted_deadlines
if (@largest_version_num.created_at < deadline_version.due_at)
break
end
end
for deadline_time in @sorted_deadlines
if (current_time < deadline_time.due_at)
break
end
end
end
</pre>
|}

==Removing special code in rereview method==
The rereview method had some special code to check if the current user is jace_smith and uses a custom hard-coded rubric instead of a rubric from the system. This was a code segment that was written when multipart rubrics were first tested. Removing this code will break the assignment and so the code was moved to a separate method and commented as a kludge.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In method rereview

#**********************
# Check whether this is Jen's assgt. & if so, use her rubric
if (@assignment.instructor_id == User.find_by_name("jace_smith").id) && @title == "Review"
if @assignment.id < 469
@next_action = "update"
render :action => 'custom_response'
else
@next_action = "update"
render :action => 'custom_response_2011'
end
else
# end of special code (except for the end below, to match the if above)
#**********************
render :action => 'response'
end
else
#else create a new version and update it.
@header = "New"
@next_action = "create"
@feedback = params[:feedback]
@map = ResponseMap.find(params[:id])
@return = params[:return]
@modified_object = @map.map_id
get_content
#**********************
# Check whether this is Jen's assgt. & if so, use her rubric
if (@assignment.instructor_id == User.find_by_name("jace_smith").id) && @title == "Review"
if @assignment.id < 469
@next_action = "create"
render :action => 'custom_response'
else
@next_action = "create"
render :action => 'custom_response_2011'
end
else
# end of special code (except for the end below, to match the if above)
#**********************
render :action => 'response'
end
end
end
</pre>
|<pre>
In method rereview

# Check whether this is Jen's assgt. & if so, use her rubric
if (@assignment.instructor_id == User.find_by_name("jace_smith").id) && @title == "Review"
handle_jens_assignment
else
render :action => 'response'
end
else
#else create a new version and update it.
@header = "New"
@next_action = "create"
@feedback = params[:feedback]
@map = ResponseMap.find(params[:id])
@return = params[:return]
@modified_object = @map.map_id
get_content
# Check whether this is Jen's assgt. & if so, use her rubric
if (@assignment.instructor_id == User.find_by_name("jace_smith").id) && @title == "Review"
handle_jens_assignment
else
render :action => 'response'
end
end
end
</pre>
<pre>
#kludge for checking if assignment is jen's assignment and using her rubric if it is
def handle_jens_assignment
if @assignment.id < 469
@next_action = "update"
render :action => 'custom_response'
else
@next_action = "update"
render :action => 'custom_response_2011'
end
end
</pre>
|}

=Steps to verify changes=

==Action Allowed==
Action allowed is called before every method call to confirm whether or not the currently logged in user has the required privileges to complete the requested action.
To test the functionality of this method one has to attempt to complete an action that they have privileges to complete, and confirm that they're allowed to complete it. One also has to attempt to complete an action that they don't have the privileges to complete, and confirm that they're not allowed to complete it.

===Allowed===
Log into the application with the user having a student's role (User Id: user5072, Password: password)

# Click on Assignments, and you should see the following:

[[File:actionallowedPass.png]]

===Not Allowed===
Log into the application with the user having an instructor's role (User Id: user6, Password: password)

# Click on Assignments, and you should see the following:

[[File:actionallowedFail.png]]

== get_scores ==
Get scores is called anytime the scores for reviews are shown. Given that, the way to test its correct functionality is to navigate to a completed review and make sure the scores are shown and are correct.

Log into the application with the user having a student's role (User Id: user5072, Password: password)
# Click on Assignments
# Click on Writing assignment 1b, Spring 2013
# Click on Others' Work
# Click on Review done at --2013-03-01 23:57:55 UTC

Successful loading of this page confirms the get_scores method.

== rereview ==
Rereview manages the versioning of multiple reviews for the same assignment. To test the correct functionality of review, one should attempt to update a review (i.e. 'rereview').

Log into the application with the user having a student's role (User Id: user5072, Password: password)
# Click on Assignments
# Click on Writing assignment 1b, Spring 2013
# Click on Others' Work
# Click on Update (beside Metaprogramming in dynamically typed languages)

Successful loading of this page confirms the rereview method.

=References=
<references></references>

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-24T21:06:39Z

Rlcoble:

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

In order to run our code vist: 152.46.20.14:1 (VNC Viewer) or 152.46.20.14:5801 (browser), and use the password: password to log in. Please leave the system like you found it (with the browser open, and set to localhost:3000).

__TOC__

=Introduction to Expertiza=
Expertiza is a web application where students can submit and peer-review learning objects (articles, code, web sites, etc). The Expertiza project is supported by the National Science Foundation.<ref>[http://expertiza.ncsu.edu/ Expertiza]</ref><ref>[http://wikis.lib.ncsu.edu/index.php/Expertiza Wiki]</ref>

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and deleted all of the previous references (action_allowed? gets called automatically)
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|-
| rereview
| Moved logic for sorting response versions, and for getting the latest response to their own methods. The method had some special code that was moved out. Could not move the logic for creating new reviews out of rereview since the new reviews were not created by rereview but instead was using the create method in response_controller.rb
| The rereview method was becoming too large and confusing
|-
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|-
| get_scores
| Moved from controller (response_controller.rb) to model (response.rb)
| The functionality in get_scores makes more sense to be implemented in the Model rather than in the controller
|-
|}

= Re-factored Code =

==Renaming latestResponseVersion method==
The latestResponseVersion method is misnamed. It fetches all the previous versions of a response and its current name does not reflect its actual functionality. The method was renamed as previous_responses since it better suited the actual functionality.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def latestResponseVersion
#get all previous versions of responses for the response map.
@review_scores=Array.new
@prev=Response.where(map_id: @map.id)
for element in @prev
@review_scores << element
end
end
</pre>
<pre>
In method rereview

for element in @prev
if (element.map.id==@map.map.id)
array_not_empty=1
@review_scores << element
end
end
latestResponseVersion
</pre>
<pre>
In method create

@map = ResponseMap.find(params[:id]) #assignment/review/metareview id is in params id
@res = 0
msg = ""
error_msg = ""
latestResponseVersion
</pre>
|<pre>
def previous_responses
#get all previous versions of responses for the response map.
@review_scores=Array.new
@prev=Response.where(map_id: @map.id)
for element in @prev
@review_scores << element
end
end
</pre>
<pre>
In method rereview

@map=ResponseMap.find(params[:id])
# store response content in map
get_content
previous_responses
</pre>
<pre>
In method create

@map = ResponseMap.find(params[:id]) #assignment/review/metareview id is in params id
@res = 0
msg = ""
error_msg = ""
previous_responses
</pre>
|}

==Removing duplicate methods==
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

==Moving code to the proper place==
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method. Moreover, once this code was moved to the action_allowed? method, all of the references to redirect_when_disallowed were removed (action_allowed? gets called automatically).

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def action_allowed?
current_user
end

def redirect_when_disallowed(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|<pre>
def action_allowed?
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if Response.where(id: params[:id]).empty?
true
elsif
response = Response.find(params[:id])
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
current_user_id?(response.map.reviewer.user_id)
end
end
</pre>
|}

==Moving get_scores to the Response Model==
The get_scores method was being implemented in the controller. Its function fits better in the model.
As such, the method was moved and changed to retain the functionality of code that uses it. Since the variables it requires were no longer in scope, they're passed in as arguments. Also due to scope, the result has to be explicitly returned.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In response_controller.rb

def get_scores
@review_scores = []
@question_type = []
@questions.each do |question|
@review_scores << Score
.where(
response_id: @response.id,
question_id: question.id
).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end
</pre>
|<pre>
In response.rb

def get_scores(response, questions)
review_scores = []
question_type = []
questions.each do |question|
review_scores << Score
.where(
response_id: response.id,
question_id: question.id
).first
question_type << QuestionType.find_by_question_id(question.id)
end
question_type
end

</pre>
<pre>
In response_controller.rb

def view
@response = Response.find(params[:id])
@map = @response.map
get_content
@question_type = @response.get_scores(@response, @questions)
end
</pre>
|}

==Moving the sorting of response versions logic out of rereview method==
The code to sort response versions has been moved from rereview method to a separate method. This was done because the rereview method was becoming very long and confusing.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In method rereview

def rereview
@map=ResponseMap.find(params[:id])
get_content
array_not_empty=0
@review_scores=Array.new
@prev=Response.all
#get all versions and find the latest version
for element in @prev
if (element.map.id==@map.map.id)
array_not_empty=1
@review_scores << element
end
end

latestResponseVersion
#sort all the available versions in descending order.
if @prev.present?
@sorted=@review_scores.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@largest_version_num=@sorted[0]
@latest_phase=@largest_version_num.created_at
due_dates = DueDate.where(["assignment_id = ?", @assignment.id])
@sorted_deadlines=Array.new
@sorted_deadlines=due_dates.sort { |m1, m2| (m1.due_at and m2.due_at) ? m1.due_at <=> m2.due_at : (m1.due_at ? -1 : 1) }
current_time=Time.new.getutc
#get the highest version numbered review
next_due_date=@sorted_deadlines[0]
#check in which phase the latest review was done.
for deadline_version in @sorted_deadlines
if (@largest_version_num.created_at < deadline_version.due_at)
break
end
end
</pre>
|<pre>
In method rereview

def rereview
@map=ResponseMap.find(params[:id])

# store response content in map
get_content

previous_responses
#sort all the available versions in descending order.
if @prev.present?
sortResponseVersion
end
</pre>
<pre>
def sortResponseVersion
@sorted=@review_scores.sort { |m1, m2| (m1.version_num and m2.version_num) ? m2.version_num <=> m1.version_num : (m1.version_num ? -1 : 1) }
@largest_version_num=@sorted[0]
@latest_phase=@largest_version_num.created_at
due_dates = DueDate.where(["assignment_id = ?", @assignment.id])
@sorted_deadlines=Array.new
@sorted_deadlines=due_dates.sort { |m1, m2| (m1.due_at and m2.due_at) ? m1.due_at <=> m2.due_at : (m1.due_at ? -1 : 1) }
current_time=Time.new.getutc
#get the highest version numbered review
next_due_date=@sorted_deadlines[0]
#check in which phase the latest review was done.
for deadline_version in @sorted_deadlines
if (@largest_version_num.created_at < deadline_version.due_at)
break
end
end
for deadline_time in @sorted_deadlines
if (current_time < deadline_time.due_at)
break
end
end
end
</pre>
|}

==Removing special code in rereview method==
The rereview method had some special code to check if the current user is jace_smith and uses a custom hard-coded rubric instead of a rubric from the system. This was a code segment that was written when multipart rubrics were first tested. Removing this code will break the assignment and so the code was moved to a separate method and commented as a kludge.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In method rereview

#**********************
# Check whether this is Jen's assgt. & if so, use her rubric
if (@assignment.instructor_id == User.find_by_name("jace_smith").id) && @title == "Review"
if @assignment.id < 469
@next_action = "update"
render :action => 'custom_response'
else
@next_action = "update"
render :action => 'custom_response_2011'
end
else
# end of special code (except for the end below, to match the if above)
#**********************
render :action => 'response'
end
else
#else create a new version and update it.
@header = "New"
@next_action = "create"
@feedback = params[:feedback]
@map = ResponseMap.find(params[:id])
@return = params[:return]
@modified_object = @map.map_id
get_content
#**********************
# Check whether this is Jen's assgt. & if so, use her rubric
if (@assignment.instructor_id == User.find_by_name("jace_smith").id) && @title == "Review"
if @assignment.id < 469
@next_action = "create"
render :action => 'custom_response'
else
@next_action = "create"
render :action => 'custom_response_2011'
end
else
# end of special code (except for the end below, to match the if above)
#**********************
render :action => 'response'
end
end
end
</pre>
|<pre>
In method rereview

# Check whether this is Jen's assgt. & if so, use her rubric
if (@assignment.instructor_id == User.find_by_name("jace_smith").id) && @title == "Review"
handle_jens_assignment
else
render :action => 'response'
end
else
#else create a new version and update it.
@header = "New"
@next_action = "create"
@feedback = params[:feedback]
@map = ResponseMap.find(params[:id])
@return = params[:return]
@modified_object = @map.map_id
get_content
# Check whether this is Jen's assgt. & if so, use her rubric
if (@assignment.instructor_id == User.find_by_name("jace_smith").id) && @title == "Review"
handle_jens_assignment
else
render :action => 'response'
end
end
end
</pre>
<pre>
#kludge for checking if assignment is jen's assignment and using her rubric if it is
def handle_jens_assignment
if @assignment.id < 469
@next_action = "update"
render :action => 'custom_response'
else
@next_action = "update"
render :action => 'custom_response_2011'
end
end
</pre>
|}

=Steps to verify changes=

==Action Allowed==
Action allowed is called before every method call to confirm whether or not the currently logged in user has the required privileges to complete the requested action.
To test the functionality of this method one has to attempt to complete an action that they have privileges to complete, and confirm that they're allowed to complete it. One also has to attempt to complete an action that they don't have the privileges to complete, and confirm that they're not allowed to complete it.

===Allowed===
Log into the application with the user having a student's role (User Id: user5072, Password: password)

# Click on Assignments, and you should see the following:

[[File:actionallowedPass.png]]

===Not Allowed===
Log into the application with the user having an instructor's role (User Id: user6, Password: password)

# Click on Assignments, and you should see the following:

[[File:actionallowedFail.png]]

== get_scores ==
Get scores is called anytime the scores for reviews are shown. Given that, the way to test its correct functionality is to navigate to a completed review and make sure the scores are shown and are correct.

Log into the application with the user having a student's role (User Id: user5072, Password: password)
# Click on Assignments
# Click on Writing assignment 1b, Spring 2013
# Click on Others' Work
# Click on Review done at --2013-03-01 23:57:55 UTC

Successful loading of this page confirms the get_scores method.

== rereview ==
Rereview manages the versioning of multiple reviews for the same assignment. To test the correct functionality of review, one should attempt to update a review (i.e. 'rereview').

Log into the application with the user having a student's role (User Id: user5072, Password: password)
# Click on Assignments
# Click on Writing assignment 1b, Spring 2013
# Click on Others' Work
# Click on Update (beside Metaprogramming in dynamically typed languages)

Successful loading of this page confirms the rereview method.

=References=
<references></references>

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-23T03:54:54Z

Rlcoble: /* Introduction to Expertiza */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

=Introduction to Expertiza=
Expertiza is a web application where students can submit and peer-review learning objects (articles, code, web sites, etc). The Expertiza project is supported by the National Science Foundation.<ref>[http://expertiza.ncsu.edu/ Expertiza]</ref><ref>[http://wikis.lib.ncsu.edu/index.php/Expertiza Wiki]</ref>

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and deleted all of the previous references (action_allowed? gets called automatically)
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|-
| rereview
| Moved logic for sorting response versions, and for getting the latest response to their own methods
| The rereview method was becoming too large and confusing
|-
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|-
| get_scores
| Moved from controller (response_controller.rb) to model (response.rb)
| The functionality in get_scores makes more sense to be implemented in the Model rather than in the controller
|-
|}

= Re-factored Code =

==Removing duplicate methods==
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

==Moving code to the proper place==
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method. Moreover, once this code was moved to the action_allowed? method, all of the references to redirect_when_disallowed were removed (action_allowed? gets called automatically).

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def action_allowed?
current_user
end

def redirect_when_disallowed(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|<pre>
def action_allowed?
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if Response.where(id: params[:id]).empty?
true
elsif
response = Response.find(params[:id])
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
current_user_id?(response.map.reviewer.user_id)
end
end
</pre>
|}

==Moving get_scores to the Response Model==
The get_scores method was being implemented in the controller. Its function fits better in the model.
As such, the method was moved and changed to retain the functionality of code that uses it. Since the variables it requires were no longer in scope, they're passed in as arguments. Also due to scope, the result has to be explicitly returned.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In response_controller.rb

def get_scores
@review_scores = []
@question_type = []
@questions.each do |question|
@review_scores << Score
.where(
response_id: @response.id,
question_id: question.id
).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end
</pre>
|<pre>
In response.rb

def get_scores(response, questions)
review_scores = []
question_type = []
questions.each do |question|
review_scores << Score
.where(
response_id: response.id,
question_id: question.id
).first
question_type << QuestionType.find_by_question_id(question.id)
end
question_type
end

</pre>
<pre>
In response_controller.rb

def view
@response = Response.find(params[:id])
@map = @response.map
get_content
@question_type = @response.get_scores(@response, @questions)
end
</pre>
|}

=Steps to verify changes=

==Action Allowed==
Action allowed is called before every method call to confirm whether or not the currently logged in user has the required privileges to complete the requested action.
To test the functionality of this method one has to attempt to complete an action that they have privileges to complete, and confirm that they're allowed to complete it. One also has to attempt to complete an action that they don't have the privileges to complete, and confirm that they're not allowed to complete it.

===Allowed===
Log into the application with the user having a student's role (User Id: user5072, Password: password)

# Click on Assignments, and you should see the following:

[[File:actionallowedPass.png]]

===Not Allowed===
Log into the application with the user having an instructor's role (User Id: user6, Password: password)

# Click on Assignments, and you should see the following:

[[File:actionallowedFail.png]]

== get_scores ==
Get scores is called anytime the scores for reviews are shown. Given that, the way to test its correct functionality is to navigate to a completed review and make sure the scores are shown and are correct.

Log into the application with the user having a student's role (User Id: user5072, Password: password)
# Click on Assignments
# Click on Writing assignment 1b, Spring 2013
# Click on Others' Work
# Click on Review done at --2013-03-01 23:57:55 UTC

Successful loading of this page confirms the get_scores method.

== rereview ==
Rereview manages the versioning of multiple reviews for the same assignment. To test the correct functionality of review, one should attempt to update a review (i.e. 'rereview').

Log into the application with the user having a student's role (User Id: user5072, Password: password)
# Click on Assignments
# Click on Writing assignment 1b, Spring 2013
# Click on Others' Work
# Click on Update (beside Metaprogramming in dynamically typed languages)

Successful loading of this page confirms the rereview method.

=References=
<references></references>

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-23T03:54:23Z

Rlcoble:

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

=Introduction to Expertiza=
Expertiza is a web application where students can submit and peer-review learning objects (articles, code, web sites, etc). The Expertiza project is supported by the National Science Foundation.<ref>[http://expertiza.ncsu.edu/ Expertiza]</ref><ref>[http://wikis.lib.ncsu.edu/index.php/Expertiza]</ref>

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and deleted all of the previous references (action_allowed? gets called automatically)
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|-
| rereview
| Moved logic for sorting response versions, and for getting the latest response to their own methods
| The rereview method was becoming too large and confusing
|-
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|-
| get_scores
| Moved from controller (response_controller.rb) to model (response.rb)
| The functionality in get_scores makes more sense to be implemented in the Model rather than in the controller
|-
|}

= Re-factored Code =

==Removing duplicate methods==
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

==Moving code to the proper place==
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method. Moreover, once this code was moved to the action_allowed? method, all of the references to redirect_when_disallowed were removed (action_allowed? gets called automatically).

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def action_allowed?
current_user
end

def redirect_when_disallowed(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|<pre>
def action_allowed?
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if Response.where(id: params[:id]).empty?
true
elsif
response = Response.find(params[:id])
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
current_user_id?(response.map.reviewer.user_id)
end
end
</pre>
|}

==Moving get_scores to the Response Model==
The get_scores method was being implemented in the controller. Its function fits better in the model.
As such, the method was moved and changed to retain the functionality of code that uses it. Since the variables it requires were no longer in scope, they're passed in as arguments. Also due to scope, the result has to be explicitly returned.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In response_controller.rb

def get_scores
@review_scores = []
@question_type = []
@questions.each do |question|
@review_scores << Score
.where(
response_id: @response.id,
question_id: question.id
).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end
</pre>
|<pre>
In response.rb

def get_scores(response, questions)
review_scores = []
question_type = []
questions.each do |question|
review_scores << Score
.where(
response_id: response.id,
question_id: question.id
).first
question_type << QuestionType.find_by_question_id(question.id)
end
question_type
end

</pre>
<pre>
In response_controller.rb

def view
@response = Response.find(params[:id])
@map = @response.map
get_content
@question_type = @response.get_scores(@response, @questions)
end
</pre>
|}

=Steps to verify changes=

==Action Allowed==
Action allowed is called before every method call to confirm whether or not the currently logged in user has the required privileges to complete the requested action.
To test the functionality of this method one has to attempt to complete an action that they have privileges to complete, and confirm that they're allowed to complete it. One also has to attempt to complete an action that they don't have the privileges to complete, and confirm that they're not allowed to complete it.

===Allowed===
Log into the application with the user having a student's role (User Id: user5072, Password: password)

# Click on Assignments, and you should see the following:

[[File:actionallowedPass.png]]

===Not Allowed===
Log into the application with the user having an instructor's role (User Id: user6, Password: password)

# Click on Assignments, and you should see the following:

[[File:actionallowedFail.png]]

== get_scores ==
Get scores is called anytime the scores for reviews are shown. Given that, the way to test its correct functionality is to navigate to a completed review and make sure the scores are shown and are correct.

Log into the application with the user having a student's role (User Id: user5072, Password: password)
# Click on Assignments
# Click on Writing assignment 1b, Spring 2013
# Click on Others' Work
# Click on Review done at --2013-03-01 23:57:55 UTC

Successful loading of this page confirms the get_scores method.

== rereview ==
Rereview manages the versioning of multiple reviews for the same assignment. To test the correct functionality of review, one should attempt to update a review (i.e. 'rereview').

Log into the application with the user having a student's role (User Id: user5072, Password: password)
# Click on Assignments
# Click on Writing assignment 1b, Spring 2013
# Click on Others' Work
# Click on Update (beside Metaprogramming in dynamically typed languages)

Successful loading of this page confirms the rereview method.

=References=
<references></references>

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-23T03:49:46Z

Rlcoble: /* rereview */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and deleted all of the previous references (action_allowed? gets called automatically)
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|-
| rereview
| Moved logic for sorting response versions, and for getting the latest response to their own methods
| The rereview method was becoming too large and confusing
|-
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|-
| get_scores
| Moved from controller (response_controller.rb) to model (response.rb)
| The functionality in get_scores makes more sense to be implemented in the Model rather than in the controller
|-
|}

= Re-factored Code =

==Removing duplicate methods==
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

==Moving code to the proper place==
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method. Moreover, once this code was moved to the action_allowed? method, all of the references to redirect_when_disallowed were removed (action_allowed? gets called automatically).

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def action_allowed?
current_user
end

def redirect_when_disallowed(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|<pre>
def action_allowed?
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if Response.where(id: params[:id]).empty?
true
elsif
response = Response.find(params[:id])
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
current_user_id?(response.map.reviewer.user_id)
end
end
</pre>
|}

==Moving get_scores to the Response Model==
The get_scores method was being implemented in the controller. Its function fits better in the model.
As such, the method was moved and changed to retain the functionality of code that uses it. Since the variables it requires were no longer in scope, they're passed in as arguments. Also due to scope, the result has to be explicitly returned.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In response_controller.rb

def get_scores
@review_scores = []
@question_type = []
@questions.each do |question|
@review_scores << Score
.where(
response_id: @response.id,
question_id: question.id
).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end
</pre>
|<pre>
In response.rb

def get_scores(response, questions)
review_scores = []
question_type = []
questions.each do |question|
review_scores << Score
.where(
response_id: response.id,
question_id: question.id
).first
question_type << QuestionType.find_by_question_id(question.id)
end
question_type
end

</pre>
<pre>
In response_controller.rb

def view
@response = Response.find(params[:id])
@map = @response.map
get_content
@question_type = @response.get_scores(@response, @questions)
end
</pre>
|}

=Steps to verify changes=

==Action Allowed==
Action allowed is called before every method call to confirm whether or not the currently logged in user has the required privileges to complete the requested action.
To test the functionality of this method one has to attempt to complete an action that they have privileges to complete, and confirm that they're allowed to complete it. One also has to attempt to complete an action that they don't have the privileges to complete, and confirm that they're not allowed to complete it.

===Allowed===
Log into the application with the user having a student's role (User Id: user5072, Password: password)

# Click on Assignments, and you should see the following:

[[File:actionallowedPass.png]]

===Not Allowed===
Log into the application with the user having an instructor's role (User Id: user6, Password: password)

# Click on Assignments, and you should see the following:

[[File:actionallowedFail.png]]

== get_scores ==
Get scores is called anytime the scores for reviews are shown. Given that, the way to test its correct functionality is to navigate to a completed review and make sure the scores are shown and are correct.

Log into the application with the user having a student's role (User Id: user5072, Password: password)
# Click on Assignments
# Click on Writing assignment 1b, Spring 2013
# Click on Others' Work
# Click on Review done at --2013-03-01 23:57:55 UTC

Successful loading of this page confirms the get_scores method.

== rereview ==
Rereview manages the versioning of multiple reviews for the same assignment. To test the correct functionality of review, one should attempt to update a review (i.e. 'rereview').

Log into the application with the user having a student's role (User Id: user5072, Password: password)
# Click on Assignments
# Click on Writing assignment 1b, Spring 2013
# Click on Others' Work
# Click on Update (beside Metaprogramming in dynamically typed languages)

Successful loading of this page confirms the rereview method.

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-23T03:49:24Z

Rlcoble: /* Steps to verify changes */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and deleted all of the previous references (action_allowed? gets called automatically)
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|-
| rereview
| Moved logic for sorting response versions, and for getting the latest response to their own methods
| The rereview method was becoming too large and confusing
|-
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|-
| get_scores
| Moved from controller (response_controller.rb) to model (response.rb)
| The functionality in get_scores makes more sense to be implemented in the Model rather than in the controller
|-
|}

= Re-factored Code =

==Removing duplicate methods==
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

==Moving code to the proper place==
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method. Moreover, once this code was moved to the action_allowed? method, all of the references to redirect_when_disallowed were removed (action_allowed? gets called automatically).

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def action_allowed?
current_user
end

def redirect_when_disallowed(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|<pre>
def action_allowed?
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if Response.where(id: params[:id]).empty?
true
elsif
response = Response.find(params[:id])
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
current_user_id?(response.map.reviewer.user_id)
end
end
</pre>
|}

==Moving get_scores to the Response Model==
The get_scores method was being implemented in the controller. Its function fits better in the model.
As such, the method was moved and changed to retain the functionality of code that uses it. Since the variables it requires were no longer in scope, they're passed in as arguments. Also due to scope, the result has to be explicitly returned.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In response_controller.rb

def get_scores
@review_scores = []
@question_type = []
@questions.each do |question|
@review_scores << Score
.where(
response_id: @response.id,
question_id: question.id
).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end
</pre>
|<pre>
In response.rb

def get_scores(response, questions)
review_scores = []
question_type = []
questions.each do |question|
review_scores << Score
.where(
response_id: response.id,
question_id: question.id
).first
question_type << QuestionType.find_by_question_id(question.id)
end
question_type
end

</pre>
<pre>
In response_controller.rb

def view
@response = Response.find(params[:id])
@map = @response.map
get_content
@question_type = @response.get_scores(@response, @questions)
end
</pre>
|}

=Steps to verify changes=

==Action Allowed==
Action allowed is called before every method call to confirm whether or not the currently logged in user has the required privileges to complete the requested action.
To test the functionality of this method one has to attempt to complete an action that they have privileges to complete, and confirm that they're allowed to complete it. One also has to attempt to complete an action that they don't have the privileges to complete, and confirm that they're not allowed to complete it.

===Allowed===
Log into the application with the user having a student's role (User Id: user5072, Password: password)

# Click on Assignments, and you should see the following:

[[File:actionallowedPass.png]]

===Not Allowed===
Log into the application with the user having an instructor's role (User Id: user6, Password: password)

# Click on Assignments, and you should see the following:

[[File:actionallowedFail.png]]

== get_scores ==
Get scores is called anytime the scores for reviews are shown. Given that, the way to test its correct functionality is to navigate to a completed review and make sure the scores are shown and are correct.

Log into the application with the user having a student's role (User Id: user5072, Password: password)
# Click on Assignments
# Click on Writing assignment 1b, Spring 2013
# Click on Others' Work
# Click on Review done at --2013-03-01 23:57:55 UTC

Successful loading of this page confirms the get_scores method.

== rereview ==
Rereview manages the versioning of multiple reviews for the same assignment. To test the correct functionality of review, one should attempt to update a review ( i.e. 'rereview' )

Log into the application with the user having a student's role (User Id: user5072, Password: password)
# Click on Assignments
# Click on Writing assignment 1b, Spring 2013
# Click on Others' Work
# Click on Update (beside Metaprogramming in dynamically typed languages)

Successful loading of this page confirms the rereview method.

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-23T03:42:50Z

Rlcoble: /* get_scores & rereview */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and deleted all of the previous references (action_allowed? gets called automatically)
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|-
| rereview
| Moved logic for sorting response versions, and for getting the latest response to their own methods
| The rereview method was becoming too large and confusing
|-
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|-
| get_scores
| Moved from controller (response_controller.rb) to model (response.rb)
| The functionality in get_scores makes more sense to be implemented in the Model rather than in the controller
|-
|}

= Re-factored Code =

==Removing duplicate methods==
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

==Moving code to the proper place==
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method. Moreover, once this code was moved to the action_allowed? method, all of the references to redirect_when_disallowed were removed (action_allowed? gets called automatically).

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def action_allowed?
current_user
end

def redirect_when_disallowed(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|<pre>
def action_allowed?
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if Response.where(id: params[:id]).empty?
true
elsif
response = Response.find(params[:id])
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
current_user_id?(response.map.reviewer.user_id)
end
end
</pre>
|}

==Moving get_scores to the Response Model==
The get_scores method was being implemented in the controller. Its function fits better in the model.
As such, the method was moved and changed to retain the functionality of code that uses it. Since the variables it requires were no longer in scope, they're passed in as arguments. Also due to scope, the result has to be explicitly returned.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In response_controller.rb

def get_scores
@review_scores = []
@question_type = []
@questions.each do |question|
@review_scores << Score
.where(
response_id: @response.id,
question_id: question.id
).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end
</pre>
|<pre>
In response.rb

def get_scores(response, questions)
review_scores = []
question_type = []
questions.each do |question|
review_scores << Score
.where(
response_id: response.id,
question_id: question.id
).first
question_type << QuestionType.find_by_question_id(question.id)
end
question_type
end

</pre>
<pre>
In response_controller.rb

def view
@response = Response.find(params[:id])
@map = @response.map
get_content
@question_type = @response.get_scores(@response, @questions)
end
</pre>
|}

=Steps to verify changes=

==Action Allowed==
Action allowed is called before every method call to confirm whether or not the currently logged in user has the required privileges to complete the requested action.
To test the functionality of this method one has to attempt to complete an action that they have privileges to complete, and confirm that they're allowed to complete it. One also has to attempt to complete an action that they don't have the privileges to complete, and confirm that they're not allowed to complete it.

===Allowed===
Log into the application with the user having a student's role (User Id: user5072, Password: password)

# Click on Assignments, and you should see the following:

[[File:actionallowedPass.png]]

===Not Allowed===
Log into the application with the user having an instructor's role (User Id: user6, Password: password)

# Click on Assignments, and you should see the following:

[[File:actionallowedFail.png]]

== get_scores & rereview ==
Get scores is called anytime the scores for reviews are shown. Given that, the way to test its correct functionality is to navigate to a completed review and make sure the scores are shown and are correct.
 Rereview manages the versioning of multiple reviews for the same assignment. To test the correct functionality of review, one should attempt to update a review ( i.e. 'rereview' )
 Both of these methods can be tested by following these steps:

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-23T03:42:30Z

Rlcoble: /* get_scores & rereview */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and deleted all of the previous references (action_allowed? gets called automatically)
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|-
| rereview
| Moved logic for sorting response versions, and for getting the latest response to their own methods
| The rereview method was becoming too large and confusing
|-
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|-
| get_scores
| Moved from controller (response_controller.rb) to model (response.rb)
| The functionality in get_scores makes more sense to be implemented in the Model rather than in the controller
|-
|}

= Re-factored Code =

==Removing duplicate methods==
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

==Moving code to the proper place==
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method. Moreover, once this code was moved to the action_allowed? method, all of the references to redirect_when_disallowed were removed (action_allowed? gets called automatically).

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def action_allowed?
current_user
end

def redirect_when_disallowed(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|<pre>
def action_allowed?
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if Response.where(id: params[:id]).empty?
true
elsif
response = Response.find(params[:id])
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
current_user_id?(response.map.reviewer.user_id)
end
end
</pre>
|}

==Moving get_scores to the Response Model==
The get_scores method was being implemented in the controller. Its function fits better in the model.
As such, the method was moved and changed to retain the functionality of code that uses it. Since the variables it requires were no longer in scope, they're passed in as arguments. Also due to scope, the result has to be explicitly returned.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In response_controller.rb

def get_scores
@review_scores = []
@question_type = []
@questions.each do |question|
@review_scores << Score
.where(
response_id: @response.id,
question_id: question.id
).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end
</pre>
|<pre>
In response.rb

def get_scores(response, questions)
review_scores = []
question_type = []
questions.each do |question|
review_scores << Score
.where(
response_id: response.id,
question_id: question.id
).first
question_type << QuestionType.find_by_question_id(question.id)
end
question_type
end

</pre>
<pre>
In response_controller.rb

def view
@response = Response.find(params[:id])
@map = @response.map
get_content
@question_type = @response.get_scores(@response, @questions)
end
</pre>
|}

=Steps to verify changes=

==Action Allowed==
Action allowed is called before every method call to confirm whether or not the currently logged in user has the required privileges to complete the requested action.
To test the functionality of this method one has to attempt to complete an action that they have privileges to complete, and confirm that they're allowed to complete it. One also has to attempt to complete an action that they don't have the privileges to complete, and confirm that they're not allowed to complete it.

===Allowed===
Log into the application with the user having a student's role (User Id: user5072, Password: password)

# Click on Assignments, and you should see the following:

[[File:actionallowedPass.png]]

===Not Allowed===
Log into the application with the user having an instructor's role (User Id: user6, Password: password)

# Click on Assignments, and you should see the following:

[[File:actionallowedFail.png]]

== get_scores & rereview ==
Get scores is called anytime the scores for reviews are shown. Given that, the way to test its correct functionality is to navigate to a completed review and make sure the scores are shown and are correct.
Rereview manages the versioning of multiple reviews for the same assignment. To test the correct functionality of review, one should attempt to update a review ( i.e. 'rereview' )
Both of these methods can be tested by following these steps:

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-23T03:42:11Z

Rlcoble: /* Action Allowed */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and deleted all of the previous references (action_allowed? gets called automatically)
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|-
| rereview
| Moved logic for sorting response versions, and for getting the latest response to their own methods
| The rereview method was becoming too large and confusing
|-
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|-
| get_scores
| Moved from controller (response_controller.rb) to model (response.rb)
| The functionality in get_scores makes more sense to be implemented in the Model rather than in the controller
|-
|}

= Re-factored Code =

==Removing duplicate methods==
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

==Moving code to the proper place==
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method. Moreover, once this code was moved to the action_allowed? method, all of the references to redirect_when_disallowed were removed (action_allowed? gets called automatically).

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def action_allowed?
current_user
end

def redirect_when_disallowed(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|<pre>
def action_allowed?
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if Response.where(id: params[:id]).empty?
true
elsif
response = Response.find(params[:id])
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
current_user_id?(response.map.reviewer.user_id)
end
end
</pre>
|}

==Moving get_scores to the Response Model==
The get_scores method was being implemented in the controller. Its function fits better in the model.
As such, the method was moved and changed to retain the functionality of code that uses it. Since the variables it requires were no longer in scope, they're passed in as arguments. Also due to scope, the result has to be explicitly returned.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In response_controller.rb

def get_scores
@review_scores = []
@question_type = []
@questions.each do |question|
@review_scores << Score
.where(
response_id: @response.id,
question_id: question.id
).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end
</pre>
|<pre>
In response.rb

def get_scores(response, questions)
review_scores = []
question_type = []
questions.each do |question|
review_scores << Score
.where(
response_id: response.id,
question_id: question.id
).first
question_type << QuestionType.find_by_question_id(question.id)
end
question_type
end

</pre>
<pre>
In response_controller.rb

def view
@response = Response.find(params[:id])
@map = @response.map
get_content
@question_type = @response.get_scores(@response, @questions)
end
</pre>
|}

=Steps to verify changes=

==Action Allowed==
Action allowed is called before every method call to confirm whether or not the currently logged in user has the required privileges to complete the requested action.
To test the functionality of this method one has to attempt to complete an action that they have privileges to complete, and confirm that they're allowed to complete it. One also has to attempt to complete an action that they don't have the privileges to complete, and confirm that they're not allowed to complete it.

===Allowed===
Log into the application with the user having a student's role (User Id: user5072, Password: password)

# Click on Assignments, and you should see the following:

[[File:actionallowedPass.png]]

===Not Allowed===
Log into the application with the user having an instructor's role (User Id: user6, Password: password)

# Click on Assignments, and you should see the following:

[[File:actionallowedFail.png]]

== get_scores & rereview ==
Get scores is called anytime the scores for reviews are shown. Given that, the way to test its correct functionality is to navigate to a completed review and make sure the scores are shown and are correct.
Rereview manages the versioning of multiple reviews for the same assignment. To test the correct functionality of review, one should attempt to update a review ( i.e. 'rereview' )
Both of these methods can be tested by following these steps:

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-23T03:41:49Z

Rlcoble: /* Steps to verify changes */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and deleted all of the previous references (action_allowed? gets called automatically)
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|-
| rereview
| Moved logic for sorting response versions, and for getting the latest response to their own methods
| The rereview method was becoming too large and confusing
|-
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|-
| get_scores
| Moved from controller (response_controller.rb) to model (response.rb)
| The functionality in get_scores makes more sense to be implemented in the Model rather than in the controller
|-
|}

= Re-factored Code =

==Removing duplicate methods==
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

==Moving code to the proper place==
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method. Moreover, once this code was moved to the action_allowed? method, all of the references to redirect_when_disallowed were removed (action_allowed? gets called automatically).

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def action_allowed?
current_user
end

def redirect_when_disallowed(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|<pre>
def action_allowed?
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if Response.where(id: params[:id]).empty?
true
elsif
response = Response.find(params[:id])
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
current_user_id?(response.map.reviewer.user_id)
end
end
</pre>
|}

==Moving get_scores to the Response Model==
The get_scores method was being implemented in the controller. Its function fits better in the model.
As such, the method was moved and changed to retain the functionality of code that uses it. Since the variables it requires were no longer in scope, they're passed in as arguments. Also due to scope, the result has to be explicitly returned.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In response_controller.rb

def get_scores
@review_scores = []
@question_type = []
@questions.each do |question|
@review_scores << Score
.where(
response_id: @response.id,
question_id: question.id
).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end
</pre>
|<pre>
In response.rb

def get_scores(response, questions)
review_scores = []
question_type = []
questions.each do |question|
review_scores << Score
.where(
response_id: response.id,
question_id: question.id
).first
question_type << QuestionType.find_by_question_id(question.id)
end
question_type
end

</pre>
<pre>
In response_controller.rb

def view
@response = Response.find(params[:id])
@map = @response.map
get_content
@question_type = @response.get_scores(@response, @questions)
end
</pre>
|}

=Steps to verify changes=

==Action Allowed==
Action allowed is called before every method call to confirm whether or not the currently logged in user has the required privileges to complete the requested action.
To test the functionality of this method one has to attempt to complete an action that they have privileges to complete, and confirm that they're allowed to complete it. One also has to attempt to complete an action that they don't have the privileges to complete, and confirm that they're not allowed to complete it.

===Allowed===
Log into the application with the user having a student's role (User Id: user5072, Password: password)

1. Click on Assignments, and you should see the following:

[[File:actionallowedPass.png]]

===Not Allowed===
Log into the application with the user having an instructor's role (User Id: user6, Password: password)

1. Click on Assignments, and you should see the following:

[[File:actionallowedFail.png]]

== get_scores & rereview ==
Get scores is called anytime the scores for reviews are shown. Given that, the way to test its correct functionality is to navigate to a completed review and make sure the scores are shown and are correct.
Rereview manages the versioning of multiple reviews for the same assignment. To test the correct functionality of review, one should attempt to update a review ( i.e. 'rereview' )
Both of these methods can be tested by following these steps:

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-23T03:40:41Z

Rlcoble: /* get_scores */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and deleted all of the previous references (action_allowed? gets called automatically)
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|-
| rereview
| Moved logic for sorting response versions, and for getting the latest response to their own methods
| The rereview method was becoming too large and confusing
|-
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|-
| get_scores
| Moved from controller (response_controller.rb) to model (response.rb)
| The functionality in get_scores makes more sense to be implemented in the Model rather than in the controller
|-
|}

= Re-factored Code =

==Removing duplicate methods==
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

==Moving code to the proper place==
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method. Moreover, once this code was moved to the action_allowed? method, all of the references to redirect_when_disallowed were removed (action_allowed? gets called automatically).

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def action_allowed?
current_user
end

def redirect_when_disallowed(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|<pre>
def action_allowed?
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if Response.where(id: params[:id]).empty?
true
elsif
response = Response.find(params[:id])
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
current_user_id?(response.map.reviewer.user_id)
end
end
</pre>
|}

==Moving get_scores to the Response Model==
The get_scores method was being implemented in the controller. Its function fits better in the model.
As such, the method was moved and changed to retain the functionality of code that uses it. Since the variables it requires were no longer in scope, they're passed in as arguments. Also due to scope, the result has to be explicitly returned.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In response_controller.rb

def get_scores
@review_scores = []
@question_type = []
@questions.each do |question|
@review_scores << Score
.where(
response_id: @response.id,
question_id: question.id
).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end
</pre>
|<pre>
In response.rb

def get_scores(response, questions)
review_scores = []
question_type = []
questions.each do |question|
review_scores << Score
.where(
response_id: response.id,
question_id: question.id
).first
question_type << QuestionType.find_by_question_id(question.id)
end
question_type
end

</pre>
<pre>
In response_controller.rb

def view
@response = Response.find(params[:id])
@map = @response.map
get_content
@question_type = @response.get_scores(@response, @questions)
end
</pre>
|}

=Steps to verify changes=

==Action Allowed==
Action allowed is called before every method call to confirm whether or not the currently logged in user has the required privileges to complete the requested action.
To test the functionality of this method one has to attempt to complete an action that they have privileges to complete, and confirm that they're allowed to complete it. One also has to attempt to complete an action that they don't have the privileges to complete, and confirm that they're not allowed to complete it.

===Allowed===
Log into the application with the user having a student's role (User Id: user5072, Password: password)

1. Click on Assignments, and you should see the following:

[[File:actionallowedPass.png]]

===Not Allowed===
Log into the application with the user having an instructor's role (User Id: user6, Password: password)

1. Click on Assignments, and you should see the following:

[[File:actionallowedFail.png]]

== get_scores & rereview ==
Get scores is called anytime the scores for reviews are shown. Given that, the way to test its correct functionality is to navigate to a completed review and make sure the scores are shown and are correct

ADD STEPS HERE

==== rereview ====
Rereview manages the versioning of multiple reviews for the same assignment. To test the correct functionality of review, one should attempt to update a review ( i.e. 'rereview' )

ADD STEPS HERE

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-23T03:40:13Z

Rlcoble: /* Not Allowed */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and deleted all of the previous references (action_allowed? gets called automatically)
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|-
| rereview
| Moved logic for sorting response versions, and for getting the latest response to their own methods
| The rereview method was becoming too large and confusing
|-
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|-
| get_scores
| Moved from controller (response_controller.rb) to model (response.rb)
| The functionality in get_scores makes more sense to be implemented in the Model rather than in the controller
|-
|}

= Re-factored Code =

==Removing duplicate methods==
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

==Moving code to the proper place==
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method. Moreover, once this code was moved to the action_allowed? method, all of the references to redirect_when_disallowed were removed (action_allowed? gets called automatically).

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def action_allowed?
current_user
end

def redirect_when_disallowed(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|<pre>
def action_allowed?
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if Response.where(id: params[:id]).empty?
true
elsif
response = Response.find(params[:id])
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
current_user_id?(response.map.reviewer.user_id)
end
end
</pre>
|}

==Moving get_scores to the Response Model==
The get_scores method was being implemented in the controller. Its function fits better in the model.
As such, the method was moved and changed to retain the functionality of code that uses it. Since the variables it requires were no longer in scope, they're passed in as arguments. Also due to scope, the result has to be explicitly returned.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In response_controller.rb

def get_scores
@review_scores = []
@question_type = []
@questions.each do |question|
@review_scores << Score
.where(
response_id: @response.id,
question_id: question.id
).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end
</pre>
|<pre>
In response.rb

def get_scores(response, questions)
review_scores = []
question_type = []
questions.each do |question|
review_scores << Score
.where(
response_id: response.id,
question_id: question.id
).first
question_type << QuestionType.find_by_question_id(question.id)
end
question_type
end

</pre>
<pre>
In response_controller.rb

def view
@response = Response.find(params[:id])
@map = @response.map
get_content
@question_type = @response.get_scores(@response, @questions)
end
</pre>
|}

=Steps to verify changes=

==Action Allowed==
Action allowed is called before every method call to confirm whether or not the currently logged in user has the required privileges to complete the requested action.
To test the functionality of this method one has to attempt to complete an action that they have privileges to complete, and confirm that they're allowed to complete it. One also has to attempt to complete an action that they don't have the privileges to complete, and confirm that they're not allowed to complete it.

===Allowed===
Log into the application with the user having a student's role (User Id: user5072, Password: password)

1. Click on Assignments, and you should see the following:

[[File:actionallowedPass.png]]

===Not Allowed===
Log into the application with the user having an instructor's role (User Id: user6, Password: password)

1. Click on Assignments, and you should see the following:

[[File:actionallowedFail.png]]

==== get_scores ====
Get scores is called anytime the scores for reviews are shown. Given that, the way to test its correct functionality is to navigate to a completed review and make sure the scores are shown and are correct

ADD STEPS HERE

==== rereview ====
Rereview manages the versioning of multiple reviews for the same assignment. To test the correct functionality of review, one should attempt to update a review ( i.e. 'rereview' )

ADD STEPS HERE

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-23T03:39:52Z

Rlcoble: /* Allowed */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and deleted all of the previous references (action_allowed? gets called automatically)
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|-
| rereview
| Moved logic for sorting response versions, and for getting the latest response to their own methods
| The rereview method was becoming too large and confusing
|-
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|-
| get_scores
| Moved from controller (response_controller.rb) to model (response.rb)
| The functionality in get_scores makes more sense to be implemented in the Model rather than in the controller
|-
|}

= Re-factored Code =

==Removing duplicate methods==
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

==Moving code to the proper place==
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method. Moreover, once this code was moved to the action_allowed? method, all of the references to redirect_when_disallowed were removed (action_allowed? gets called automatically).

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def action_allowed?
current_user
end

def redirect_when_disallowed(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|<pre>
def action_allowed?
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if Response.where(id: params[:id]).empty?
true
elsif
response = Response.find(params[:id])
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
current_user_id?(response.map.reviewer.user_id)
end
end
</pre>
|}

==Moving get_scores to the Response Model==
The get_scores method was being implemented in the controller. Its function fits better in the model.
As such, the method was moved and changed to retain the functionality of code that uses it. Since the variables it requires were no longer in scope, they're passed in as arguments. Also due to scope, the result has to be explicitly returned.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In response_controller.rb

def get_scores
@review_scores = []
@question_type = []
@questions.each do |question|
@review_scores << Score
.where(
response_id: @response.id,
question_id: question.id
).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end
</pre>
|<pre>
In response.rb

def get_scores(response, questions)
review_scores = []
question_type = []
questions.each do |question|
review_scores << Score
.where(
response_id: response.id,
question_id: question.id
).first
question_type << QuestionType.find_by_question_id(question.id)
end
question_type
end

</pre>
<pre>
In response_controller.rb

def view
@response = Response.find(params[:id])
@map = @response.map
get_content
@question_type = @response.get_scores(@response, @questions)
end
</pre>
|}

=Steps to verify changes=

==Action Allowed==
Action allowed is called before every method call to confirm whether or not the currently logged in user has the required privileges to complete the requested action.
To test the functionality of this method one has to attempt to complete an action that they have privileges to complete, and confirm that they're allowed to complete it. One also has to attempt to complete an action that they don't have the privileges to complete, and confirm that they're not allowed to complete it.

===Allowed===
Log into the application with the user having a student's role (User Id: user5072, Password: password)

1. Click on Assignments, and you should see the following:

[[File:actionallowedPass.png]]

==Not Allowed==
Log into the application with the user having an instructor's role (User Id: user6, Password: password)

1. Click on Assignments, and you should see the following:

[[File:actionallowedFail.png]]

=== get_scores ===
Get scores is called anytime the scores for reviews are shown. Given that, the way to test its correct functionality is to navigate to a completed review and make sure the scores are shown and are correct

ADD STEPS HERE

=== rereview ===
Rereview manages the versioning of multiple reviews for the same assignment. To test the correct functionality of review, one should attempt to update a review ( i.e. 'rereview' )

ADD STEPS HERE

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-23T03:39:41Z

Rlcoble: /* Action Allowed */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and deleted all of the previous references (action_allowed? gets called automatically)
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|-
| rereview
| Moved logic for sorting response versions, and for getting the latest response to their own methods
| The rereview method was becoming too large and confusing
|-
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|-
| get_scores
| Moved from controller (response_controller.rb) to model (response.rb)
| The functionality in get_scores makes more sense to be implemented in the Model rather than in the controller
|-
|}

= Re-factored Code =

==Removing duplicate methods==
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

==Moving code to the proper place==
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method. Moreover, once this code was moved to the action_allowed? method, all of the references to redirect_when_disallowed were removed (action_allowed? gets called automatically).

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def action_allowed?
current_user
end

def redirect_when_disallowed(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|<pre>
def action_allowed?
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if Response.where(id: params[:id]).empty?
true
elsif
response = Response.find(params[:id])
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
current_user_id?(response.map.reviewer.user_id)
end
end
</pre>
|}

==Moving get_scores to the Response Model==
The get_scores method was being implemented in the controller. Its function fits better in the model.
As such, the method was moved and changed to retain the functionality of code that uses it. Since the variables it requires were no longer in scope, they're passed in as arguments. Also due to scope, the result has to be explicitly returned.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In response_controller.rb

def get_scores
@review_scores = []
@question_type = []
@questions.each do |question|
@review_scores << Score
.where(
response_id: @response.id,
question_id: question.id
).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end
</pre>
|<pre>
In response.rb

def get_scores(response, questions)
review_scores = []
question_type = []
questions.each do |question|
review_scores << Score
.where(
response_id: response.id,
question_id: question.id
).first
question_type << QuestionType.find_by_question_id(question.id)
end
question_type
end

</pre>
<pre>
In response_controller.rb

def view
@response = Response.find(params[:id])
@map = @response.map
get_content
@question_type = @response.get_scores(@response, @questions)
end
</pre>
|}

=Steps to verify changes=

==Action Allowed==
Action allowed is called before every method call to confirm whether or not the currently logged in user has the required privileges to complete the requested action.
To test the functionality of this method one has to attempt to complete an action that they have privileges to complete, and confirm that they're allowed to complete it. One also has to attempt to complete an action that they don't have the privileges to complete, and confirm that they're not allowed to complete it.

==Allowed==
Log into the application with the user having a student's role (User Id: user5072, Password: password)

1. Click on Assignments, and you should see the following:

[[File:actionallowedPass.png]]

==Not Allowed==
Log into the application with the user having an instructor's role (User Id: user6, Password: password)

1. Click on Assignments, and you should see the following:

[[File:actionallowedFail.png]]

=== get_scores ===
Get scores is called anytime the scores for reviews are shown. Given that, the way to test its correct functionality is to navigate to a completed review and make sure the scores are shown and are correct

ADD STEPS HERE

=== rereview ===
Rereview manages the versioning of multiple reviews for the same assignment. To test the correct functionality of review, one should attempt to update a review ( i.e. 'rereview' )

ADD STEPS HERE

File:ActionallowedPass.png

2015-03-23T03:08:24Z

Rlcoble:

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-23T03:08:02Z

Rlcoble: /* Action Allowed */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and deleted all of the previous references (action_allowed? gets called automatically)
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|-
| rereview
| Moved logic for sorting response versions, and for getting the latest response to their own methods
| The rereview method was becoming too large and confusing
|-
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|-
| get_scores
| Moved from controller (response_controller.rb) to model (response.rb)
| The functionality in get_scores makes more sense to be implemented in the Model rather than in the controller
|-
|}

= Re-factored Code =

==Removing duplicate methods==
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

==Moving code to the proper place==
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method. Moreover, once this code was moved to the action_allowed? method, all of the references to redirect_when_disallowed were removed (action_allowed? gets called automatically).

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def action_allowed?
current_user
end

def redirect_when_disallowed(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|<pre>
def action_allowed?
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if Response.where(id: params[:id]).empty?
true
elsif
response = Response.find(params[:id])
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
current_user_id?(response.map.reviewer.user_id)
end
end
</pre>
|}

==Moving get_scores to the Response Model==
The get_scores method was being implemented in the controller. Its function fits better in the model.
As such, the method was moved and changed to retain the functionality of code that uses it. Since the variables it requires were no longer in scope, they're passed in as arguments. Also due to scope, the result has to be explicitly returned.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In response_controller.rb

def get_scores
@review_scores = []
@question_type = []
@questions.each do |question|
@review_scores << Score
.where(
response_id: @response.id,
question_id: question.id
).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end
</pre>
|<pre>
In response.rb

def get_scores(response, questions)
review_scores = []
question_type = []
questions.each do |question|
review_scores << Score
.where(
response_id: response.id,
question_id: question.id
).first
question_type << QuestionType.find_by_question_id(question.id)
end
question_type
end

</pre>
<pre>
In response_controller.rb

def view
@response = Response.find(params[:id])
@map = @response.map
get_content
@question_type = @response.get_scores(@response, @questions)
end
</pre>
|}

=Steps to verify changes=

===Action Allowed===
Action allowed is called before every method call to confirm whether or not the currently logged in user has the required privileges to complete the requested action.
To test the functionality of this method one has to attempt to complete an action that they have privileges to complete, and confirm that they're allowed to complete it. One also has to attempt to complete an action that they don't have the privileges to complete, and confirm that they're not allowed to complete it.

==Allowed==
Log into the application with the user having a student's role (User Id: user5072, Password: password)

1. Click on Assignments, and you should see the following:

[[File:actionallowedPass.png]]

==Not Allowed==
Log into the application with the user having an instructor's role (User Id: user6, Password: password)

1. Click on Assignments, and you should see the following:

[[File:actionallowedFail.png]]

=== get_scores ===
Get scores is called anytime the scores for reviews are shown. Given that, the way to test its correct functionality is to navigate to a completed review and make sure the scores are shown and are correct

ADD STEPS HERE

=== rereview ===
Rereview manages the versioning of multiple reviews for the same assignment. To test the correct functionality of review, one should attempt to update a review ( i.e. 'rereview' )

ADD STEPS HERE

File:ActionallowedFail.png

2015-03-23T03:04:39Z

Rlcoble:

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-23T02:56:02Z

Rlcoble: /* Re-factored Code Cases */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and deleted all of the previous references (action_allowed? gets called automatically)
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|-
| rereview
| Moved logic for sorting response versions, and for getting the latest response to their own methods
| The rereview method was becoming too large and confusing
|-
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|-
| get_scores
| Moved from controller (response_controller.rb) to model (response.rb)
| The functionality in get_scores makes more sense to be implemented in the Model rather than in the controller
|-
|}

= Re-factored Code =

==Removing duplicate methods==
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

==Moving code to the proper place==
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method. Moreover, once this code was moved to the action_allowed? method, all of the references to redirect_when_disallowed were removed (action_allowed? gets called automatically).

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def action_allowed?
current_user
end

def redirect_when_disallowed(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|<pre>
def action_allowed?
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if Response.where(id: params[:id]).empty?
true
elsif
response = Response.find(params[:id])
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
current_user_id?(response.map.reviewer.user_id)
end
end
</pre>
|}

==Moving get_scores to the Response Model==
The get_scores method was being implemented in the controller. Its function fits better in the model.
As such, the method was moved and changed to retain the functionality of code that uses it. Since the variables it requires were no longer in scope, they're passed in as arguments. Also due to scope, the result has to be explicitly returned.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In response_controller.rb

def get_scores
@review_scores = []
@question_type = []
@questions.each do |question|
@review_scores << Score
.where(
response_id: @response.id,
question_id: question.id
).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end
</pre>
|<pre>
In response.rb

def get_scores(response, questions)
review_scores = []
question_type = []
questions.each do |question|
review_scores << Score
.where(
response_id: response.id,
question_id: question.id
).first
question_type << QuestionType.find_by_question_id(question.id)
end
question_type
end

</pre>
<pre>
In response_controller.rb

def view
@response = Response.find(params[:id])
@map = @response.map
get_content
@question_type = @response.get_scores(@response, @questions)
end
</pre>
|}

=Steps to verify changes=

===Action Allowed===
Action allowed is called before every method call to confirm whether or not the currently logged in user has the required privileges to complete the requested action.
To test the functionality of this method one has to attempt to complete an action that they have privileges to complete, and confirm that they're allowed to complete it. One also has to attempt to complete an action that they don't have the privileges to complete, and confirm that they're not allowed to complete it.

Log into the application with the user having instructor's role (User Id: user6, Password: password)

1. Go to Manage -> Assignments and expand the assignments section.

4. Click on topics tab.

[[File:Topics tab.png]]

=== get_scores ===
Get scores is called anytime the scores for reviews are shown. Given that, the way to test its correct functionality is to navigate to a completed review and make sure the scores are shown and are correct

ADD STEPS HERE

=== rereview ===
Rereview manages the versioning of multiple reviews for the same assignment. To test the correct functionality of review, one should attempt to update a review ( i.e. 'rereview' )

ADD STEPS HERE

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-23T02:53:47Z

Rlcoble: /* Problem Statement */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and deleted all of the previous references (action_allowed? gets called automatically)
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|-
| rereview
| Moved logic for sorting response versions, and for getting the latest response to their own methods
| The rereview method was becoming too large and confusing
|-
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|-
| get_scores
| Moved from controller (response_controller.rb) to model (response.rb)
| The functionality in get_scores makes more sense to be implemented in the Model rather than in the controller
|-
|}

= Re-factored Code Cases =

== Case 1 : Refactoring the ResponseController ==

===Removing duplicate methods===
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

===Moving code to the proper place===
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method. Moreover, once this code was moved to the action_allowed? method, all of the references to redirect_when_disallowed were removed (action_allowed? gets called automatically).

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def action_allowed?
current_user
end

def redirect_when_disallowed(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|<pre>
def action_allowed?
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if Response.where(id: params[:id]).empty?
true
elsif
response = Response.find(params[:id])
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
current_user_id?(response.map.reviewer.user_id)
end
end
</pre>
|}

===Moving get_scores to the Response Model===
The get_scores method was being implemented in the controller. Its function fits better in the model.
As such, the method was moved and changed to retain the functionality of code that uses it. Since the variables it requires were no longer in scope, they're passed in as arguments. Also due to scope, the result has to be explicitly returned.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In response_controller.rb

def get_scores
@review_scores = []
@question_type = []
@questions.each do |question|
@review_scores << Score
.where(
response_id: @response.id,
question_id: question.id
).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end
</pre>
|<pre>
In response.rb

def get_scores(response, questions)
review_scores = []
question_type = []
questions.each do |question|
review_scores << Score
.where(
response_id: response.id,
question_id: question.id
).first
question_type << QuestionType.find_by_question_id(question.id)
end
question_type
end

</pre>
<pre>
In response_controller.rb

def view
@response = Response.find(params[:id])
@map = @response.map
get_content
@question_type = @response.get_scores(@response, @questions)
end
</pre>
|}

=Steps to verify changes=

===Action Allowed===
Action allowed is called before every method call to confirm whether or not the currently logged in user has the required privileges to complete the requested action.
To test the functionality of this method one has to attempt to complete an action that they have privileges to complete, and confirm that they're allowed to complete it. One also has to attempt to complete an action that they don't have the privileges to complete, and confirm that they're not allowed to complete it.

Log into the application with the user having instructor's role (User Id: user6, Password: password)

1. Go to Manage -> Assignments and expand the assignments section.

4. Click on topics tab.

[[File:Topics tab.png]]

=== get_scores ===
Get scores is called anytime the scores for reviews are shown. Given that, the way to test its correct functionality is to navigate to a completed review and make sure the scores are shown and are correct

ADD STEPS HERE

=== rereview ===
Rereview manages the versioning of multiple reviews for the same assignment. To test the correct functionality of review, one should attempt to update a review ( i.e. 'rereview' )

ADD STEPS HERE

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-23T02:53:03Z

Rlcoble: /* Action Allowed */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and deleted all of the previous references (action_allowed? gets called automatically)
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|-
| rereview
| Moved logic for sorting response versions, and for getting the latest response to their own methods
| The rereview method was becoming too large and confusing
|-
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|-
| get_scores
| Moved from controller (response_controller.rb) to model (response.rb)
| The functionality in get_scores makes more sense to be implemented in the Model rather than in the controller
|-
|}

= Re-factored Code Cases =

== Case 1 : Refactoring the ResponseController ==

===Removing duplicate methods===
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

===Moving code to the proper place===
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method. Moreover, once this code was moved to the action_allowed? method, all of the references to redirect_when_disallowed were removed (action_allowed? gets called automatically).

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def action_allowed?
current_user
end

def redirect_when_disallowed(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|<pre>
def action_allowed?
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if Response.where(id: params[:id]).empty?
true
elsif
response = Response.find(params[:id])
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
current_user_id?(response.map.reviewer.user_id)
end
end
</pre>
|}

===Moving get_scores to the Response Model===
The get_scores method was being implemented in the controller. Its function fits better in the model.
As such, the method was moved and changed to retain the functionality of code that uses it. Since the variables it requires were no longer in scope, they're passed in as arguments. Also due to scope, the result has to be explicitly returned.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In response_controller.rb

def get_scores
@review_scores = []
@question_type = []
@questions.each do |question|
@review_scores << Score
.where(
response_id: @response.id,
question_id: question.id
).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end
</pre>
|<pre>
In response.rb

def get_scores(response, questions)
review_scores = []
question_type = []
questions.each do |question|
review_scores << Score
.where(
response_id: response.id,
question_id: question.id
).first
question_type << QuestionType.find_by_question_id(question.id)
end
question_type
end

</pre>
<pre>
In response_controller.rb

def view
@response = Response.find(params[:id])
@map = @response.map
get_content
@question_type = @response.get_scores(@response, @questions)
end
</pre>
|}

=Steps to verify changes=

===Action Allowed===
Action allowed is called before every method call to confirm whether or not the currently logged in user has the required privileges to complete the requested action.
To test the functionality of this method one has to attempt to complete an action that they have privileges to complete, and confirm that they're allowed to complete it. One also has to attempt to complete an action that they don't have the privileges to complete, and confirm that they're not allowed to complete it.

Log into the application with the user having instructor's role (User Id: user6, Password: password)

1. Go to Manage -> Assignments and expand the assignments section.

4. Click on topics tab.

[[File:Topics tab.png]]

=== get_scores ===
Get scores is called anytime the scores for reviews are shown. Given that, the way to test its correct functionality is to navigate to a completed review and make sure the scores are shown and are correct

ADD STEPS HERE

=== rereview ===
Rereview manages the versioning of multiple reviews for the same assignment. To test the correct functionality of review, one should attempt to update a review ( i.e. 'rereview' )

ADD STEPS HERE

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-23T02:51:17Z

Rlcoble: /* Moving get_scores to the Response Model */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and deleted all of the previous references (action_allowed? gets called automatically)
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|-
| rereview
| Moved logic for sorting response versions, and for getting the latest response to their own methods
| The rereview method was becoming too large and confusing
|-
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|-
| get_scores
| Moved from controller (response_controller.rb) to model (response.rb)
| The functionality in get_scores makes more sense to be implemented in the Model rather than in the controller
|-
|}

= Re-factored Code Cases =

== Case 1 : Refactoring the ResponseController ==

===Removing duplicate methods===
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

===Moving code to the proper place===
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method. Moreover, once this code was moved to the action_allowed? method, all of the references to redirect_when_disallowed were removed (action_allowed? gets called automatically).

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def action_allowed?
current_user
end

def redirect_when_disallowed(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|<pre>
def action_allowed?
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if Response.where(id: params[:id]).empty?
true
elsif
response = Response.find(params[:id])
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
current_user_id?(response.map.reviewer.user_id)
end
end
</pre>
|}

===Moving get_scores to the Response Model===
The get_scores method was being implemented in the controller. Its function fits better in the model.
As such, the method was moved and changed to retain the functionality of code that uses it. Since the variables it requires were no longer in scope, they're passed in as arguments. Also due to scope, the result has to be explicitly returned.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In response_controller.rb

def get_scores
@review_scores = []
@question_type = []
@questions.each do |question|
@review_scores << Score
.where(
response_id: @response.id,
question_id: question.id
).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end
</pre>
|<pre>
In response.rb

def get_scores(response, questions)
review_scores = []
question_type = []
questions.each do |question|
review_scores << Score
.where(
response_id: response.id,
question_id: question.id
).first
question_type << QuestionType.find_by_question_id(question.id)
end
question_type
end

</pre>
<pre>
In response_controller.rb

def view
@response = Response.find(params[:id])
@map = @response.map
get_content
@question_type = @response.get_scores(@response, @questions)
end
</pre>
|}

=Steps to verify changes=

===Action Allowed===
Action allowed is called before every method call to confirm whether or not the currently logged in user has the required privileges to complete the requested action.
To test the functionality of this method one has to attempt to complete an action that they have privileges to complete, and confirm that they're allowed to complete it. One also has to attempt to complete an action that they don't have the privileges to complete, and confirm that they're not allowed to complete it.

Log into the application with the user having instructor's role (user6, password)

1. Go to Manage -> Assignments and expand the assignments section.

4. Click on topics tab.

[[File:Topics tab.png]]

=== get_scores ===
Get scores is called anytime the scores for reviews are shown. Given that, the way to test its correct functionality is to navigate to a completed review and make sure the scores are shown and are correct

ADD STEPS HERE

=== rereview ===
Rereview manages the versioning of multiple reviews for the same assignment. To test the correct functionality of review, one should attempt to update a review ( i.e. 'rereview' )

ADD STEPS HERE

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-23T02:49:28Z

Rlcoble: /* Moving code to the proper place */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and deleted all of the previous references (action_allowed? gets called automatically)
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|-
| rereview
| Moved logic for sorting response versions, and for getting the latest response to their own methods
| The rereview method was becoming too large and confusing
|-
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|-
| get_scores
| Moved from controller (response_controller.rb) to model (response.rb)
| The functionality in get_scores makes more sense to be implemented in the Model rather than in the controller
|-
|}

= Re-factored Code Cases =

== Case 1 : Refactoring the ResponseController ==

===Removing duplicate methods===
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

===Moving code to the proper place===
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method. Moreover, once this code was moved to the action_allowed? method, all of the references to redirect_when_disallowed were removed (action_allowed? gets called automatically).

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def action_allowed?
current_user
end

def redirect_when_disallowed(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|<pre>
def action_allowed?
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if Response.where(id: params[:id]).empty?
true
elsif
response = Response.find(params[:id])
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
current_user_id?(response.map.reviewer.user_id)
end
end
</pre>
|}

===Moving get_scores to the Response Model===
The get_scores method was being implemented in the controller. Its function fits better in the model.
As such, the method was moved and changed to retain the functionality of code that uses it. Since the variables it requires were no longer in scope, they're passed in as arguments. Also due to scope, the result has to be explicitly returned.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In response_controller.rb

def get_scores
- @review_scores = []
- @question_type = []
- @questions.each do |question|
- @review_scores << Score
- .where(
- response_id: @response.id,
- question_id: question.id
- ).first
- @question_type << QuestionType.find_by_question_id(question.id)
- end
- end
</pre>
|<pre>
In response.rb

def get_scores(response, questions)
review_scores = []
question_type = []
questions.each do |question|
review_scores << Score
.where(
response_id: response.id,
question_id: question.id
).first
question_type << QuestionType.find_by_question_id(question.id)
end
question_type
end

</pre>
<pre>
In response_controller.rb

def view
@response = Response.find(params[:id])
- return if action_allowed?(@response)
+ #return if action_allowed?(@response)
@map = @response.map
get_content
- get_scores(@response, @questions)
+ @question_type = @response.get_scores(@response, @questions)
end
</pre>
|}

=Steps to verify changes=

===Action Allowed===
Action allowed is called before every method call to confirm whether or not the currently logged in user has the required privileges to complete the requested action.
To test the functionality of this method one has to attempt to complete an action that they have privileges to complete, and confirm that they're allowed to complete it. One also has to attempt to complete an action that they don't have the privileges to complete, and confirm that they're not allowed to complete it.

Log into the application with the user having instructor's role (user6, password)

1. Go to Manage -> Assignments and expand the assignments section.

4. Click on topics tab.

[[File:Topics tab.png]]

=== get_scores ===
Get scores is called anytime the scores for reviews are shown. Given that, the way to test its correct functionality is to navigate to a completed review and make sure the scores are shown and are correct

ADD STEPS HERE

=== rereview ===
Rereview manages the versioning of multiple reviews for the same assignment. To test the correct functionality of review, one should attempt to update a review ( i.e. 'rereview' )

ADD STEPS HERE

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-23T02:46:27Z

Rlcoble: /* Response Controller */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and deleted all of the previous references (action_allowed? gets called automatically)
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|-
| rereview
| Moved logic for sorting response versions, and for getting the latest response to their own methods
| The rereview method was becoming too large and confusing
|-
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|-
| get_scores
| Moved from controller (response_controller.rb) to model (response.rb)
| The functionality in get_scores makes more sense to be implemented in the Model rather than in the controller
|-
|}

= Re-factored Code Cases =

== Case 1 : Refactoring the ResponseController ==

===Removing duplicate methods===
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

===Moving code to the proper place===
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method. Moreover, once this code was moved to the action_allowed? method, all of the references to redirect_when_disallowed were changed to action_allowed? (left out of wiki for brevity).

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def action_allowed?
current_user
end

def redirect_when_disallowed(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|<pre>
def action_allowed?(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|}

===Moving get_scores to the Response Model===
The get_scores method was being implemented in the controller. Its function fits better in the model.
As such, the method was moved and changed to retain the functionality of code that uses it. Since the variables it requires were no longer in scope, they're passed in as arguments. Also due to scope, the result has to be explicitly returned.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In response_controller.rb

def get_scores
- @review_scores = []
- @question_type = []
- @questions.each do |question|
- @review_scores << Score
- .where(
- response_id: @response.id,
- question_id: question.id
- ).first
- @question_type << QuestionType.find_by_question_id(question.id)
- end
- end
</pre>
|<pre>
In response.rb

def get_scores(response, questions)
review_scores = []
question_type = []
questions.each do |question|
review_scores << Score
.where(
response_id: response.id,
question_id: question.id
).first
question_type << QuestionType.find_by_question_id(question.id)
end
question_type
end

</pre>
<pre>
In response_controller.rb

def view
@response = Response.find(params[:id])
- return if action_allowed?(@response)
+ #return if action_allowed?(@response)
@map = @response.map
get_content
- get_scores(@response, @questions)
+ @question_type = @response.get_scores(@response, @questions)
end
</pre>
|}

=Steps to verify changes=

===Action Allowed===
Action allowed is called before every method call to confirm whether or not the currently logged in user has the required privileges to complete the requested action.
To test the functionality of this method one has to attempt to complete an action that they have privileges to complete, and confirm that they're allowed to complete it. One also has to attempt to complete an action that they don't have the privileges to complete, and confirm that they're not allowed to complete it.

Log into the application with the user having instructor's role (user6, password)

1. Go to Manage -> Assignments and expand the assignments section.

4. Click on topics tab.

[[File:Topics tab.png]]

=== get_scores ===
Get scores is called anytime the scores for reviews are shown. Given that, the way to test its correct functionality is to navigate to a completed review and make sure the scores are shown and are correct

ADD STEPS HERE

=== rereview ===
Rereview manages the versioning of multiple reviews for the same assignment. To test the correct functionality of review, one should attempt to update a review ( i.e. 'rereview' )

ADD STEPS HERE

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-23T02:45:38Z

Rlcoble: /* Response Controller */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| edit
| Deleted the old edit method
| The old edit method was not getting called due to ruby rules
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and deleted all of the previous references (action_allowed? gets called automatically)
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|-
| rereview
| Moved logic for sorting response versions, and for getting the latest response to their own methods
| The rereview method was becoming too large and confusing
|-
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|-
| get_scores
| Moved from controller (response_controller.rb) to model (response.rb)
| The functionality in get_scores makes more sense to be implemented in the Model rather than in the controller
|-
|}

= Re-factored Code Cases =

== Case 1 : Refactoring the ResponseController ==

===Removing duplicate methods===
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

===Moving code to the proper place===
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method. Moreover, once this code was moved to the action_allowed? method, all of the references to redirect_when_disallowed were changed to action_allowed? (left out of wiki for brevity).

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def action_allowed?
current_user
end

def redirect_when_disallowed(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|<pre>
def action_allowed?(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|}

===Moving get_scores to the Response Model===
The get_scores method was being implemented in the controller. Its function fits better in the model.
As such, the method was moved and changed to retain the functionality of code that uses it. Since the variables it requires were no longer in scope, they're passed in as arguments. Also due to scope, the result has to be explicitly returned.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
In response_controller.rb

def get_scores
- @review_scores = []
- @question_type = []
- @questions.each do |question|
- @review_scores << Score
- .where(
- response_id: @response.id,
- question_id: question.id
- ).first
- @question_type << QuestionType.find_by_question_id(question.id)
- end
- end
</pre>
|<pre>
In response.rb

def get_scores(response, questions)
review_scores = []
question_type = []
questions.each do |question|
review_scores << Score
.where(
response_id: response.id,
question_id: question.id
).first
question_type << QuestionType.find_by_question_id(question.id)
end
question_type
end

</pre>
<pre>
In response_controller.rb

def view
@response = Response.find(params[:id])
- return if action_allowed?(@response)
+ #return if action_allowed?(@response)
@map = @response.map
get_content
- get_scores(@response, @questions)
+ @question_type = @response.get_scores(@response, @questions)
end
</pre>
|}

=Steps to verify changes=

===Action Allowed===
Action allowed is called before every method call to confirm whether or not the currently logged in user has the required privileges to complete the requested action.
To test the functionality of this method one has to attempt to complete an action that they have privileges to complete, and confirm that they're allowed to complete it. One also has to attempt to complete an action that they don't have the privileges to complete, and confirm that they're not allowed to complete it.

Log into the application with the user having instructor's role (user6, password)

1. Go to Manage -> Assignments and expand the assignments section.

4. Click on topics tab.

[[File:Topics tab.png]]

=== get_scores ===
Get scores is called anytime the scores for reviews are shown. Given that, the way to test its correct functionality is to navigate to a completed review and make sure the scores are shown and are correct

ADD STEPS HERE

=== rereview ===
Rereview manages the versioning of multiple reviews for the same assignment. To test the correct functionality of review, one should attempt to update a review ( i.e. 'rereview' )

ADD STEPS HERE

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-19T04:02:45Z

Rlcoble: /* Moving code to the proper place */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| edit
| Deleted the old edit method
| The old edit method was not getting called due to ruby rules
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and changed all of the references
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|}

= Re-factored Code Cases =

== Case 1 : Refactoring the ResponseController ==

===Removing duplicate methods===
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

===Moving code to the proper place===
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method. Moreover, once this code was moved to the action_allowed? method, all of the references to redirect_when_disallowed were changed to action_allowed? (left out of wiki for brevity).

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def action_allowed?
current_user
end

def redirect_when_disallowed(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|<pre>
def action_allowed?(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|}

=Steps to verify changes=

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-19T03:59:45Z

Rlcoble:

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| edit
| Deleted the old edit method
| The old edit method was not getting called due to ruby rules
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and changed all of the references
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|}

= Re-factored Code Cases =

== Case 1 : Refactoring the ResponseController ==

===Removing duplicate methods===
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

===Moving code to the proper place===
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def action_allowed?
current_user
end

def redirect_when_disallowed(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|<pre>
def action_allowed?(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|}

=Steps to verify changes=

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-19T03:57:08Z

Rlcoble: /* Moving code to the proper place */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| edit
| Deleted the old edit method
| The old edit method was not getting called due to ruby rules
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and changed all of the references
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|}

= Re-factored Code Cases =

== Case 1 : Refactoring the ResponseController ==

===Removing duplicate methods===
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

===Moving code to the proper place===
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def action_allowed?
current_user
end

def redirect_when_disallowed(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|<pre>
def action_allowed?(response)
# For author feedback, participants need to be able to read feedback submitted by other teammates.
# If response is anything but author feedback, only the person who wrote feedback should be able to see it.
if response.map.read_attribute(:type) == 'FeedbackResponseMap' && response.map.assignment.team_assignment?
team = response.map.reviewer.team
unless team.has_user session[:user]
redirect_to '/denied?reason=You are not on the team that wrote this feedback'
else
return false
end
response.map.read_attribute(:type)
end
!current_user_id?(response.map.reviewer.user_id)
end
</pre>
|}

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-19T03:53:35Z

Rlcoble: /* Removing duplicate methods */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| edit
| Deleted the old edit method
| The old edit method was not getting called due to ruby rules
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and changed all of the references
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|}

= Re-factored Code Cases =

== Case 1 : Refactoring the ResponseController ==

===Removing duplicate methods===
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

===Moving code to the proper place===
The ResponseController allows the user to create and edit responses to questionnaires, in doing so, there needs to be some sort of authentication, and the proper place for that is in the action_allowed? method, however the un-refactored code did in the redirect_when_disallowed method.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
</pre>
|<pre>
</pre>
|}

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-19T03:47:40Z

Rlcoble: /* Removing duplicate methods */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| edit
| Deleted the old edit method
| The old edit method was not getting called due to ruby rules
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and changed all of the references
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|}

= Re-factored Code Cases =

== Case 1 : Refactoring the ResponseController ==

===Removing duplicate methods===
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:bottom;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:bottom;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-19T03:47:10Z

Rlcoble: /* Removing duplicate methods */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| edit
| Deleted the old edit method
| The old edit method was not getting called due to ruby rules
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and changed all of the references
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|}

= Re-factored Code Cases =

== Case 1 : Refactoring the ResponseController ==

===Removing duplicate methods===
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id,
:reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:top;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-19T03:42:17Z

Rlcoble: /* Removing duplicate methods */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| edit
| Deleted the old edit method
| The old edit method was not getting called due to ruby rules
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and changed all of the references
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|}

= Re-factored Code Cases =

== Case 1 : Refactoring the ResponseController ==

===Removing duplicate methods===
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! |Before Changes
! |After Changes
|- style="vertical-align:top;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id, :reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id, :reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id, :reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:top;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-19T03:41:39Z

Rlcoble: /* Removing duplicate methods */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| edit
| Deleted the old edit method
| The old edit method was not getting called due to ruby rules
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and changed all of the references
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|}

= Re-factored Code Cases =

== Case 1 : Refactoring the ResponseController ==

===Removing duplicate methods===
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! style="width:45%;"|Before Changes
! style="width:45%;"|After Changes
|- style="vertical-align:top;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id, :reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id, :reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id, :reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|- style="vertical-align:top;"
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-19T03:39:41Z

Rlcoble: /* Removing duplicate methods */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| edit
| Deleted the old edit method
| The old edit method was not getting called due to ruby rules
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and changed all of the references
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|}

= Re-factored Code Cases =

== Case 1 : Refactoring the ResponseController ==

===Removing duplicate methods===
The ResponseController allows the user to create and edit responses to questionnaires, and the functionality changed over time, causing two new_feedback and view methods to be created; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! style="width:50%;"|Before Changes
! style="width:50%;"|After Changes
|- style="vertical-align:top;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id, :reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id, :reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id, :reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|-
|<pre>
def view
@response = Response.find(params[:id])
return if redirect_when_disallowed(@response)
@map = @response.map
get_content
@review_scores = Array.new
@question_type = Array.new
@questions.each do |question|
@review_scores << Score.where(response_id: @map.response_id, question_id: question.id).first
@question_type << QuestionType.find_by_question_id(question.id)
end
end

def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|<pre>
def view
@response = Response.find(params[:id])
return if action_allowed?(@response)
@map = @response.map
get_content
get_scores(@response, @questions)
end
</pre>
|}

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-19T03:36:43Z

Rlcoble: /* Removing duplicate methods */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| edit
| Deleted the old edit method
| The old edit method was not getting called due to ruby rules
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and changed all of the references
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|}

= Re-factored Code Cases =

== Case 1 : Refactoring the ResponseController ==

===Removing duplicate methods===
The ResponseController allows the user to create and edit responses to questionnaires, therefore it needs edit and view methods; however the functionality changed over time, causing two edit and view methods to be created, as well as new_feedback; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! style="width:50%;"|Before Changes
! style="width:50%;"|After Changes
|- style="vertical-align:top;"
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id, :reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.map_id, :return => "feedback"
else
redirect_to :back
end
end

def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id, :reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|<pre>
def new_feedback
review = Response.find(params[:id])
if review
reviewer = AssignmentParticipant.where(user_id: session[:user].id, parent_id: review.map.assignment.id).first
map = FeedbackResponseMap.where(reviewed_object_id: review.id, reviewer_id: reviewer.id).first
if map.nil?
#if no feedback exists by dat user den only create for dat particular response/review
map = FeedbackResponseMap.create(:reviewed_object_id => review.id, :reviewer_id => reviewer.id, :reviewee_id => review.map.reviewer.id)
end
redirect_to :action => 'new', :id => map.id, :return => "feedback"
else
redirect_to :back
end
end
</pre>
|}

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-19T03:34:40Z

Rlcoble: /* Removing duplicate methods */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| edit
| Deleted the old edit method
| The old edit method was not getting called due to ruby rules
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and changed all of the references
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|}

= Re-factored Code Cases =

== Case 1 : Refactoring the ResponseController ==

===Removing duplicate methods===
The ResponseController allows the user to create and edit responses to questionnaires, therefore it needs edit and view methods; however the functionality changed over time, causing two edit and view methods to be created, as well as new_feedback; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! style="width:50%;"|Before Changes
! style="width:50%;"|After Changes
|- style="vertical-align:top;"
|<pre>
</pre>
|<pre>
</pre>
|}

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-19T03:34:10Z

Rlcoble:

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| edit
| Deleted the old edit method
| The old edit method was not getting called due to ruby rules
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and changed all of the references
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|}

= Re-factored Code Cases =

== Case 1 : Refactoring the ResponseController ==

===Removing duplicate methods===
The ResponseController allows the user to create and edit responses to questionnaires, therefore it needs edit and view methods; however the functionality changed over time, causing two edit and view methods to be created, as well as new_feedback; the oldest of which doesn't get called anymore.

{| class="wikitable"
|-
! style="width:13%;"|Before Changes
! style="width:33%;"|After Changes
|- style="vertical-align:top;"
|<pre>
</pre>
|<pre>
</pre>
|}

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-19T03:15:43Z

Rlcoble:

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| edit
| Deleted the old edit method
| The old edit method was not getting called due to ruby rules
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and changed all of the references
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|}

==Response Model==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|}

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-19T03:13:12Z

Rlcoble: /* Response Controller */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| edit
| Deleted the old edit method
| The old edit method was not getting called due to ruby rules
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and changed all of the references
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|}

==Views==

{| class="wikitable"
|-
! style="width:18%;"|View Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| rowspan="5" valign="middle" |
sign_up_sheet/_add_signup_topcis
| Fixed title
| The page title displayed for an instructor was "Sign-up sheet for ... "
|-
| Commented out View/Manage bookmark links
| These links were broken, and according to existing code were not meant for the instructor view.
|-
| Added variable initialization for @sign_up_topics
| The variable was referenced further on in the view, which was causing an 'nil value' error
|-
| Fixed flash message rendering for new topic creation
| The flash message was rendering incorrectly with HTML tags visible on the web page
|-
| Added full path names to partial names
| The shared partials were also being used by views in the Assignments controller, so full paths were needed
|-
| sign_up_sheet/_add_topics
| Added separation between the Import Topics and Manage Bookmarks links
| The two links were clumped together and it was difficult to distinguish between them
|-
| sign_up_sheet/_actions
| Replaced rendering of the reserve_topic partial with the _all_actions partial
| The reserve_topic partial is no longer being used and is replaced by the newly created _all_actions partial
|-
| sign_up_sheet/_all_actions
| Created this new partial
| We created the _all_actions partial to conditionally render the "Actions" table field for both instructors and students. This now also includes working links through which instructors or administrators can edit or delete topics.
|-
| sign_up_sheet/_table_line
| Gave edit/delete rights to Super Admin
| The Super-Administrator user wasn't included in the list of users with these permissions
|-
| sign_up_sheet/edit
| Modified title and included @assignment_id variable to be passed as a parameter variable to the update action
| The view was initially trying to access the params[:assignment_id] variable which was not getting initialized
|-
| assignments/edit
| Changed the partial rendered to /sign_up_sheet/add_signup_topcis.html
| The assignments/edit/add_signup_topics partial (with duplicated code) was otherwise being rendered
|}

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-19T03:12:54Z

Rlcoble: /* Response Controller */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| edit
| Deleted the old edit method
| The old edit method was not getting called due to ruby rules
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed
| rowspan="2" | Moved all of the code from redirect_when_disallowed to action_allowed and changed all of the references |
| rowspan="2" | Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|-
| action_allowed?
|}

==Views==

{| class="wikitable"
|-
! style="width:18%;"|View Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| rowspan="5" valign="middle" |
sign_up_sheet/_add_signup_topcis
| Fixed title
| The page title displayed for an instructor was "Sign-up sheet for ... "
|-
| Commented out View/Manage bookmark links
| These links were broken, and according to existing code were not meant for the instructor view.
|-
| Added variable initialization for @sign_up_topics
| The variable was referenced further on in the view, which was causing an 'nil value' error
|-
| Fixed flash message rendering for new topic creation
| The flash message was rendering incorrectly with HTML tags visible on the web page
|-
| Added full path names to partial names
| The shared partials were also being used by views in the Assignments controller, so full paths were needed
|-
| sign_up_sheet/_add_topics
| Added separation between the Import Topics and Manage Bookmarks links
| The two links were clumped together and it was difficult to distinguish between them
|-
| sign_up_sheet/_actions
| Replaced rendering of the reserve_topic partial with the _all_actions partial
| The reserve_topic partial is no longer being used and is replaced by the newly created _all_actions partial
|-
| sign_up_sheet/_all_actions
| Created this new partial
| We created the _all_actions partial to conditionally render the "Actions" table field for both instructors and students. This now also includes working links through which instructors or administrators can edit or delete topics.
|-
| sign_up_sheet/_table_line
| Gave edit/delete rights to Super Admin
| The Super-Administrator user wasn't included in the list of users with these permissions
|-
| sign_up_sheet/edit
| Modified title and included @assignment_id variable to be passed as a parameter variable to the update action
| The view was initially trying to access the params[:assignment_id] variable which was not getting initialized
|-
| assignments/edit
| Changed the partial rendered to /sign_up_sheet/add_signup_topcis.html
| The assignments/edit/add_signup_topics partial (with duplicated code) was otherwise being rendered
|}

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-19T02:58:32Z

Rlcoble: /* Response Controller */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| edit
| Deleted the old edit method
| The old edit method was not getting called due to ruby rules
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|-
| redirect_when_disallowed & action_allowed?
| Moved all of the code from redirect_when_disallowed to action_allowed and changed all of the references
| Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|}

==Views==

{| class="wikitable"
|-
! style="width:18%;"|View Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| rowspan="5" valign="middle" |
sign_up_sheet/_add_signup_topcis
| Fixed title
| The page title displayed for an instructor was "Sign-up sheet for ... "
|-
| Commented out View/Manage bookmark links
| These links were broken, and according to existing code were not meant for the instructor view.
|-
| Added variable initialization for @sign_up_topics
| The variable was referenced further on in the view, which was causing an 'nil value' error
|-
| Fixed flash message rendering for new topic creation
| The flash message was rendering incorrectly with HTML tags visible on the web page
|-
| Added full path names to partial names
| The shared partials were also being used by views in the Assignments controller, so full paths were needed
|-
| sign_up_sheet/_add_topics
| Added separation between the Import Topics and Manage Bookmarks links
| The two links were clumped together and it was difficult to distinguish between them
|-
| sign_up_sheet/_actions
| Replaced rendering of the reserve_topic partial with the _all_actions partial
| The reserve_topic partial is no longer being used and is replaced by the newly created _all_actions partial
|-
| sign_up_sheet/_all_actions
| Created this new partial
| We created the _all_actions partial to conditionally render the "Actions" table field for both instructors and students. This now also includes working links through which instructors or administrators can edit or delete topics.
|-
| sign_up_sheet/_table_line
| Gave edit/delete rights to Super Admin
| The Super-Administrator user wasn't included in the list of users with these permissions
|-
| sign_up_sheet/edit
| Modified title and included @assignment_id variable to be passed as a parameter variable to the update action
| The view was initially trying to access the params[:assignment_id] variable which was not getting initialized
|-
| assignments/edit
| Changed the partial rendered to /sign_up_sheet/add_signup_topcis.html
| The assignments/edit/add_signup_topics partial (with duplicated code) was otherwise being rendered
|}

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-19T02:58:07Z

Rlcoble: /* Response Controller */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| edit
| Deleted the old edit method
| The old edit method was not getting called due to ruby rules
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
-
| redirect_when_disallowed & action_allowed?
| Moved all of the code from redirect_when_disallowed to action_allowed and changed all of the references
| Authorization to perform actions wasn't being performed correctly, it is supposed to be done through action_allowed?
|}

==Views==

{| class="wikitable"
|-
! style="width:18%;"|View Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| rowspan="5" valign="middle" |
sign_up_sheet/_add_signup_topcis
| Fixed title
| The page title displayed for an instructor was "Sign-up sheet for ... "
|-
| Commented out View/Manage bookmark links
| These links were broken, and according to existing code were not meant for the instructor view.
|-
| Added variable initialization for @sign_up_topics
| The variable was referenced further on in the view, which was causing an 'nil value' error
|-
| Fixed flash message rendering for new topic creation
| The flash message was rendering incorrectly with HTML tags visible on the web page
|-
| Added full path names to partial names
| The shared partials were also being used by views in the Assignments controller, so full paths were needed
|-
| sign_up_sheet/_add_topics
| Added separation between the Import Topics and Manage Bookmarks links
| The two links were clumped together and it was difficult to distinguish between them
|-
| sign_up_sheet/_actions
| Replaced rendering of the reserve_topic partial with the _all_actions partial
| The reserve_topic partial is no longer being used and is replaced by the newly created _all_actions partial
|-
| sign_up_sheet/_all_actions
| Created this new partial
| We created the _all_actions partial to conditionally render the "Actions" table field for both instructors and students. This now also includes working links through which instructors or administrators can edit or delete topics.
|-
| sign_up_sheet/_table_line
| Gave edit/delete rights to Super Admin
| The Super-Administrator user wasn't included in the list of users with these permissions
|-
| sign_up_sheet/edit
| Modified title and included @assignment_id variable to be passed as a parameter variable to the update action
| The view was initially trying to access the params[:assignment_id] variable which was not getting initialized
|-
| assignments/edit
| Changed the partial rendered to /sign_up_sheet/add_signup_topcis.html
| The assignments/edit/add_signup_topics partial (with duplicated code) was otherwise being rendered
|}

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-19T02:53:16Z

Rlcoble: /* Response Controller */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| edit
| Deleted the old edit method
| The old edit method was not getting called due to ruby rules
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| view
| Deleted the old view method
| The old view method was not getting called due to ruby rules
|}

==Views==

{| class="wikitable"
|-
! style="width:18%;"|View Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| rowspan="5" valign="middle" |
sign_up_sheet/_add_signup_topcis
| Fixed title
| The page title displayed for an instructor was "Sign-up sheet for ... "
|-
| Commented out View/Manage bookmark links
| These links were broken, and according to existing code were not meant for the instructor view.
|-
| Added variable initialization for @sign_up_topics
| The variable was referenced further on in the view, which was causing an 'nil value' error
|-
| Fixed flash message rendering for new topic creation
| The flash message was rendering incorrectly with HTML tags visible on the web page
|-
| Added full path names to partial names
| The shared partials were also being used by views in the Assignments controller, so full paths were needed
|-
| sign_up_sheet/_add_topics
| Added separation between the Import Topics and Manage Bookmarks links
| The two links were clumped together and it was difficult to distinguish between them
|-
| sign_up_sheet/_actions
| Replaced rendering of the reserve_topic partial with the _all_actions partial
| The reserve_topic partial is no longer being used and is replaced by the newly created _all_actions partial
|-
| sign_up_sheet/_all_actions
| Created this new partial
| We created the _all_actions partial to conditionally render the "Actions" table field for both instructors and students. This now also includes working links through which instructors or administrators can edit or delete topics.
|-
| sign_up_sheet/_table_line
| Gave edit/delete rights to Super Admin
| The Super-Administrator user wasn't included in the list of users with these permissions
|-
| sign_up_sheet/edit
| Modified title and included @assignment_id variable to be passed as a parameter variable to the update action
| The view was initially trying to access the params[:assignment_id] variable which was not getting initialized
|-
| assignments/edit
| Changed the partial rendered to /sign_up_sheet/add_signup_topcis.html
| The assignments/edit/add_signup_topics partial (with duplicated code) was otherwise being rendered
|}

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-19T02:52:08Z

Rlcoble: /* Response Controller */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| edit
| Deleted the old edit method
| The old edit method was not getting called due to ruby rules
|-
| new_feedback
| Deleted the old new_feedback method
| The old new_feedback method was not getting called due to ruby rules
|-
| rowspan="3" valign="middle" |
destroy
| Renamed the 'delete' method to 'destroy'
| This was done for better Rails 4 routing compatibility
|-
| Initialized the assignment_id parameter
| This is used further on and is not passed from the link URL
|-
| Fixed redirection after topic deletion to Topics tab
| Once a topic was successfully deleted, the view rendered was just a list of topics
|}

==Views==

{| class="wikitable"
|-
! style="width:18%;"|View Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| rowspan="5" valign="middle" |
sign_up_sheet/_add_signup_topcis
| Fixed title
| The page title displayed for an instructor was "Sign-up sheet for ... "
|-
| Commented out View/Manage bookmark links
| These links were broken, and according to existing code were not meant for the instructor view.
|-
| Added variable initialization for @sign_up_topics
| The variable was referenced further on in the view, which was causing an 'nil value' error
|-
| Fixed flash message rendering for new topic creation
| The flash message was rendering incorrectly with HTML tags visible on the web page
|-
| Added full path names to partial names
| The shared partials were also being used by views in the Assignments controller, so full paths were needed
|-
| sign_up_sheet/_add_topics
| Added separation between the Import Topics and Manage Bookmarks links
| The two links were clumped together and it was difficult to distinguish between them
|-
| sign_up_sheet/_actions
| Replaced rendering of the reserve_topic partial with the _all_actions partial
| The reserve_topic partial is no longer being used and is replaced by the newly created _all_actions partial
|-
| sign_up_sheet/_all_actions
| Created this new partial
| We created the _all_actions partial to conditionally render the "Actions" table field for both instructors and students. This now also includes working links through which instructors or administrators can edit or delete topics.
|-
| sign_up_sheet/_table_line
| Gave edit/delete rights to Super Admin
| The Super-Administrator user wasn't included in the list of users with these permissions
|-
| sign_up_sheet/edit
| Modified title and included @assignment_id variable to be passed as a parameter variable to the update action
| The view was initially trying to access the params[:assignment_id] variable which was not getting initialized
|-
| assignments/edit
| Changed the partial rendered to /sign_up_sheet/add_signup_topcis.html
| The assignments/edit/add_signup_topics partial (with duplicated code) was otherwise being rendered
|}

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-19T02:49:17Z

Rlcoble: /* Response Controller */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| latestResponseVersion
| Changed name to previous_responses
| The name wasn't indicative of what the method did
|-
| update
| Fixed redirection after topic updation to Topics tab
| Once a topic was successfully edited, the view rendered was just a list of topics
|-
| edit
| Initialized @assignment_id variable
| The variable is used in the edit view
|-
| rowspan="3" valign="middle" |
destroy
| Renamed the 'delete' method to 'destroy'
| This was done for better Rails 4 routing compatibility
|-
| Initialized the assignment_id parameter
| This is used further on and is not passed from the link URL
|-
| Fixed redirection after topic deletion to Topics tab
| Once a topic was successfully deleted, the view rendered was just a list of topics
|}

==Views==

{| class="wikitable"
|-
! style="width:18%;"|View Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| rowspan="5" valign="middle" |
sign_up_sheet/_add_signup_topcis
| Fixed title
| The page title displayed for an instructor was "Sign-up sheet for ... "
|-
| Commented out View/Manage bookmark links
| These links were broken, and according to existing code were not meant for the instructor view.
|-
| Added variable initialization for @sign_up_topics
| The variable was referenced further on in the view, which was causing an 'nil value' error
|-
| Fixed flash message rendering for new topic creation
| The flash message was rendering incorrectly with HTML tags visible on the web page
|-
| Added full path names to partial names
| The shared partials were also being used by views in the Assignments controller, so full paths were needed
|-
| sign_up_sheet/_add_topics
| Added separation between the Import Topics and Manage Bookmarks links
| The two links were clumped together and it was difficult to distinguish between them
|-
| sign_up_sheet/_actions
| Replaced rendering of the reserve_topic partial with the _all_actions partial
| The reserve_topic partial is no longer being used and is replaced by the newly created _all_actions partial
|-
| sign_up_sheet/_all_actions
| Created this new partial
| We created the _all_actions partial to conditionally render the "Actions" table field for both instructors and students. This now also includes working links through which instructors or administrators can edit or delete topics.
|-
| sign_up_sheet/_table_line
| Gave edit/delete rights to Super Admin
| The Super-Administrator user wasn't included in the list of users with these permissions
|-
| sign_up_sheet/edit
| Modified title and included @assignment_id variable to be passed as a parameter variable to the update action
| The view was initially trying to access the params[:assignment_id] variable which was not getting initialized
|-
| assignments/edit
| Changed the partial rendered to /sign_up_sheet/add_signup_topcis.html
| The assignments/edit/add_signup_topics partial (with duplicated code) was otherwise being rendered
|}

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-19T02:46:36Z

Rlcoble:

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==Response Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| create
| Fixed redirection after topic creation to Topics tab
| On successful creation of a topic, the action was merely redirecting to the assignments/edit view
|-
| update
| Fixed redirection after topic updation to Topics tab
| Once a topic was successfully edited, the view rendered was just a list of topics
|-
| edit
| Initialized @assignment_id variable
| The variable is used in the edit view
|-
| rowspan="3" valign="middle" |
destroy
| Renamed the 'delete' method to 'destroy'
| This was done for better Rails 4 routing compatibility
|-
| Initialized the assignment_id parameter
| This is used further on and is not passed from the link URL
|-
| Fixed redirection after topic deletion to Topics tab
| Once a topic was successfully deleted, the view rendered was just a list of topics
|}

==Views==

{| class="wikitable"
|-
! style="width:18%;"|View Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| rowspan="5" valign="middle" |
sign_up_sheet/_add_signup_topcis
| Fixed title
| The page title displayed for an instructor was "Sign-up sheet for ... "
|-
| Commented out View/Manage bookmark links
| These links were broken, and according to existing code were not meant for the instructor view.
|-
| Added variable initialization for @sign_up_topics
| The variable was referenced further on in the view, which was causing an 'nil value' error
|-
| Fixed flash message rendering for new topic creation
| The flash message was rendering incorrectly with HTML tags visible on the web page
|-
| Added full path names to partial names
| The shared partials were also being used by views in the Assignments controller, so full paths were needed
|-
| sign_up_sheet/_add_topics
| Added separation between the Import Topics and Manage Bookmarks links
| The two links were clumped together and it was difficult to distinguish between them
|-
| sign_up_sheet/_actions
| Replaced rendering of the reserve_topic partial with the _all_actions partial
| The reserve_topic partial is no longer being used and is replaced by the newly created _all_actions partial
|-
| sign_up_sheet/_all_actions
| Created this new partial
| We created the _all_actions partial to conditionally render the "Actions" table field for both instructors and students. This now also includes working links through which instructors or administrators can edit or delete topics.
|-
| sign_up_sheet/_table_line
| Gave edit/delete rights to Super Admin
| The Super-Administrator user wasn't included in the list of users with these permissions
|-
| sign_up_sheet/edit
| Modified title and included @assignment_id variable to be passed as a parameter variable to the update action
| The view was initially trying to access the params[:assignment_id] variable which was not getting initialized
|-
| assignments/edit
| Changed the partial rendered to /sign_up_sheet/add_signup_topcis.html
| The assignments/edit/add_signup_topics partial (with duplicated code) was otherwise being rendered
|}

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-19T02:45:49Z

Rlcoble:

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.

=Changes Made=

==SignupSheet Controller==

{| class="wikitable"
|-
! style="width:13%;"|Method Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| create
| Fixed redirection after topic creation to Topics tab
| On successful creation of a topic, the action was merely redirecting to the assignments/edit view
|-
| update
| Fixed redirection after topic updation to Topics tab
| Once a topic was successfully edited, the view rendered was just a list of topics
|-
| edit
| Initialized @assignment_id variable
| The variable is used in the edit view
|-
| rowspan="3" valign="middle" |
destroy
| Renamed the 'delete' method to 'destroy'
| This was done for better Rails 4 routing compatibility
|-
| Initialized the assignment_id parameter
| This is used further on and is not passed from the link URL
|-
| Fixed redirection after topic deletion to Topics tab
| Once a topic was successfully deleted, the view rendered was just a list of topics
|}

==Views==

{| class="wikitable"
|-
! style="width:18%;"|View Name
! style="width:33%;"|Changes Made
! style="width:43%;"|Reason For Change
|- style="vertical-align:top;"
| rowspan="5" valign="middle" |
sign_up_sheet/_add_signup_topcis
| Fixed title
| The page title displayed for an instructor was "Sign-up sheet for ... "
|-
| Commented out View/Manage bookmark links
| These links were broken, and according to existing code were not meant for the instructor view.
|-
| Added variable initialization for @sign_up_topics
| The variable was referenced further on in the view, which was causing an 'nil value' error
|-
| Fixed flash message rendering for new topic creation
| The flash message was rendering incorrectly with HTML tags visible on the web page
|-
| Added full path names to partial names
| The shared partials were also being used by views in the Assignments controller, so full paths were needed
|-
| sign_up_sheet/_add_topics
| Added separation between the Import Topics and Manage Bookmarks links
| The two links were clumped together and it was difficult to distinguish between them
|-
| sign_up_sheet/_actions
| Replaced rendering of the reserve_topic partial with the _all_actions partial
| The reserve_topic partial is no longer being used and is replaced by the newly created _all_actions partial
|-
| sign_up_sheet/_all_actions
| Created this new partial
| We created the _all_actions partial to conditionally render the "Actions" table field for both instructors and students. This now also includes working links through which instructors or administrators can edit or delete topics.
|-
| sign_up_sheet/_table_line
| Gave edit/delete rights to Super Admin
| The Super-Administrator user wasn't included in the list of users with these permissions
|-
| sign_up_sheet/edit
| Modified title and included @assignment_id variable to be passed as a parameter variable to the update action
| The view was initially trying to access the params[:assignment_id] variable which was not getting initialized
|-
| assignments/edit
| Changed the partial rendered to /sign_up_sheet/add_signup_topcis.html
| The assignments/edit/add_signup_topics partial (with duplicated code) was otherwise being rendered
|}

CSC/ECE 517 Fall 2014/oss E1508 MRS

2015-03-19T02:41:23Z

Rlcoble: /* Problem Statement */

'''E1508 Refactoring Response Controller'''

This page provides a description of the Expertiza based OSS project. This project aimed at refactoring the ResponseController.

__TOC__

= Problem Statement =
'''Classes involved:'''
response_controller.rb
response.rb
'''???????'''

'''What they do:'''
Allows the user to create and edit responses to questionnaires … such as performing a review, rating a teammate, or giving feedback to a reviewer.

'''What's wrong with it:'''
* It doesn’t do authorization properly.
* It contains duplicated methods.
* Functionality that should be in models is incorporated into the controller.

'''What needs to be done:'''
# latestresponseversion seems misnamed. It fetches all previous versions of a response (which is to say, all previous review versions by the current reviewer of the current author for the current assignment).
# get_scores gets all the scores assigned in a particular response. A “response” is created when someone submits a review, a partner evaluation, a survey, etc.
# The rereview method is 98 lines long. Several parts of it should be turned into methods. Sorting review versions is really not a controller responsibility; it would be better to do this in a model class (which class?) Ditto for determining whether a review is current (i.e., was done during the current assignment phase). This is a query that is made about a review (actually, about a response, which may be a review, author feedback, etc.). It should be placed in the appropriate model class.
# rereview contains special code to check whether an assignment is “Jen’s assignment”; this was the first assignment we ever created with a multipart rubric. It was hard-coded into the system, rather than working on a rubric that was created in the normal way. It is probably impossible to remove this code without breaking that assignment, but it should be done in a separate method, and commented appropriately as a kludge.
# Again in rereview, creating a new version of a review is a model responsibility, and should be moved out of the controller.
# There are two (consecutive) copies of the edit method. The second appears to be the newer one, and, according to the rules for method definition, is the one that is currently in use. The first should be removed. Ditto for new_feedback and view--the 2nd version of each appears to be newer & should be kept.
# Authorization to perform actions is not checked correctly. It is supposed to be done through the action_allowed? method at the beginning of the class definition. Different authorization should be required for different operations. For example, someone should be allowed to view a response if they wrote the response, or they are the person or on the team whose work the response applied to, or if they are an instructor or TA for the class. The person who wrote a response should be allowed to edit it, but not the person/team who was being reviewed, nor the instructor or TA for the class. Currently, authorization is denied by the redirect_when_disallowed method, which was an earlier, more error-prone way of controlling access. It should go away, now that the class has an action_allowed? method.