Expertiza_Wiki - User contributions [en]

CSC/ECE 517 Spring 2016/Badging System

2016-04-25T22:33:16Z

Magoff2: Added the rest of walkthrough

==Introduction==
===Background===
Much like physical badges in the army and youth scout troops, digital badges are an assessment and credentialing mechanism that is housed and managed online. Badges are designed to make visible and validate learning in both formal and informal settings, and hold the potential to help transform where and how learning is valued. In other words, badges may be used in order to set goals and motivations for students and reward and may help to improve their academic scores. Badges can also be considered as a way to reward student’s success. Moreover, badges can be used by teachers for alternative assessment techniques.

===Purpose===
One request for the Expertiza system is to add a badging system as a way to measure student performance. Expertiza will take advantage of the motivations created from badges by awarding students with new badges based off providing a variety of factors within the Expertiza system. Some of these badges include: achieving a top percentage of scores in an assignment, achieving a high peer review score, performing well overall in a course and other manual accomplishments deemed necessary by the teaching staff for a course. Instead of implementing the whole badging system, we will call an existing online badging web service, Credly, and integrate it with Expertiza. Instructor can create badges using this service and assign to students.

==Requirements==
===System Requirements===
The system requirements focuses on adding a 'badging' functionality in Expertiza. This feature allows instructors to assign badges to students based on their performance and accomplishments. Badges are of types - course-level and assignment-level. Badges can be pre-selected while creating an assignment and automatically triggered when student finished the assignment or assignment is closed. Badges can also be awarded manually by instructor to an individual or a team. An instructor can also create new badges anytime and award to students. A leaderboard gives an account of standing of students in terms of badges earned. In order to implement a badging system, a third party badge manager will be utilized called Credly. Credly provides a way for users to accumulate and display badges they earn in a centralized way. By utilizing Credly, the development of the actual badges and badge management can be abstracted away from the project.

The testing of these requirements will use Rspec testing framework for all non-user interface related modifications. All user-interface modifications resulting from the user requirements will be tested manually.

===Use Case===
The following simple illustration shows the use cases of the system.

[[File:Use_case.PNG]]

====Use Case Scenarios====
* '''Student Views Leaderboard'''
** Actor: Student
** Other Participants: None
** Primary Sequence:
**# Log into Expertiza
**# Mouse over Home
**# Select Leaderboard
* '''Instructor Views Assignment Leaderboard'''
** Actor: Instructor
** Other Participants: None
** Primary Sequence:
**# Log into Expertiza
**# Select Assignments
**# Select View Badges on assignment
* '''Instructor Edits Assignment Badges'''
** Actor: Instructor
** Other Participants: None
** Primary Sequence:
**# Log into Expertiza
**# Select Assignments
**# Select Edit Assignments
**# Select Badges tab
**# Check enable badges
**# Check Score Threshold
**# Enter 95.5 as scoring threshold
**# Select Save
* '''Instructor Creates Course Badges'''
** Actor: Instructor
** Other Participants: None
** Primary Sequence:
**# Log into Expertiza
**# Select LeaderBoard
**# Select Award Badges
**# Select Create new badge
**# Create new badge using Credly
**# Select Save

===Tasks Done===
*Create db table to store the participants with badges.
*Write code for calling the service and calculating/identifying badges based on the scores of students on all assignments.
*Add badge specification to course details and assignment details page for the instructor to specify the badges.
*Create views for both students and instructors. Students should be able to view their badges from different courses and instructors should be able to see the badges awarded/earned for their class.
*Display a subset of the badge holders on the leaderboard page. Also, student can view badges of other students in the course.
*Criteria to be followed for awarding badges:
#Top scores for an assignment. (configured at assignment page)
#All scores more than a threshold for an assignment. (configured at assignment page)
#Mean score of selected assignments being greater than threshold. (configured at course page)
#Top mean score of selected assignments. (configured at course page)
#Discretionary merit badges for projects that exceed expectations.

===Files Used===
Files that are modified or are added can be found [http://github.com/expertiza/expertiza/pull/673/files here]

*Modified files:
**app/controllers/student_task_controller.rb 4
**app/controllers/users_controller.rb 4
**app/controllers/tree_display_controller.rb 4
**app/controllers/leaderboard_controller.rb 4
**app/controllers/assignments_controller.rb 4
**app/models/user.rb 4
**app/models/leaderboard.rb 4
**app/models/badge_user.rb 4
**app/models/assignment_form.rb 4
**app/models/assignment.rb 4
**app/views/leaderboard/index.html.erb 4
**app/views/leaderboard/_leaderBoards.html.erb 4
**app/views/leaderboard/_achievementLeaderBoards.html.erb
**app/views/course/edit.html.erb
**app/views/tree_display/actions/_courses_actions.html.erb 4
**config/routes.rb 4
**db/schema.rb 4
**app/views/leaderboard/view.html.erb 4
**app/views/auth/_login.html.erb 4
**app/views/assignments/edit.html.erb 4
**app/helpers/leaderboard_helper.rb 4
**app/helpers/assignment_helper.rb 4

*Newly added files:
**app/models/badge.rb 4
**app/models/badge_groups.rb 4
**app/models/assignment_group.rb 4
**app/controllers/badges_controller.rb 4
**app/controllers/badge_groups_controller.rb 4
**app/views/users/credly_register.html.erb 4
**app/views/assignments/edit/_badges.html.erb 4
**app/views/badges/ 4
**app/views/badge_groups/ 4
**app/views/assignments/edit/_select_badge.html.erb 4
**app/helpers/credly_helper.rb 4

===Deciding External Web Service===
{| class="wikitable"
|-
! Factors !! Open Badges !! Credly !! Bestr
|-
| Native User Management || No || Yes. No need to store all records locally. || No
|-
| Extensive API Support || Yes. But many still in beta phase. || Yes. (Primary reason for choosing Credly) || No
|-
| Interactive Badge Builder SDK|| Yes. But still in beta phase. || Yes || Yes. But gives few options for cusromization.
|-
| Existing Integration with other systems || Few || Many || No
|-
| Monetary Costs || Free || Free tier as well as paid plans. || Paid.
|}

From the above rubrics, we decided to use Credly as our web service for badging system.

==Database Design==
The following tables will be created to implement a solution for this project.

1. badges table - which stores badge_id and their descriptions.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| id || int || Primary key. Auto-generated
|-
| name || varchar || Description of the badge
|-
| credly_badge_id || int || Corresponding badge id with Credly
|}

2. badge_users table - which stores details about what badges are assignment to a user and related details.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| id || int || Primary key. Auto-generated
|-
| badge_id || int || Referenced from badges table
|-
| user_id || int || Referenced from users table
|-
| course_id || int || Referenced from courses table
|-
| assignment_id || int || Referenced from assignments table
|-
| is_course_badge || boolean || Whether badge is a course-badge or individual-badge
|}

3. badge_groups - which stores information about which badges should be assigned depending on the threshold score.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| id || int || Primary key. Auto-generated
|-
| strategy || varchar || Describes the strategy of awarding
|-
| badge_id || int || Assigned badge id.
|-
| course_id || int || Course for which group is formed.
|-
| is_course_level_group || boolean || Whether group is for course
|-
| threshold || int || Score required to award the badge
|}

4. assignment_groups - which stores details about the team badges.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| id || int || Primary key. Auto-generated
|-
| badge_group_id || int || Referenced from badge_groups table
|-
| assignment_id || int || Referenced from assignments table
|}

==Design Pattern==
# MVC – The project is implemented in Ruby on Rails that uses MVC architecture. It separates an application’s data model, user interface, and control logic into three distinct components (model, view and controller, respectively).
# DRY Principle – We are trying to reuse the existing functionalities in Expertiza, thus avoiding code duplication. Whenever possible, code modification based on the existing classes, controllers, or tables will be done instead of creating the new one.

==Object Oriented Design==
As with most Ruby on Rails applications, this solution uses the Model-View-Controller
design pattern. The following diagram shows a workflow of the planned design along with the attributes and operations that are
relevant to the implementation of this solution.

[[File:badging_class_diagram.png]]

==Walkthrough==
Below is a walkthrough of the changes to implement the Badging System:
===Instructor===
Instructors may configure badges on the course page using the new badge configuration icon:

[[File:Manage_courses_badges.jpg]]

Upon clicking the badge configuration icon, the user will be presented with two items: create groups and view all existing groups. Users may also edit and delete groups. A group is a set of assignments to present badges for.

[[File:badges_configuration.jpg]]

A new group may be created using the form below. This form allows instructors to create a new badge while creating a group for which they will be redirected to Credly. The form page must be refreshed upon creating a new badge so it may appear in the interface. The result of this form will create a new record in badge_groups and assignment_groups tables.

[[File:badges_new.jpg]]

Under assignment configuration, instructors may add badges to an individual assignment. They may choose to add the badges to the top N students, or based off of a given threshold. In order to see the previously mentioned strategies, Enable Badges must be checked. When enabling badges, it will create data in the badges_group and assignments_group tables.

[[File:assignment_badges_config.jpg]]

After badges are awarded, an instructor may view the badges given to students on the leaderboard page. On the leaderboard page each course has it's own board of students. Instructors may also manually award badges to students from the page.

[[File:leaderboard_instructor.jpg]]

Upon clicking award badge you will be brought to a form, which contains the student, the badge and the assignment. After submitting the form a badge will be awarded to the student by creating an entry in the badges_users table.

[[File:award_badges.jpg]]

===Student===
Students may view the leaderboard for classes they have taken. They may see where they place among their peers.

[[File:student_leaderboard.png]]

==Mockups==
The Expertiza badging system will largely be driven by academic achievement from students. By using student’s scores as a way to provide badges it will be easy to automate the badge reward system upon closing an assignment. For instance, an instructor may decide to reward badges to the top 3 scores on an assignment so once the assignment closes those students will automatically be given those badges.

In order to use badges for an assignment, an instructor must turn on badging for their assignment upon creating or editing an assignment. When turning on the badging system the instructor may specify how many badges will be distributed, or choose to distribute them based off of a scoring threshold that students must achieve.

Following the completion of an assignment an instructor may view the awarded badges on the assignment page. A student will be able to view their earned badges on their homepage categorized by course and assignment.

The layout of each page will match with the currently existing design standards in Expertiza we will continue to use the header and will use headings and links much like other pages. Figure 1 below shows what the leaderboard may look like from a student perspective. Each course the student has participated in will be displayed on the page and by clicking the “Show Badges” the page will generate a list of each of the participants sorted by the number of badges they have earned. In order to display the badges the application will make a call to Credly to query about student badges.

[[File: StudentLeaderboard.png]]
Figure 1: Student Leaderboard

The next figures are all from the perspective of an inspector or admin. In Figure 3 below an instructor may view the badges earned for a given assignment or course in which they own. They will get to his page by clicking a badges button from either the assignments or courses page. The title of the page will be the name of either the course of assignment. Like the previous figure, by clicking show badges the list of course participants will appear sorted by the number of badges they have earned. Another link, “Award Badges” will be used to manually grant a badge. When an instructor or admin clicks on the link, they will be directed to the credly page in order to grant the badge to the student.

[[File: InstructorAssignment.png]]
Figure 2: Instructor assignment / course badge view

In order to use badges for an assignment, an instructor must first enable them for the assignment. The badges will be enabled by default. The figure below shows some of the settings associated with the badges system. Instructors may choose to automatically grant badges to students based off of their performance on the assignment. When editing or creating a new assignment they may come to the new badges tab and configure how they want the badges granted. Instructors may choose to grant some number of badges to the top scores of the group defined by the number the input, or they may decide to grant badges to anyone who may achieve a score past the provided scoring threshold.

[[File: EditAssignmentBadges.png]]
Figure 3: Assignment Badge Settings

Like assignments, courses also need to have some settings to configure badges. In Figure 4, instructors may automatically grant badges for students based on mean scores of multiple assignments throughout the course. First the instructor must check all of the assignments they would like to include in the mean then they must select a scoring strategy. Like the previous figure, they may choose between granting a badge to the top number of participants based on instructor input, or they may set a threshold on a mean score and any student who has achieved a score past the mean will be granted a badge.

[[File: BadgeCourseOptions.png]]
Figure 4: Edit Course

File:Student leaderboard.png

2016-04-25T22:32:31Z

Magoff2:

File:Award badges.jpg

2016-04-25T22:28:40Z

Magoff2:

File:Leaderboard instructor.jpg

2016-04-25T22:25:16Z

Magoff2:

File:Assignment badges config.jpg

2016-04-25T22:19:17Z

Magoff2:

CSC/ECE 517 Spring 2016/Badging System

2016-04-25T14:15:55Z

Magoff2: Started screenshot walkthrough

==Introduction==
===Background===
Much like physical badges in the army and youth scout troops, digital badges are an assessment and credentialing mechanism that is housed and managed online. Badges are designed to make visible and validate learning in both formal and informal settings, and hold the potential to help transform where and how learning is valued. In other words, badges may be used in order to set goals and motivations for students and reward and may help to improve their academic scores. Badges can also be considered as a way to reward student’s success. Moreover, badges can be used by teachers for alternative assessment techniques.

===Purpose===
One request for the Expertiza system is to add a badging system as a way to measure student performance. Expertiza will take advantage of the motivations created from badges by awarding students with new badges based off providing a variety of factors within the Expertiza system. Some of these badges include: achieving a top percentage of scores in an assignment, achieving a high peer review score, performing well overall in a course and other manual accomplishments deemed necessary by the teaching staff for a course. Instead of implementing the whole badging system, we will call an existing online badging web service, Credly, and integrate it with Expertiza. Instructor can create badges using this service and assign to students.

==Requirements==
===System Requirements===
The system requirements focuses on adding a 'badging' functionality in Expertiza. This feature allows instructors to assign badges to students based on their performance and accomplishments. Badges are of types - course-level and assignment-level. Badges can be pre-selected while creating an assignment and automatically triggered when student finished the assignment or assignment is closed. Badges can also be awarded manually by instructor to an individual or a team. An instructor can also create new badges anytime and award to students. A leaderboard gives an account of standing of students in terms of badges earned. In order to implement a badging system, a third party badge manager will be utilized called Credly. Credly provides a way for users to accumulate and display badges they earn in a centralized way. By utilizing Credly, the development of the actual badges and badge management can be abstracted away from the project.

The testing of these requirements will use Rspec testing framework for all non-user interface related modifications. All user-interface modifications resulting from the user requirements will be tested manually.

===Use Case===
The following simple illustration shows the use cases of the system.

[[File:Use_case.PNG]]

====Use Case Scenarios====
* '''Student Views Leaderboard'''
** Actor: Student
** Other Participants: None
** Primary Sequence:
**# Log into Expertiza
**# Mouse over Home
**# Select Leaderboard
* '''Instructor Views Assignment Leaderboard'''
** Actor: Instructor
** Other Participants: None
** Primary Sequence:
**# Log into Expertiza
**# Select Assignments
**# Select View Badges on assignment
* '''Instructor Edits Assignment Badges'''
** Actor: Instructor
** Other Participants: None
** Primary Sequence:
**# Log into Expertiza
**# Select Assignments
**# Select Edit Assignments
**# Select Badges tab
**# Check enable badges
**# Check Score Threshold
**# Enter 95.5 as scoring threshold
**# Select Save
* '''Instructor Creates Course Badges'''
** Actor: Instructor
** Other Participants: None
** Primary Sequence:
**# Log into Expertiza
**# Select LeaderBoard
**# Select Award Badges
**# Select Create new badge
**# Create new badge using Credly
**# Select Save

===Tasks To Do===
*Create db table to store the participants with badges.
*Write code for calling the service and calculating/identifying badges based on the scores of students on all assignments.
*Add badge specification to course details and assignment details page for the instructor to specify the badges.
*Create views for both students and instructors. Students should be able to view their badges from different courses and instructors should be able to see the badges awarded/earned for their class.
*Display a subset of the badge holders on the leaderboard page. Also, student can view badges of other students in the course.
*Criteria to be followed for awarding badges:
#Top scores for an assignment. (configured at assignment page)
#All scores more than a threshold for an assignment. (configured at assignment page)
#Mean score of selected assignments being greater than threshold. (configured at course page)
#Top mean score of selected assignments. (configured at course page)
#Discretionary merit badges for projects that exceed expectations.

===Files Identified===
*Modified files:
**app/controllers/student_task_controller.rb
**app/controllers/users_controller.rb
**app/models/user.rb
**app/views/leaderboard/index.html.erb
**app/views/leaderboard/_top3LeaderBoards.html.erb
**app/views/leaderboard/_achievementLeaderBoards.html.erb
**app/views/course/edit.html.erb
**config/routes.rb

*Newly added files:
**app/models/badges.rb
**app/models/badge_groups.rb
**app/controllers/badges_controller.rb
**app/controllers/badge_groups_controller.rb
**app/views/users/credly_register.html.erb
**app/views/assignments/edit/_badges_configuration.html.erb
**app/views/badges/

===Deciding External Web Service===
{| class="wikitable"
|-
! Factors !! Open Badges !! Credly !! Bestr
|-
| Native User Management || No || Yes. No need to store all records locally. || No
|-
| Extensive API Support || Yes. But many still in beta phase. || Yes. (Primary reason for choosing Credly) || No
|-
| Interactive Badge Builder SDK|| Yes. But still in beta phase. || Yes || Yes. But gives few options for cusromization.
|-
| Existing Integration with other systems || Few || Many || No
|-
| Monetary Costs || Free || Free tier as well as paid plans. || Paid.
|}

From the above rubrics, we decided to use Credly as our web service for badging system.

==Database Design==
The following tables will be created to implement a solution for this project.

1. badges table - which stores badge_id and their descriptions.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| id || int || Primary key. Auto-generated
|-
| name || varchar || Description of the badge
|-
| credly_badge_id || int || Corresponding badge id with Credly
|}

2. badge_users table - which stores details about what badges are assignment to a user and related details.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| id || int || Primary key. Auto-generated
|-
| badge_id || int || Referenced from badges table
|-
| user_id || int || Referenced from users table
|-
| course_id || int || Referenced from courses table
|-
| assignment_id || int || Referenced from assignments table
|-
| is_course_badge || boolean || Whether badge is a course-badge or individual-badge
|}

3. badge_groups - which stores information about which badges should be assigned depending on the threshold score.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| id || int || Primary key. Auto-generated
|-
| strategy || varchar || Describes the strategy of awarding
|-
| badge_id || int || Assigned badge id.
|-
| course_id || int || Course for which group is formed.
|-
| is_course_level_group || boolean || Whether group is for course
|-
| threshold || int || Score required to award the badge
|}

4. assignment_groups - which stores details about the team badges.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| id || int || Primary key. Auto-generated
|-
| badge_group_id || int || Referenced from badge_groups table
|-
| assignment_id || int || Referenced from assignments table
|}

==Design Pattern==
# MVC – The project is implemented in Ruby on Rails that uses MVC architecture. It separates an application’s data model, user interface, and control logic into three distinct components (model, view and controller, respectively).
# DRY Principle – We are trying to reuse the existing functionalities in Expertiza, thus avoiding code duplication. Whenever possible, code modification based on the existing classes, controllers, or tables will be done instead of creating the new one.

==Object Oriented Design==
As with most Ruby on Rails applications, this solution uses the Model-View-Controller
design pattern. The following diagram shows a workflow of the planned design along with the attributes and operations that are
relevant to the implementation of this solution.

[[File:badging_class_diagram.png]]

==Walkthrough==
Below is a walkthrough of the changes to implement the Badging System:
===Instructor===
Instructors may configure badges on the course page using the new badge configuration icon:

[[File:Manage_courses_badges.jpg]]

Upon clicking the badge configuration icon, the user will be presented with two items: create groups and view all existing groups. Users may also edit and delete groups. A group is a set of assignments to present badges for.

[[File:badges_configuration.jpg]]

A new group may be created using the form below. This form allows instructors to create a new badge while creating a group for which they will be redirected to Credly. The form page must be refreshed upon creating a new badge so it may appear in the interface. The result of this form will create a new record in badge_groups and assignment_groups tables.

[[File:badges_new.jpg]]

==Mockups==
The Expertiza badging system will largely be driven by academic achievement from students. By using student’s scores as a way to provide badges it will be easy to automate the badge reward system upon closing an assignment. For instance, an instructor may decide to reward badges to the top 3 scores on an assignment so once the assignment closes those students will automatically be given those badges.

In order to use badges for an assignment, an instructor must turn on badging for their assignment upon creating or editing an assignment. When turning on the badging system the instructor may specify how many badges will be distributed, or choose to distribute them based off of a scoring threshold that students must achieve.

Following the completion of an assignment an instructor may view the awarded badges on the assignment page. A student will be able to view their earned badges on their homepage categorized by course and assignment.

The layout of each page will match with the currently existing design standards in Expertiza we will continue to use the header and will use headings and links much like other pages. Figure 1 below shows what the leaderboard may look like from a student perspective. Each course the student has participated in will be displayed on the page and by clicking the “Show Badges” the page will generate a list of each of the participants sorted by the number of badges they have earned. In order to display the badges the application will make a call to Credly to query about student badges.

[[File: StudentLeaderboard.png]]
Figure 1: Student Leaderboard

The next figures are all from the perspective of an inspector or admin. In Figure 3 below an instructor may view the badges earned for a given assignment or course in which they own. They will get to his page by clicking a badges button from either the assignments or courses page. The title of the page will be the name of either the course of assignment. Like the previous figure, by clicking show badges the list of course participants will appear sorted by the number of badges they have earned. Another link, “Award Badges” will be used to manually grant a badge. When an instructor or admin clicks on the link, they will be directed to the credly page in order to grant the badge to the student.

[[File: InstructorAssignment.png]]
Figure 2: Instructor assignment / course badge view

In order to use badges for an assignment, an instructor must first enable them for the assignment. The badges will be enabled by default. The figure below shows some of the settings associated with the badges system. Instructors may choose to automatically grant badges to students based off of their performance on the assignment. When editing or creating a new assignment they may come to the new badges tab and configure how they want the badges granted. Instructors may choose to grant some number of badges to the top scores of the group defined by the number the input, or they may decide to grant badges to anyone who may achieve a score past the provided scoring threshold.

[[File: EditAssignmentBadges.png]]
Figure 3: Assignment Badge Settings

Like assignments, courses also need to have some settings to configure badges. In Figure 4, instructors may automatically grant badges for students based on mean scores of multiple assignments throughout the course. First the instructor must check all of the assignments they would like to include in the mean then they must select a scoring strategy. Like the previous figure, they may choose between granting a badge to the top number of participants based on instructor input, or they may set a threshold on a mean score and any student who has achieved a score past the mean will be granted a badge.

[[File: BadgeCourseOptions.png]]
Figure 4: Edit Course

File:Badges new.jpg

2016-04-25T14:14:32Z

Magoff2:

File:Badges configuration.jpg

2016-04-25T14:09:43Z

Magoff2:

File:Manage courses badges.jpg

2016-04-25T14:06:21Z

Magoff2: Course page for badges

Course page for badges

CSC/ECE 517 Spring 2016/Badging System

2016-04-11T22:01:30Z

Magoff2: /* Mockups */

==Introduction==
===Background===
Much like physical badges in the army and youth scout troops, digital badges are an assessment and credentialing mechanism that is housed and managed online. Badges are designed to make visible and validate learning in both formal and informal settings, and hold the potential to help transform where and how learning is valued. In other words, badges may be used in order to set goals and motivations for students and reward and may help to improve their academic scores. Badges can also be considered as a way to reward student’s success. Moreover, badges can be used by teachers for alternative assessment techniques.

===Purpose===
One request for the Expertiza system is to add a badging system as a way to measure student performance. Expertiza will take advantage of the motivations created from badges by awarding students with new badges based off providing a variety of factors within the Expertiza system. Some of these badges include: achieving a top percentage of scores in an assignment, achieving a high peer review score, performing well overall in a course and other manual accomplishments deemed necessary by the teaching staff for a course. Instead of implementing the whole badging system, we will call an existing online badging web service, Credly, and integrate it with Expertiza.

==Requirements==
===System Requirements===
The system requirements focuses on adding a 'badging' functionality in Expertiza. This feature allows instructors to assign badges to students based on their performance and accomplishments. Badges are of types - course-level and assignment-level. Badges can be pre-selected while creating an assignment and automatically triggered when student finished the assignment or assignment is closed. Badges can also be awarded manually by instructor to an individual or a team. A leaderboard gives an account of standing of students in terms of badges earned. In order to implement a badging system, a third party badge manager will be utilized called Credly. Credly provides a way for users to accumulate and display badges they earn in a centralized way. By utilizing Credly, the development of the actual badges and badge management can be abstracted away from the project.

The testing of these requirements will use Rspec testing framework for all non-user interface related modifications. All user-interface modifications resulting from the user requirements will be tested manually.
===Use Case===
The following simple illustration shows the use cases of the system.

[[File:Use_case.PNG]]

====Use Cases====
* '''Student Views Leaderboard'''
** Actor: Student
** Other Participants: None
** Primary Sequence:
**# Log into Expertiza
**# Mouse over Home
**# Select Leaderboard
* '''Instructor Views Assignment Leaderboard'''
** Actor: Instructor
** Other Participants: None
** Primary Sequence:
**# Log into Expertiza
**# Select Assignments
**# Select View Badges on assignment
* '''Instructor Edits Assignment Badges'''
** Actor: Instructor
** Other Participants: None
** Primary Sequence:
**# Log into Expertiza
**# Select Assignments
**# Select Edit Assignments
**# Select Badges tab
**# Check enable badges
* '''Instructor Creates Course Badges'''
** Actor: Instructor
** Other Participants: None
** Primary Sequence:
**# Log into Expertiza
**# Select Courses
**# Select Edit Badges
**# Check assignments
**# Check Score Threshold
**# Enter 95.5 as scoring threshold
**# Select Submit

===Tasks To Do===
*Create db table to store the participants with badges.
*Write code for calling the service and calculating/identifying badges based on the scores of students on all assignments.
*Add badge specification to course details and assignment details page for the instructor to specify the badges.
*Create views for both students and instructors. Students should be able to view their badges from different courses and instructors should be able to see the badges awarded/earned for their class.
*Display a subset of the badge holders on the leaderboard page. Also, student can view badges of other students in the course.
*Criteria to be followed for awarding badges:
#Top scores for an assignment. (configured at assignment page)
#All scores more than a threshold for an assignment. (configured at assignment page)
#Mean score of selected assignments being greater than threshold. (configured at course page)
#Top mean score of selected assignments. (configured at course page)
#Discretionary merit badges for projects that exceed expectations.

===Files Identified===
Associated files goes here.

===Deciding External Web Service===
{| class="wikitable"
|-
! Factors !! Open Badges !! Credly !! Bestr
|-
| Native User Management || No || Yes. No need to store all records locally. || No
|-
| Extensive API Support || Yes. But many still in beta phase. || Yes. (Primary reason for choosing Credly) || No
|-
| Interactive Badge Builder SDK|| Yes. But still in beta phase. || Yes || Yes. But gives few options for cusromization.
|-
| Existing Integration with other systems || Few || Many || No
|-
| Monetary Costs || Free || Free tier as well as paid plans. || Paid.
|}

From the above rubrics, we decided to use Credly as our web service for badging system.

==Database Design==
The following tables will be created to implement a solution for this project.

1. badges table - which stores badge_id and their descriptions.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| badge_id || int || Primary key. Auto-generated
|-
| name || string || Description of the badge
|}

2. badge_users table - which stores details about what badges are assignment to a user and related details.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| badge_user_id || int || Primary key. Auto-generated
|-
| badge_id || int || Referenced from badges table
|-
| user_id || int || Referenced from users table
|-
| course_id || int || Referenced from courses table
|-
| assignment_id || int || Referenced from assignments table
|-
| is_course_badge || boolean || Whether badge is a course-badge or individual-badge
|}

3. badge_groups - which stores information about which badges should be assigned depending on the threshold score.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| badge_group_id || int || Primary key. Auto-generated
|-
| strategy || string || Describes the strategy of awarding
|-
| threshold || int || Score required to award the badge
|}

4. assignment_groups - which stores details about the team badges.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| assignment_group_id || int || Primary key. Auto-generated
|-
| badge_group_id || int || Referenced from badge_groups table
|-
| assignment_id || int || Referenced from assignments table
|}

==Design Pattern==
# MVC – The project is implemented in Ruby on Rails that uses MVC architecture. It separates an application’s data model, user interface, and control logic into three distinct components (model, view and controller, respectively).
# DRY Principle – We are trying to reuse the existing functionalities in Expertiza, thus avoiding code duplication. Whenever possible, code modification based on the existing classes, controllers, or tables will be done instead of creating the new one.

==Object Oriented Design==
As with most Ruby on Rails applications, this solution uses the Model-View-Controller
design pattern. The following diagram shows a workflow of the planned design along with the attributes and operations that are
relevant to the implementation of this solution.

[[File:Cap1.PNG]]

==Mockups==
The Expertiza badging system will largely be driven by academic achievement from students. By using student’s scores as a way to provide badges it will be easy to automate the badge reward system upon closing an assignment. For instance, an instructor may decide to reward badges to the top 3 scores on an assignment so once the assignment closes those students will automatically be given those badges.

In order to use badges for an assignment, an instructor must turn on badging for their assignment upon creating or editing an assignment. When turning on the badging system the instructor may specify how many badges will be distributed, or choose to distribute them based off of a scoring threshold that students must achieve.

Following the completion of an assignment an instructor may view the awarded badges on the assignment page. A student will be able to view their earned badges on their homepage categorized by course and assignment.
.
The layout of each page will match with the currently existing design standards in Expertiza we will continue to use the header and will use headings and links much like other pages. Figure 1 below shows what the leaderboard may look like from a student perspective. Each course the student has participated in will be displayed on the page and by clicking the “Show Badges” the page will generate a list of each of the participants sorted by the number of badges they have earned. In order to display the badges the application will make a call to Credly to query about student badges.

[[File: StudentLeaderboard.png]]
Figure 1: Student Leaderboard

The next figures are all from the perspective of an inspector or admin. In Figure 3 below an instructor may view the badges earned for a given assignment or course in which they own. They will get to his page by clicking a badges button from either the assignments or courses page. The title of the page will be the name of either the course of assignment. Like the previous figure, by clicking show badges the list of course participants will appear sorted by the number of badges they have earned. Another link, “Award Badges” will be used to manually grant a badge. When an instructor or admin clicks on the link, they will be directed to the credly page in order to grant the badge to the student.

[[File: InstructorAssignment.png]]
Figure 2: Instructor assignment / course badge view

In order to use badges for an assignment, an instructor must first enable them for the assignment. The badges will be enabled by default. The figure below shows some of the settings associated with the badges system. Instructors may choose to automatically grant badges to students based off of their performance on the assignment. When editing or creating a new assignment they may come to the new badges tab and configure how they want the badges granted. Instructors may choose to grant some number of badges to the top scores of the group defined by the number the input, or they may decide to grant badges to anyone who may achieve a score past the provided scoring threshold.

[[File: EditAssignmentBadges.png]]
Figure 3: Assignment Badge Settings

Like assignments, courses also need to have some settings to configure badges. In Figure 4, instructors may automatically grant badges for students based on mean scores of multiple assignments throughout the course. First the instructor must check all of the assignments they would like to include in the mean then they must select a scoring strategy. Like the previous figure, they may choose between granting a badge to the top number of participants based on instructor input, or they may set a threshold on a mean score and any student who has achieved a score past the mean will be granted a badge.

[[File: BadgeCourseOptions.png]]
Figure 4: Edit Course

CSC/ECE 517 Spring 2016/Badging System

2016-04-11T21:59:56Z

Magoff2:

==Introduction==
===Background===
Much like physical badges in the army and youth scout troops, digital badges are an assessment and credentialing mechanism that is housed and managed online. Badges are designed to make visible and validate learning in both formal and informal settings, and hold the potential to help transform where and how learning is valued. In other words, badges may be used in order to set goals and motivations for students and reward and may help to improve their academic scores. Badges can also be considered as a way to reward student’s success. Moreover, badges can be used by teachers for alternative assessment techniques.

===Purpose===
One request for the Expertiza system is to add a badging system as a way to measure student performance. Expertiza will take advantage of the motivations created from badges by awarding students with new badges based off providing a variety of factors within the Expertiza system. Some of these badges include: achieving a top percentage of scores in an assignment, achieving a high peer review score, performing well overall in a course and other manual accomplishments deemed necessary by the teaching staff for a course. Instead of implementing the whole badging system, we will call an existing online badging web service, Credly, and integrate it with Expertiza.

==Requirements==
===System Requirements===
The system requirements focuses on adding a 'badging' functionality in Expertiza. This feature allows instructors to assign badges to students based on their performance and accomplishments. Badges are of types - course-level and assignment-level. Badges can be pre-selected while creating an assignment and automatically triggered when student finished the assignment or assignment is closed. Badges can also be awarded manually by instructor to an individual or a team. A leaderboard gives an account of standing of students in terms of badges earned. In order to implement a badging system, a third party badge manager will be utilized called Credly. Credly provides a way for users to accumulate and display badges they earn in a centralized way. By utilizing Credly, the development of the actual badges and badge management can be abstracted away from the project.

The testing of these requirements will use Rspec testing framework for all non-user interface related modifications. All user-interface modifications resulting from the user requirements will be tested manually.
===Use Case===
The following simple illustration shows the use cases of the system.

[[File:Use_case.PNG]]

====Use Cases====
* '''Student Views Leaderboard'''
** Actor: Student
** Other Participants: None
** Primary Sequence:
**# Log into Expertiza
**# Mouse over Home
**# Select Leaderboard
* '''Instructor Views Assignment Leaderboard'''
** Actor: Instructor
** Other Participants: None
** Primary Sequence:
**# Log into Expertiza
**# Select Assignments
**# Select View Badges on assignment
* '''Instructor Edits Assignment Badges'''
** Actor: Instructor
** Other Participants: None
** Primary Sequence:
**# Log into Expertiza
**# Select Assignments
**# Select Edit Assignments
**# Select Badges tab
**# Check enable badges
* '''Instructor Creates Course Badges'''
** Actor: Instructor
** Other Participants: None
** Primary Sequence:
**# Log into Expertiza
**# Select Courses
**# Select Edit Badges
**# Check assignments
**# Check Score Threshold
**# Enter 95.5 as scoring threshold
**# Select Submit

===Tasks To Do===
*Create db table to store the participants with badges.
*Write code for calling the service and calculating/identifying badges based on the scores of students on all assignments.
*Add badge specification to course details and assignment details page for the instructor to specify the badges.
*Create views for both students and instructors. Students should be able to view their badges from different courses and instructors should be able to see the badges awarded/earned for their class.
*Display a subset of the badge holders on the leaderboard page. Also, student can view badges of other students in the course.
*Criteria to be followed for awarding badges:
#Top scores for an assignment. (configured at assignment page)
#All scores more than a threshold for an assignment. (configured at assignment page)
#Mean score of selected assignments being greater than threshold. (configured at course page)
#Top mean score of selected assignments. (configured at course page)
#Discretionary merit badges for projects that exceed expectations.

===Files Identified===
Associated files goes here.

===Deciding External Web Service===
{| class="wikitable"
|-
! Factors !! Open Badges !! Credly !! Bestr
|-
| Native User Management || No || Yes. No need to store all records locally. || No
|-
| Extensive API Support || Yes. But many still in beta phase. || Yes. (Primary reason for choosing Credly) || No
|-
| Interactive Badge Builder SDK|| Yes. But still in beta phase. || Yes || Yes. But gives few options for cusromization.
|-
| Existing Integration with other systems || Few || Many || No
|-
| Monetary Costs || Free || Free tier as well as paid plans. || Paid.
|}

From the above rubrics, we decided to use Credly as our web service for badging system.

==Database Design==
The following tables will be created to implement a solution for this project.

1. badges table - which stores badge_id and their descriptions.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| badge_id || int || Primary key. Auto-generated
|-
| name || string || Description of the badge
|}

2. badge_users table - which stores details about what badges are assignment to a user and related details.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| badge_user_id || int || Primary key. Auto-generated
|-
| badge_id || int || Referenced from badges table
|-
| user_id || int || Referenced from users table
|-
| course_id || int || Referenced from courses table
|-
| assignment_id || int || Referenced from assignments table
|-
| is_course_badge || boolean || Whether badge is a course-badge or individual-badge
|}

3. badge_groups - which stores information about which badges should be assigned depending on the threshold score.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| badge_group_id || int || Primary key. Auto-generated
|-
| strategy || string || Describes the strategy of awarding
|-
| threshold || int || Score required to award the badge
|}

4. assignment_groups - which stores details about the team badges.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| assignment_group_id || int || Primary key. Auto-generated
|-
| badge_group_id || int || Referenced from badge_groups table
|-
| assignment_id || int || Referenced from assignments table
|}

==Design Pattern==
# MVC – The project is implemented in Ruby on Rails that uses MVC architecture. It separates an application’s data model, user interface, and control logic into three distinct components (model, view and controller, respectively).
# DRY Principle – We are trying to reuse the existing functionalities in Expertiza, thus avoiding code duplication. Whenever possible, code modification based on the existing classes, controllers, or tables will be done instead of creating the new one.

==Object Oriented Design==
As with most Ruby on Rails applications, this solution uses the Model-View-Controller
design pattern. The following diagram shows a workflow of the planned design along with the attributes and operations that are
relevant to the implementation of this solution.

[[File:Cap1.PNG]]

==Mockups==
The Expertiza badging system will largely be driven by academic achievement from students. By using student’s scores as a way to provide badges it will be easy to automate the badge reward system upon closing an assignment. For instance, an instructor may decide to reward badges to the top 3 scores on an assignment so once the assignment closes those students will automatically be given those badges.

In order to use badges for an assignment, an instructor must turn on badging for their assignment upon creating or editing an assignment. When turning on the badging system the instructor may specify how many badges will be distributed, or choose to distribute them based off of a scoring threshold that students must achieve.

Following the completion of an assignment an instructor may view the awarded badges on the assignment page. A student will be able to view their earned badges on their homepage categorized by course and assignment.
.
The layout of each page will match with the currently existing design standards in Expertiza we will continue to use the header and will use headings and links much like other pages. Figure 1 below shows what the leaderboard may look like from a student perspective. Each course the student has participated in will be displayed on the page and by clicking the “Show Badges” the page will generate a list of each of the participants sorted by the number of badges they have earned. In order to display the badges the application will make a call to Credly to query about student badges.

[[File: StudentLeaderboard.png]]
Figure 1: Student Leaderboard

The next figures are all from the perspective of an inspector or admin. In Figure 3 below an instructor may view the badges earned for a given assignment or course in which they own. They will get to his page by clicking a badges button from either the assignments or courses page. The title of the page will be the name of either the course of assignment. Like the previous figure, by clicking show badges the list of course participants will appear sorted by the number of badges they have earned. Another link, “Award Badges” will be used to manually grant a badge. When an instructor or admin clicks on the link, they will be directed to the credly page in order to grant the badge to the student.

[[File: InstructorAssignment.png]]
Figure 2: Instructor assignment / course badge view

In order to use badges for an assignment, an instructor must first enable them for the assignment. The badges will be enabled by default. The figure below shows some of the settings associated with the badges system. Instructors may choose to automatically grant badges to students based off of their performance on the assignment. When editing or creating a new assignment they may come to the new badges tab and configure how they want the badges granted. Instructors may choose to grant some number of badges to the top scores of the group defined by the number the input, or they may decide to grant badges to anyone who may achieve a score past the provided scoring threshold.

[[File: EditAssignmentBadges.png]]
Figure 3: Assignment Badge Settings

Like assignments, courses also need to have some settings to configure badges. In Figure 4, instructors may automatically grant badges for students based on mean scores of multiple assignments throughout the course. First the instructor must check all of the assignments they would like to include in the mean then they must select a scoring strategy. Like the previous figure, they may choose between granting a badge to the top number of participants based on instructor input, or they may set a threshold on a mean score and any student who has achieved a score past the mean will be granted a badge.

[[File: BadgeCourseOptions.png]]
Figure 4: Edit Course

CSC/ECE 517 Spring 2016/Badging System

2016-04-11T21:57:54Z

Magoff2: Added some use cases

==Introduction==
===Background===
Much like physical badges in the army and youth scout troops, digital badges are an assessment and credentialing mechanism that is housed and managed online. Badges are designed to make visible and validate learning in both formal and informal settings, and hold the potential to help transform where and how learning is valued. In other words, badges may be used in order to set goals and motivations for students and reward and may help to improve their academic scores. Badges can also be considered as a way to reward student’s success. Moreover, badges can be used by teachers for alternative assessment techniques.

===Purpose===
One request for the Expertiza system is to add a badging system as a way to measure student performance. Expertiza will take advantage of the motivations created from badges by awarding students with new badges based off providing a variety of factors within the Expertiza system. Some of these badges include: achieving a top percentage of scores in an assignment, achieving a high peer review score, performing well overall in a course and other manual accomplishments deemed necessary by the teaching staff for a course. Instead of implementing the whole badging system, we will call an existing online badging web service, Credly, and integrate it with Expertiza.

==Requirements==
===System Requirements===
The system requirements focuses on adding a 'badging' functionality in Expertiza. This feature allows instructors to assign badges to students based on their performance and accomplishments. Badges are of types - course-level and assignment-level. Badges can be pre-selected while creating an assignment and automatically triggered when student finished the assignment or assignment is closed. Badges can also be awarded manually by instructor to an individual or a team. A leaderboard gives an account of standing of students in terms of badges earned. In order to implement a badging system, a third party badge manager will be utilized called Credly. Credly provides a way for users to accumulate and display badges they earn in a centralized way. By utilizing Credly, the development of the actual badges and badge management can be abstracted away from the project.

The testing of these requirements will use Rspec testing framework for all non-user interface related modifications. All user-interface modifications resulting from the user requirements will be tested manually.
===Use Case===
The following simple illustration shows the use cases of the system.

[[File:Use_case.PNG]]

====Use Cases====
* Student Views Leaderboard
** Actor: Student
** Other Participants: None
** Primary Sequence:
**# Log into Expertiza
**# Mouse over Home
**# Select Leaderboard
* Instructor Views Assignment Leaderboard
** Actor: Instructor
** Other Participants: None
** Primary Sequence:
**# Log into Expertiza
**# Select Assignments
**# Select View Badges on assignment
* Instructor Edits Assignment Badges
** Actor: Instructor
** Other Participants: None
** Primary Sequence:
**# Log into Expertiza
**# Select Assignments
**# Select Edit Assignments
**# Select Badges tab
**# Check enable badges
* Instructor Creates Course Badges
** Actor: Instructor
** Other Participants: None
** Primary Sequence:
**# Log into Expertiza
**# Select Courses
**# Select Edit Badges
**# Check assignments
**# Check Score Threshold
**# Enter 95.5 as scoring threshold
**# Select Submit

===Tasks To Do===
*Create db table to store the participants with badges.
*Write code for calling the service and calculating/identifying badges based on the scores of students on all assignments.
*Add badge specification to course details and assignment details page for the instructor to specify the badges.
*Create views for both students and instructors. Students should be able to view their badges from different courses and instructors should be able to see the badges awarded/earned for their class.
*Display a subset of the badge holders on the leaderboard page. Also, student can view badges of other students in the course.
*Criteria to be followed for awarding badges:
#Top scores for an assignment. (configured at assignment page)
#All scores more than a threshold for an assignment. (configured at assignment page)
#Mean score of selected assignments being greater than threshold. (configured at course page)
#Top mean score of selected assignments. (configured at course page)
#Discretionary merit badges for projects that exceed expectations.

===Files Identified===
Associated files goes here.

===Deciding External Web Service===
{| class="wikitable"
|-
! Factors !! Open Badges !! Credly !! Bestr
|-
| Native User Management || No || Yes. No need to store all records locally. || No
|-
| Extensive API Support || Yes. But many still in beta phase. || Yes. (Primary reason for choosing Credly) || No
|-
| Interactive Badge Builder SDK|| Yes. But still in beta phase. || Yes || Yes. But gives few options for cusromization.
|-
| Existing Integration with other systems || Few || Many || No
|-
| Monetary Costs || Free || Free tier as well as paid plans. || Paid.
|}

From the above rubrics, we decided to use Credly as our web service for badging system.

==Design==
The Expertiza badging system will largely be driven by academic achievement from students. By using student’s scores as a way to provide badges it will be easy to automate the badge reward system upon closing an assignment. For instance, an instructor may decide to reward badges to the top 3 scores on an assignment so once the assignment closes those students will automatically be given those badges.

In order to use badges for an assignment, an instructor must turn on badging for their assignment upon creating or editing an assignment. When turning on the badging system the instructor may specify how many badges will be distributed, or choose to distribute them based off of a scoring threshold that students must achieve.

Following the completion of an assignment an instructor may view the awarded badges on the assignment page. A student will be able to view their earned badges on their homepage categorized by course and assignment.
.
The layout of each page will match with the currently existing design standards in Expertiza we will continue to use the header and will use headings and links much like other pages. Figure 1 below shows what the leaderboard may look like from a student perspective. Each course the student has participated in will be displayed on the page and by clicking the “Show Badges” the page will generate a list of each of the participants sorted by the number of badges they have earned. In order to display the badges the application will make a call to Credly to query about student badges.

[[File: StudentLeaderboard.png]]
Figure 1: Student Leaderboard

The next figures are all from the perspective of an inspector or admin. In Figure 3 below an instructor may view the badges earned for a given assignment or course in which they own. They will get to his page by clicking a badges button from either the assignments or courses page. The title of the page will be the name of either the course of assignment. Like the previous figure, by clicking show badges the list of course participants will appear sorted by the number of badges they have earned. Another link, “Award Badges” will be used to manually grant a badge. When an instructor or admin clicks on the link, they will be directed to the credly page in order to grant the badge to the student.

[[File: InstructorAssignment.png]]
Figure 2: Instructor assignment / course badge view

In order to use badges for an assignment, an instructor must first enable them for the assignment. The badges will be enabled by default. The figure below shows some of the settings associated with the badges system. Instructors may choose to automatically grant badges to students based off of their performance on the assignment. When editing or creating a new assignment they may come to the new badges tab and configure how they want the badges granted. Instructors may choose to grant some number of badges to the top scores of the group defined by the number the input, or they may decide to grant badges to anyone who may achieve a score past the provided scoring threshold.

[[File: EditAssignmentBadges.png]]
Figure 3: Assignment Badge Settings

Like assignments, courses also need to have some settings to configure badges. In Figure 4, instructors may automatically grant badges for students based on mean scores of multiple assignments throughout the course. First the instructor must check all of the assignments they would like to include in the mean then they must select a scoring strategy. Like the previous figure, they may choose between granting a badge to the top number of participants based on instructor input, or they may set a threshold on a mean score and any student who has achieved a score past the mean will be granted a badge.

[[File: BadgeCourseOptions.png]]
Figure 4: Edit Course

==Database Design==
The following tables will be created to implement a solution for this project.

1. badges table - which stores badge_id and their descriptions.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| badge_id || int || Primary key. Auto-generated
|-
| name || string || Description of the badge
|}

2. badge_users table - which stores details about what badges are assignment to a user and related details.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| badge_user_id || int || Primary key. Auto-generated
|-
| badge_id || int || Referenced from badges table
|-
| user_id || int || Referenced from users table
|-
| course_id || int || Referenced from courses table
|-
| assignment_id || int || Referenced from assignments table
|-
| is_course_badge || boolean || Whether badge is a course-badge or individual-badge
|}

3. badge_groups - which stores information about which badges should be assigned depending on the threshold score.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| badge_group_id || int || Primary key. Auto-generated
|-
| strategy || string || Describes the strategy of awarding
|-
| threshold || int || Score required to award the badge
|}

4. assignment_groups - which stores details about the team badges.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| assignment_group_id || int || Primary key. Auto-generated
|-
| badge_group_id || int || Referenced from badge_groups table
|-
| assignment_id || int || Referenced from assignments table
|}

==Design Pattern==
# MVC – The project is implemented in Ruby on Rails that uses MVC architecture. It separates an application’s data model, user interface, and control logic into three distinct components (model, view and controller, respectively).
# DRY Principle – We are trying to reuse the existing functionalities in Expertiza, thus avoiding code duplication. Whenever possible, code modification based on the existing classes, controllers, or tables will be done instead of creating the new one.

==Object Oriented Design==
As with most Ruby on Rails applications, this solution uses the Model-View-Controller
design pattern. The following diagram shows a workflow of the planned design along with the attributes and operations that are
relevant to the implementation of this solution.

[[File:Cap1.PNG]]

==Mockups==

Mockup goes here

CSC/ECE 517 Spring 2016/Badging System

2016-04-11T21:48:22Z

Magoff2: Added images

File:BadgeCourseOptions.png

2016-04-11T21:47:47Z

Magoff2:

File:EditAssignmentBadges.png

2016-04-11T21:46:44Z

Magoff2: uploaded a new version of "File:EditAssignmentBadges.png"

File:InstructorAssignment.png

2016-04-11T21:45:43Z

Magoff2: uploaded a new version of "File:InstructorAssignment.png"

File:StudentLeaderboard.png

2016-04-11T21:44:00Z

Magoff2: uploaded a new version of "File:StudentLeaderboard.png"

First one broke trying again

File:EditAssignmentBadges.png

2016-04-11T21:40:03Z

Magoff2:

File:InstructorAssignment.png

2016-04-11T21:37:55Z

Magoff2:

File:StudentLeaderboard.png

2016-04-11T21:36:00Z

Magoff2: First one broke trying again

First one broke trying again

CSC/ECE 517 Spring 2016/Badging System

2016-04-11T21:33:43Z

Magoff2:

==Introduction==
===Background===
Much like physical badges in the army and youth scout troops, digital badges are an assessment and credentialing mechanism that is housed and managed online. Badges are designed to make visible and validate learning in both formal and informal settings, and hold the potential to help transform where and how learning is valued. In other words, badges may be used in order to set goals and motivations for students and reward and may help to improve their academic scores. Badges can also be considered as a way to reward student’s success. Moreover, badges can be used by teachers for alternative assessment techniques.

===Purpose===
One request for the Expertiza system is to add a badging system as a way to measure student performance. Expertiza will take advantage of the motivations created from badges by awarding students with new badges based off providing a variety of factors within the Expertiza system. Some of these badges include: achieving a top percentage of scores in an assignment, achieving a high peer review score, performing well overall in a course and other manual accomplishments deemed necessary by the teaching staff for a course. Instead of implementing the whole badging system, we will call an existing online badging web service, Credly, and integrate it with Expertiza.

==Requirements==
===System Requirements===
The system requirements focuses on adding a 'badging' functionality in Expertiza. This feature allows instructors to assign badges to students based on their performance and accomplishments. Badges are of types - course-level and assignment-level. Badges can be pre-selected while creating an assignment and automatically triggered when student finished the assignment or assignment is closed. Badges can also be awarded manually by instructor to an individual or a team. A leaderboard gives an account of standing of students in terms of badges earned. In order to implement a badging system, a third party badge manager will be utilized called Credly. Credly provides a way for users to accumulate and display badges they earn in a centralized way. By utilizing Credly, the development of the actual badges and badge management can be abstracted away from the project.

The testing of these requirements will use Rspec testing framework for all non-user interface related modifications. All user-interface modifications resulting from the user requirements will be tested manually.
===Use Case===
The following simple illustration shows the use cases of the system.

[[File:Use_case.PNG]]

===Tasks To Do===
*Create db table to store the participants with badges.
*Write code for calling the service and calculating/identifying badges based on the scores of students on all assignments.
*Add badge specification to course details and assignment details page for the instructor to specify the badges.
*Create views for both students and instructors. Students should be able to view their badges from different courses and instructors should be able to see the badges awarded/earned for their class.
*Display a subset of the badge holders on the leaderboard page. Also, student can view badges of other students in the course.
*Criteria to be followed for awarding badges:
#Top scores for an assignment. (configured at assignment page)
#All scores more than a threshold for an assignment. (configured at assignment page)
#Mean score of selected assignments being greater than threshold. (configured at course page)
#Top mean score of selected assignments. (configured at course page)
#Discretionary merit badges for projects that exceed expectations.

===Files Identified===
Associated files goes here.

===Deciding External Web Service===
{| class="wikitable"
|-
! Factors !! Open Badges !! Credly !! Bestr
|-
| Native User Management || No || Yes. No need to store all records locally. || No
|-
| Extensive API Support || Yes. But many still in beta phase. || Yes. (Primary reason for choosing Credly) || No
|-
| Interactive Badge Builder SDK|| Yes. But still in beta phase. || Yes || Yes. But gives few options for cusromization.
|-
| Existing Integration with other systems || Few || Many || No
|-
| Monetary Costs || Free || Free tier as well as paid plans. || Paid.
|}

From the above rubrics, we decided to use Credly as our web service for badging system.

==Design==
The Expertiza badging system will largely be driven by academic achievement from students. By using student’s scores as a way to provide badges it will be easy to automate the badge reward system upon closing an assignment. For instance, an instructor may decide to reward badges to the top 3 scores on an assignment so once the assignment closes those students will automatically be given those badges.

In order to use badges for an assignment, an instructor must turn on badging for their assignment upon creating or editing an assignment. When turning on the badging system the instructor may specify how many badges will be distributed, or choose to distribute them based off of a scoring threshold that students must achieve.

Following the completion of an assignment an instructor may view the awarded badges on the assignment page. A student will be able to view their earned badges on their homepage categorized by course and assignment.

In order to implement a badging system, a third party badge manager will be utilized called Credly. Credly provides a way for users to accumulate and display badges they earn in a centralized way. By utilizing Credly, the development of the actual badges and badge management can be abstracted away from the project.

The layout of each page will match with the currently existing design standards in Expertiza we will continue to use the header and will use headings and links much like other pages. Figure 1 below shows what the leaderboard may look like from a student perspective. Each course the student has participated in will be displayed on the page and by clicking the “Show Badges” the page will generate a list of each of the participants sorted by the number of badges they have earned. In order to display the badges the application will make a call to Credly to query about student badges.

[[File: Badge_student_leaderboard.png |600x454px]]
Figure 1: Student Leaderboard

The next figures are all from the perspective of an inspector or admin. In Figure 3 below an instructor may view the badges earned for a given assignment or course in which they own. They will get to his page by clicking a badges button from either the assignments or courses page. The title of the page will be the name of either the course of assignment. Like the previous figure, by clicking show badges the list of course participants will appear sorted by the number of badges they have earned. Another link, “Award Badges” will be used to manually grant a badge. When an instructor or admin clicks on the link, they will be directed to the credly page in order to grant the badge to the student.

[[File: example.jpg]]
Figure 2: Instructor assignment / course badge view

In order to use badges for an assignment, an instructor must first enable them for the assignment. The badges will be enabled by default. The figure below shows some of the settings associated with the badges system. Instructors may choose to automatically grant badges to students based off of their performance on the assignment. When editing or creating a new assignment they may come to the new badges tab and configure how they want the badges granted. Instructors may choose to grant some number of badges to the top scores of the group defined by the number the input, or they may decide to grant badges to anyone who may achieve a score past the provided scoring threshold.

[[File: example.jpg]]
Figure 3: Assignment Badge Settings

Like assignments, courses also need to have some settings to configure badges. In Figure 4, instructors may automatically grant badges for students based on mean scores of multiple assignments throughout the course. First the instructor must check all of the assignments they would like to include in the mean then they must select a scoring strategy. Like the previous figure, they may choose between granting a badge to the top number of participants based on instructor input, or they may set a threshold on a mean score and any student who has achieved a score past the mean will be granted a badge.

[[File: example.jpg]]
Figure 4: Edit Course

==Database Design==
The following tables will be created to implement a solution for this project.

1. badges table - which stores badge_id and their descriptions.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| badge_id || int || Primary key. Auto-generated
|-
| name || string || Description of the badge
|}

2. badge_users table - which stores details about what badges are assignment to a user and related details.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| badge_user_id || int || Primary key. Auto-generated
|-
| badge_id || int || Referenced from badges table
|-
| user_id || int || Referenced from users table
|-
| course_id || int || Referenced from courses table
|-
| assignment_id || int || Referenced from assignments table
|-
| is_course_badge || boolean || Whether badge is a course-badge or individual-badge
|}

3. badge_groups - which stores information about which badges should be assigned depending on the threshold score.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| badge_group_id || int || Primary key. Auto-generated
|-
| strategy || string || Describes the strategy of awarding
|-
| threshold || int || Score required to award the badge
|}

4. assignment_groups - which stores details about the team badges.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| assignment_group_id || int || Primary key. Auto-generated
|-
| badge_group_id || int || Referenced from badge_groups table
|-
| assignment_id || int || Referenced from assignments table
|}

==Design Pattern==
# MVC – The project is implemented in Ruby on Rails that uses MVC architecture. It separates an application’s data model, user interface, and control logic into three distinct components (model, view and controller, respectively).
# DRY Principle – We are trying to reuse the existing functionalities in Expertiza, thus avoiding code duplication. Whenever possible, code modification based on the existing classes, controllers, or tables will be done instead of creating the new one.

==Object Oriented Design==
As with most Ruby on Rails applications, this solution uses the Model-View-Controller
design pattern. The following diagram shows a workflow of the planned design along with the attributes and operations that are
relevant to the implementation of this solution.

[[File:Cap1.PNG]]

==Mockups==

Mockup goes here

CSC/ECE 517 Spring 2016/Badging System

2016-04-11T21:29:24Z

Magoff2:

==Introduction==
===Background===
Much like physical badges in the army and youth scout troops, digital badges are an assessment and credentialing mechanism that is housed and managed online. Badges are designed to make visible and validate learning in both formal and informal settings, and hold the potential to help transform where and how learning is valued. In other words, badges may be used in order to set goals and motivations for students and reward and may help to improve their academic scores. Badges can also be considered as a way to reward student’s success. Moreover, badges can be used by teachers for alternative assessment techniques.

===Purpose===
One request for the Expertiza system is to add a badging system as a way to measure student performance. Expertiza will take advantage of the motivations created from badges by awarding students with new badges based off providing a variety of factors within the Expertiza system. Some of these badges include: achieving a top percentage of scores in an assignment, achieving a high peer review score, performing well overall in a course and other manual accomplishments deemed necessary by the teaching staff for a course. Instead of implementing the whole badging system, we will call an existing online badging web service, Credly, and integrate it with Expertiza.

==Requirements==
===System Requirements===
The system requirements focuses on adding a 'badging' functionality in Expertiza. This feature allows instructors to assign badges to students based on their performance and accomplishments. Badges are of types - course-level and assignment-level. Badges can be pre-selected while creating an assignment and automatically triggered when student finished the assignment or assignment is closed. Badges can also be awarded manually by instructor to an individual or a team. A leaderboard gives an account of standing of students in terms of badges earned. In order to implement a badging system, a third party badge manager will be utilized called Credly. Credly provides a way for users to accumulate and display badges they earn in a centralized way. By utilizing Credly, the development of the actual badges and badge management can be abstracted away from the project.

The testing of these requirements will use Rspec testing framework for all non-user interface related modifications. All user-interface modifications resulting from the user requirements will be tested manually.
===Use Case===
The following simple illustration shows the use cases of the system.

[[File:Use_case.PNG]]

===Tasks To Do===
*Create db table to store the participants with badges.
*Write code for calling the service and calculating/identifying badges based on the scores of students on all assignments.
*Add badge specification to course details and assignment details page for the instructor to specify the badges.
*Create views for both students and instructors. Students should be able to view their badges from different courses and instructors should be able to see the badges awarded/earned for their class.
*Display a subset of the badge holders on the leaderboard page. Also, student can view badges of other students in the course.
*Criteria to be followed for awarding badges:
#Top scores for an assignment. (configured at assignment page)
#All scores more than a threshold for an assignment. (configured at assignment page)
#Mean score of selected assignments being greater than threshold. (configured at course page)
#Top mean score of selected assignments. (configured at course page)
#Discretionary merit badges for projects that exceed expectations.

===Deciding External Web Service===
{| class="wikitable"
|-
! Factors !! Open Badges !! Credly !! Bestr
|-
| Native User Management || No || Yes. No need to store all records locally. || No
|-
| Extensive API Support || Yes. But many still in beta phase. || Yes. (Primary reason for choosing Credly) || No
|-
| Interactive Badge Builder SDK|| Yes. But still in beta phase. || Yes || Yes. But gives few options for cusromization.
|-
| Existing Integration with other systems || Few || Many || No
|-
| Monetary Costs || Free || Free tier as well as paid plans. || Paid.
|}

From the above rubrics, we decided to use Credly as our web service for badging system.

==Design==
The Expertiza badging system will largely be driven by academic achievement from students. By using student’s scores as a way to provide badges it will be easy to automate the badge reward system upon closing an assignment. For instance, an instructor may decide to reward badges to the top 3 scores on an assignment so once the assignment closes those students will automatically be given those badges.

In order to use badges for an assignment, an instructor must turn on badging for their assignment upon creating or editing an assignment. When turning on the badging system the instructor may specify how many badges will be distributed, or choose to distribute them based off of a scoring threshold that students must achieve.

Following the completion of an assignment an instructor may view the awarded badges on the assignment page. A student will be able to view their earned badges on their homepage categorized by course and assignment.

In order to implement a badging system, a third party badge manager will be utilized called Credly. Credly provides a way for users to accumulate and display badges they earn in a centralized way. By utilizing Credly, the development of the actual badges and badge management can be abstracted away from the project.

The layout of each page will match with the currently existing design standards in Expertiza we will continue to use the header and will use headings and links much like other pages. Figure 1 below shows what the leaderboard may look like from a student perspective. Each course the student has participated in will be displayed on the page and by clicking the “Show Badges” the page will generate a list of each of the participants sorted by the number of badges they have earned. In order to display the badges the application will make a call to Credly to query about student badges.

[[File: Badge_student_leaderboard.png]]
Figure 1: Student Leaderboard

The next figures are all from the perspective of an inspector or admin. In Figure 3 below an instructor may view the badges earned for a given assignment or course in which they own. They will get to his page by clicking a badges button from either the assignments or courses page. The title of the page will be the name of either the course of assignment. Like the previous figure, by clicking show badges the list of course participants will appear sorted by the number of badges they have earned. Another link, “Award Badges” will be used to manually grant a badge. When an instructor or admin clicks on the link, they will be directed to the credly page in order to grant the badge to the student.

[[File: example.jpg]]
Figure 2: Instructor assignment / course badge view

In order to use badges for an assignment, an instructor must first enable them for the assignment. The badges will be enabled by default. The figure below shows some of the settings associated with the badges system. Instructors may choose to automatically grant badges to students based off of their performance on the assignment. When editing or creating a new assignment they may come to the new badges tab and configure how they want the badges granted. Instructors may choose to grant some number of badges to the top scores of the group defined by the number the input, or they may decide to grant badges to anyone who may achieve a score past the provided scoring threshold.

[[File: example.jpg]]
Figure 3: Assignment Badge Settings

Like assignments, courses also need to have some settings to configure badges. In Figure 4, instructors may automatically grant badges for students based on mean scores of multiple assignments throughout the course. First the instructor must check all of the assignments they would like to include in the mean then they must select a scoring strategy. Like the previous figure, they may choose between granting a badge to the top number of participants based on instructor input, or they may set a threshold on a mean score and any student who has achieved a score past the mean will be granted a badge.

[[File: example.jpg]]
Figure 4: Edit Course

==Database Design==
The following tables will be created to implement a solution for this project.

1. badges table - which stores badge_id and their descriptions.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| badge_id || int || Primary key. Auto-generated
|-
| name || string || Description of the badge
|}

2. badge_users table - which stores details about what badges are assignment to a user and related details.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| badge_user_id || int || Primary key. Auto-generated
|-
| badge_id || int || Referenced from badges table
|-
| user_id || int || Referenced from users table
|-
| course_id || int || Referenced from courses table
|-
| assignment_id || int || Referenced from assignments table
|-
| is_course_badge || boolean || Whether badge is a course-badge or individual-badge
|}

3. badge_groups - which stores information about which badges should be assigned depending on the threshold score.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| badge_group_id || int || Primary key. Auto-generated
|-
| strategy || string || Describes the strategy of awarding
|-
| threshold || int || Score required to award the badge
|}

4. assignment_groups - which stores details about the team badges.
{| class="wikitable"
|-
! Column !! Type !! Comment
|-
| assignment_group_id || int || Primary key. Auto-generated
|-
| badge_group_id || int || Referenced from badge_groups table
|-
| assignment_id || int || Referenced from assignments table
|}

==Design Pattern==
# MVC – The project is implemented in Ruby on Rails that uses MVC architecture. It separates an application’s data model, user interface, and control logic into three distinct components (model, view and controller, respectively).
# DRY Principle – We are trying to reuse the existing functionalities in Expertiza, thus avoiding code duplication. Whenever possible, code modification based on the existing classes, controllers, or tables will be done instead of creating the new one.

==Object Oriented Design==
As with most Ruby on Rails applications, this solution uses the Model-View-Controller
design pattern. The following diagram shows a workflow of the planned design along with the attributes and operations that are
relevant to the implementation of this solution.

[[File:Cap1.PNG]]

==Mockups==

Mockup goes here

File:Badge student leaderboard.png

2016-04-11T21:28:30Z

Magoff2: uploaded a new version of "File:Badge student leaderboard.png"

File:Badge student leaderboard.png

2016-04-11T21:28:06Z

Magoff2:

CSC/ECE 517 Spring 2016/Badging System

2016-04-11T21:27:07Z

Magoff2: Added design section need to figure out how to add images

CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature

2016-03-30T23:44:37Z

Magoff2:

This page will discuss the newly added peer self review feature that was added to the Expertiza project.

== Background ==
Developed by both students and faculty at [https://en.wikipedia.org/wiki/North_Carolina_State_University North Carolina State University] using [http://rubyonrails.org/ Ruby on Rails], [http://expertiza.ncsu.edu/ Expertiza] is a educational based web application that allows to students to peer review other student's work. In Expertiza, instructors are in charge of courses and within each course, they may create a series of assignments for students to contribute to, either as a member of a team or individually. Students or Teams may submit their assignments to the system through multiple means including file uploads and embedded links. Then assignments may become available to peer review by other members of the course, which provides a way to [https://en.wikipedia.org/wiki/Crowdsourcing crowd-source] grading on the work.

== Problem Statement ==
Expertiza previously contained a self-review feature where student's were able to review their own work after submitting their assignments but it was removed due to the inconsistency with the other types of reviews. The task was to re-implement the feature in a way that ensured the overall design would remain intact. The self-review feature should allow students to review their own submission using the same rubric that was provided to other peer reviewers of the assignment. By reviewing their own work, students will be able to assess the artifact through the rubric and may be inspired to make improvements between rounds of peer-reviews.

=== What Needs Done: ===
The following tasks were given to be completed by the team:
* The self-review feature should use the same questionnaire_id as a peer-review. That way developers may call "''assignment.get_review_questionnaire_id(round)''" to get a questionnaire for the self-review.
* A method called "''self_review_response_map?''" should be added to ''review_response_map.rb''. The method will return true if the response_map is a self_response map. In order to determine the result the method shall compare the ''reviewer_id'' and ''reviewee_id'' in the response_map record and if the participant is a member of the reviewee team, true will be returned.
* Student shall do a self-review in the "your work" section. There should be a button called "Review my own work" (or "our own work" if it is a team assignment). When the button is clicked a new review_response_map record is created. Within the map, the reviewer_id is the participant id and the reviewee_id is the team_id.
* If the response_map record for self-review exists, a hyperlink with the text "begin" should appear. A student may click the link and fill in the questionnaire just like how they would for a regular peer review.
* If the self-review response_map exists and there has already been a response, two links entitled "view" and "edit" will appear that will function similarly to peer reviews.
* If the self-review was completed in the last round and the current round uses a different questionnaire (using the ''vary_rubric_by_round'' feature), a link called "update" will appear, which brings students to a new page to fill in the new rubric for the new round.
* In ''grades_controller.view_my_scores,'' self-review responses shall be excluded.
* In ''grades_controller.view_team,'' self-review responses shall be excluded.
* In ''grades_controller.view,'' self-review responses shall be excluded.
* The method called "''add_self_reviewer"'' in ''ReviewMappingController'', shall allow instructors to create self-review response maps. This method needs to be made functional again.
* Automated tests must be created.

== Files Modified in Project ==
The following files were modified in creating the new self-review feature
* ''review_response_map.rb''
* ''review_mapping_controller.rb''
* ''response_controller.rb''
* ''_set_dynamic_review.html.erb''
* ''_main.html.erb''
* ''_review_strategy.html.erb''
* ''response.html.erb''
* ''routes.rb''
* ''test_helper.rb''
* ''submitted_content_controller_test.rb''
* ''factories.rb''
* ''test_helper.rb''

The following files were created:
* ''self_review_response_map.rb''
* ''_self_review.html.erb''
* ''20160321221146_add_columnselfreviewenabled.rb''

The following test classes were created:
* ''self_review_response_maps.rb''
* ''self_review_response_map_test.rb''
* ''response_map_test.rb''

The following fixtures were modified:
* ''response_maps.yml''
* ''participants.yml''
* ''assignments.yml''
* ''questionnaires.yml''
* ''roles.yml''
* ''users.yml''
* ''assignment_questionnaires.yml''
* ''response_maps.yml''
* ''responses.yml''
* ''teams.yml''
* ''teams_users.yml''

== User Interface Walkthrough ==
Below are instructions that will guide users through the new functionality included in the update in order to test it. A video walkthrough may also be seen [https://www.youtube.com/watch?v=xaR8mD3t6RY here]

=== Instructor Perspective ===
When creating a new assignment, an instructor will have an option to enable self-reviews. In order to allow for self-reviews to be completed, the instructor must check the box while either creating or editing the assignment under the ''Review Strategy'' tab.

=== Student Perspective ===
If self-reviews are available on an assignment the following will be available for students to use.

# During the beginning stages of an assignment under "your work" the User Interface will show a label called Self-Review and a button which reads "Review my/our own work" (depending on whether it is an individual or team assignment).
# After selecting "Review my/our own work" the button will change to "Begin" (just like how a peer review works).
# Once the user selects "Begin" they will be taken to a questionnaire to complete. The questionnaire is the same one that a peer reviewer would complete.
# Similarly to a peer review, a user may either "Save" or "Submit" their self-review.
# After a user saves a self-review, "View" and "Edit" links will appear. However, once a user submits their self-review, they will be unable to edit the peer review.
# If there are multiple rounds of submissions and reviews, then in all following rounds an update link will appear to allow for students to update their self-review.
# If late submissions are allowed (via Expertiza "submission allowed" flag) then a user may begin and submit self reviews even in other review stages.
# If a self-review is not submitted throughout the duration of the assignment then "Work yet to be submitted" will be shown.
# Scores from self-reviews will not be considered when calculating grades throughout the assignment.

==Testing from UI==
To test this application from UI, follow these steps:

* First, for students to be able to do self-review, instructor must enable self-reviews for a given assignment. This can be done as follows:

# Login as Instructor
# Click 'Manage Assignments' and search for an existing assignment/create a new assignment. In 'Review Strategy' tab of assignment option, check the box associated with 'Allow self reviews?' and hit 'Save'

Now, as a student (part to this assignment) one gets a chance to perform self-review of their work.

* Performing Self Review:
# Login as Student and select the assignment you wish to self-review
# In 'Your work' tab of the assignment, at the very bottom of the page you'll find an option to 'Review your work'. On clicking this button, you'll get an option to 'Begin' self-review
# Similar to peer-reviews, you'll have questionnaire and options to 'Save' and 'Submit' your responses
# If you select to 'Save' your response, in the 'Your work' tab, you'll find 'View' and 'Edit' links which will allow you to view and edit your response respectively
# If you click 'Submit' and submit your response (Hit 'Ok' in the prompt), in the 'Your work' tab, you'll find 'View' link which will allow you to view your submitted response.

The links changes per round of submission (if there are multiple rounds)
# In submission stage, you are allowed to submit self-review and thus you can see 'Review your work button'. Upon clicking it, you'll see a 'Begin' link. On successful submission of your response, you'll have 'View' option. On successfully saving a response, you'll have 'View' and 'Edit'
# In review stage, you'll only have an option to 'View' your response
# If there are multiple rounds of submissions, then you'll have a new 'Update' option to submit a new response for new/same questionnaire (similar to peer-reviews) for all upcoming rounds of submissions.
# Finally, after the assignment is finished, you can 'View' your self-review.

== Database modification ==
In order to implement the self-review feature a modification of the database was required to add the column, ''is_selfreview_enabled'', to the ''assignments'' table. Below is the new database migration:

<pre>#E1600
class AddColumnselfreviewenabled < ActiveRecord::Migration
def self.up
add_column :assignments, :is_selfreview_enabled, :boolean
end

def self.down
remove_column :assignments, :is_selfreview_enabled, :boolean
end
end</pre>

== Design Pattern Usage ==
The self-review feature was implemented using the Model View Controller (MVC) pattern. The MVC pattern was chosen due to its current existence in the design in addition to it being a rails standard. There were no other new design patterns used in this implementation.

== Notable Code Changes ==
The largest change to the codebase to accommodate for the new self-review feature was the addition of a new type of Response Map called ''"SelfReviewResponseMap."'' The new model class is shown below:

<pre>#E1600
class SelfReviewResponseMap < ResponseMap
belongs_to :reviewee, :class_name => 'Team', :foreign_key => 'reviewee_id'
belongs_to :assignment, :class_name => 'Assignment', :foreign_key => 'reviewed_object_id'

def questionnaire(round)
if self.assignment.varying_rubrics_by_round?
Questionnaire.find(self.assignment.get_review_questionnaire_id(round))
else
Questionnaire.find(self.assignment.get_review_questionnaire_id)
end
end

def contributor
Team.find_by_id(self.reviewee_id)
end

def get_title
return "Self Review"
end
end</pre>In order to take full advantage of the new feature, instructors had to have the ability to turn it on or off as they see fit. As a result a checkbox to goggle the self-review feature was added to the assignment settings page in ''_general.html.erb''. Below is some sample code demonstrating the addition of a checkbox to the assignment settings:

<pre>
<tr>
<td style='padding:5px' id='assignment_is_selfreview_enabled'>
<input name="assignment_form[assignment][is_selfreview_enabled]" type="hidden" value="false"/>
<%= check_box_tag('assignment_form[assignment][is_selfreview_enabled]', 'true', @assignment_form.assignment.is_selfreview_enabled) %>
<%= label_tag('assignment_form[assignment][is_selfreview_enabled]', 'Allow self reviews?') %>
</td>
</tr></pre>

Changes were also made to ''review_mapping_controller.rb'' in order to accommodate the new self-review feature. The following method was added to handle the creation of new self-review for team members.

<pre>#E1600
# Start self review if not started yet
def start_self_review
assignment = Assignment.find(params[:assignment_id])
team_id = TeamsUser.find_by_sql(["SELECT t.id as t_id FROM teams_users u, teams t WHERE u.team_id = t.id and t.parent_id = ? and user_id = ?", assignment.id, params[:reviewer_userid]])

begin
#ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
if SelfReviewResponseMap.where(['reviewee_id = ? and reviewer_id = ?', team_id[0].t_id, params[:reviewer_id]]).first.nil?
SelfReviewResponseMap.create(:reviewee_id => team_id[0].t_id,
:reviewer_id => params[:reviewer_id],
:reviewed_object_id => assignment.id)
else
raise "Self review already assigned!"
end
redirect_to :controller => 'submitted_content', :action => 'edit', :id => params[:reviewer_id]
rescue
redirect_to :controller => 'submitted_content', :action => 'edit', :id => params[:reviewer_id], :msg => $!
end
end</pre>

==Testing==
Tests have been added to confirm all of the new functionality, below are some test samples that were implemented with the changes:

<pre>test "method_questionnaire" do
@questionnaire = questionnaires(:questionnaire0)
@assignment = assignments(:assignment1)
reviewrespmap = SelfReviewResponseMap.new
reviewrespmap.assignment = @assignment
reviewrespmap.questionnaire 1
assert_equal reviewrespmap.assignment.questionnaires[0].type, "ReviewQuestionnaire"
end

test "method_get_title" do
p = SelfReviewResponseMap.new
assert_equal p.get_title, "Self Review"
end

test "method_contributor" do
p = SelfReviewResponseMap.new
p.reviewee = teams(:team0)
team_id = p.contributor
assert_equal p.reviewee.id, team_id.id
end

test "reviewer_reviewee_same_team_test" do
p = SelfReviewResponseMap.new
p.reviewee = teams(:team0)
@participant = participants(:par1)
team_id = TeamsUser.find_by_sql(["SELECT t.id as t_id FROM teams_users u, teams t WHERE u.team_id = t.id and t.parent_id = ? and user_id = ?", @participant.parent_id, @participant.user_id])
assert_equal p.reviewee.id, team_id[0].t_id
end</pre>

The tests may be run via the ''rake test'' command on the project download.

== Live Demo ==
A live version of Expertiza, running with the self-review improvement, may be found at http://152.7.99.42:3000/

==References==
# [https://github.com/expertiza/expertiza Expertiza on GitHub]
# [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Documentation]
# [http://expertiza.ncsu.edu/ Expertiza Homepage]
# [https://github.com/saiteja09/expertiza Feature Fork]

CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature

2016-03-30T23:40:56Z

Magoff2: Added link to live demo and youtube video

This page will discuss the newly added peer self review feature that was added to the Expertiza project.

== Background ==
Developed by both students and faculty at [https://en.wikipedia.org/wiki/North_Carolina_State_University North Carolina State University] using [http://rubyonrails.org/ Ruby on Rails], [http://expertiza.ncsu.edu/ Expertiza] is a educational based web application that allows to students to peer review other student's work. In Expertiza, instructors are in charge of courses and within each course, they may create a series of assignments for students to contribute to, either as a member of a team or individually. Students or Teams may submit their assignments to the system through multiple means including file uploads and embedded links. Then assignments may become available to peer review by other members of the course, which provides a way to [https://en.wikipedia.org/wiki/Crowdsourcing crowd-source] grading on the work.

== Problem Statement ==
Expertiza previously contained a self-review feature where student's were able to review their own work after submitting their assignments but it was removed due to the inconsistency with the other types of reviews. The task was to re-implement the feature in a way that ensured the overall design would remain intact. The self-review feature should allow students to review their own submission using the same rubric that was provided to other peer reviewers of the assignment. By reviewing their own work, students will be able to assess the artifact through the rubric and may be inspired to make improvements between rounds of peer-reviews.

=== What Needs Done: ===
The following tasks were given to be completed by the team:
* The self-review feature should use the same questionnaire_id as a peer-review. That way developers may call "''assignment.get_review_questionnaire_id(round)''" to get a questionnaire for the self-review.
* A method called "''self_review_response_map?''" should be added to ''review_response_map.rb''. The method will return true if the response_map is a self_response map. In order to determine the result the method shall compare the ''reviewer_id'' and ''reviewee_id'' in the response_map record and if the participant is a member of the reviewee team, true will be returned.
* Student shall do a self-review in the "your work" section. There should be a button called "Review my own work" (or "our own work" if it is a team assignment). When the button is clicked a new review_response_map record is created. Within the map, the reviewer_id is the participant id and the reviewee_id is the team_id.
* If the response_map record for self-review exists, a hyperlink with the text "begin" should appear. A student may click the link and fill in the questionnaire just like how they would for a regular peer review.
* If the self-review response_map exists and there has already been a response, two links entitled "view" and "edit" will appear that will function similarly to peer reviews.
* If the self-review was completed in the last round and the current round uses a different questionnaire (using the ''vary_rubric_by_round'' feature), a link called "update" will appear, which brings students to a new page to fill in the new rubric for the new round.
* In ''grades_controller.view_my_scores,'' self-review responses shall be excluded.
* In ''grades_controller.view_team,'' self-review responses shall be excluded.
* In ''grades_controller.view,'' self-review responses shall be excluded.
* The method called "''add_self_reviewer"'' in ''ReviewMappingController'', shall allow instructors to create self-review response maps. This method needs to be made functional again.
* Automated tests must be created.

== Files Modified in Project ==
The following files were modified in creating the new self-review feature
* ''review_response_map.rb''
* ''review_mapping_controller.rb''
* ''response_controller.rb''
* ''_set_dynamic_review.html.erb''
* ''_main.html.erb''
* ''_review_strategy.html.erb''
* ''response.html.erb''
* ''routes.rb''
* ''test_helper.rb''
* ''submitted_content_controller_test.rb''
* ''factories.rb''
* ''test_helper.rb''

The following files were created:
* ''self_review_response_map.rb''
* ''_self_review.html.erb''
* ''20160321221146_add_columnselfreviewenabled.rb''

The following test classes were created:
* ''self_review_response_maps.rb''
* ''self_review_response_map_test.rb''
* ''response_map_test.rb''

The following fixtures were modified:
* ''response_maps.yml''
* ''participants.yml''
* ''assignments.yml''
* ''questionnaires.yml''
* ''roles.yml''
* ''users.yml''
* ''assignment_questionnaires.yml''
* ''response_maps.yml''
* ''responses.yml''
* ''teams.yml''
* ''teams_users.yml''

== User Interface Walkthrough ==
Below are instructions that will guide users through the new functionality included in the update in order to test it. A video walkthrough may also be seen [https://www.youtube.com/watch?v=xaR8mD3t6RY here]

=== Instructor Perspective ===
When creating a new assignment, an instructor will have an option to enable self-reviews. In order to allow for self-reviews to be completed, the instructor must check the box while either creating or editing the assignment under the ''Review Strategy'' tab.

=== Student Perspective ===
If self-reviews are available on an assignment the following will be available for students to use.

# During the beginning stages of an assignment under "your work" the User Interface will show a label called Self-Review and a button which reads "Review my/our own work" (depending on whether it is an individual or team assignment).
# After selecting "Review my/our own work" the button will change to "Begin" (just like how a peer review works).
# Once the user selects "Begin" they will be taken to a questionnaire to complete. The questionnaire is the same one that a peer reviewer would complete.
# Similarly to a peer review, a user may either "Save" or "Submit" their self-review.
# After a user saves a self-review, "View" and "Edit" links will appear. However, once a user submits their self-review, they will be unable to edit the peer review.
# If there are multiple rounds of submissions and reviews, then in all following rounds an update link will appear to allow for students to update their self-review.
# If late submissions are allowed (via Expertiza "submission allowed" flag) then a user may begin and submit self reviews even in other review stages.
# If a self-review is not submitted throughout the duration of the assignment then "Work yet to be submitted" will be shown.
# Scores from self-reviews will not be considered when calculating grades throughout the assignment.

==Testing from UI==
To test this application from UI, follow these steps:

* First, for students to be able to do self-review, instructor must enable self-reviews for a given assignment. This can be done as follows:

# Login as Instructor
# Click 'Manage Assignments' and search for an existing assignment/create a new assignment. In 'Review Strategy' tab of assignment option, check the box associated with 'Allow self reviews?' and hit 'Save'

Now, as a student (part to this assignment) one gets a chance to perform self-review of their work.

* Performing Self Review:
# Login as Student and select the assignment you wish to self-review
# In 'Your work' tab of the assignment, at the very bottom of the page you'll find an option to 'Review your work'. On clicking this button, you'll get an option to 'Begin' self-review
# Similar to peer-reviews, you'll have questionnaire and options to 'Save' and 'Submit' your responses
# If you select to 'Save' your response, in the 'Your work' tab, you'll find 'View' and 'Edit' links which will allow you to view and edit your response respectively
# If you click 'Submit' and submit your response (Hit 'Ok' in the prompt), in the 'Your work' tab, you'll find 'View' link which will allow you to view your submitted response.

The links changes per round of submission (if there are multiple rounds)
# In submission stage, you are allowed to submit self-review and thus you can see 'Review your work button'. Upon clicking it, you'll see a 'Begin' link. On successful submission of your response, you'll have 'View' option. On successfully saving a response, you'll have 'View' and 'Edit'
# In review stage, you'll only have an option to 'View' your response
# If there are multiple rounds of submissions, then you'll have a new 'Update' option to submit a new response for new/same questionnaire (similar to peer-reviews) for all upcoming rounds of submissions.
# Finally, after the assignment is finished, you can 'View' your self-review.

== Database modification ==
In order to implement the self-review feature a modification of the database was required to add the column, ''is_selfreview_enabled'', to the ''assignments'' table. Below is the new database migration:

<pre>#E1600
class AddColumnselfreviewenabled < ActiveRecord::Migration
def self.up
add_column :assignments, :is_selfreview_enabled, :boolean
end

def self.down
remove_column :assignments, :is_selfreview_enabled, :boolean
end
end</pre>

== Design Pattern Usage ==
The self-review feature was implemented using the Model View Controller (MVC) pattern. The MVC pattern was chosen due to its current existence in the design in addition to it being a rails standard. There were no other new design patterns used in this implementation.

== Notable Code Changes ==
The largest change to the codebase to accommodate for the new self-review feature was the addition of a new type of Response Map called ''"SelfReviewResponseMap."'' The new model class is shown below:

<pre>#E1600
class SelfReviewResponseMap < ResponseMap
belongs_to :reviewee, :class_name => 'Team', :foreign_key => 'reviewee_id'
belongs_to :assignment, :class_name => 'Assignment', :foreign_key => 'reviewed_object_id'

def questionnaire(round)
if self.assignment.varying_rubrics_by_round?
Questionnaire.find(self.assignment.get_review_questionnaire_id(round))
else
Questionnaire.find(self.assignment.get_review_questionnaire_id)
end
end

def contributor
Team.find_by_id(self.reviewee_id)
end

def get_title
return "Self Review"
end
end</pre>In order to take full advantage of the new feature, instructors had to have the ability to turn it on or off as they see fit. As a result a checkbox to goggle the self-review feature was added to the assignment settings page in ''_general.html.erb''. Below is some sample code demonstrating the addition of a checkbox to the assignment settings:

<pre>
<tr>
<td style='padding:5px' id='assignment_is_selfreview_enabled'>
<input name="assignment_form[assignment][is_selfreview_enabled]" type="hidden" value="false"/>
<%= check_box_tag('assignment_form[assignment][is_selfreview_enabled]', 'true', @assignment_form.assignment.is_selfreview_enabled) %>
<%= label_tag('assignment_form[assignment][is_selfreview_enabled]', 'Allow self reviews?') %>
</td>
</tr></pre>

Changes were also made to ''review_mapping_controller.rb'' in order to accommodate the new self-review feature. The following method was added to handle the creation of new self-review for team members.

<pre>#E1600
# Start self review if not started yet
def start_self_review
assignment = Assignment.find(params[:assignment_id])
team_id = TeamsUser.find_by_sql(["SELECT t.id as t_id FROM teams_users u, teams t WHERE u.team_id = t.id and t.parent_id = ? and user_id = ?", assignment.id, params[:reviewer_userid]])

begin
#ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
if SelfReviewResponseMap.where(['reviewee_id = ? and reviewer_id = ?', team_id[0].t_id, params[:reviewer_id]]).first.nil?
SelfReviewResponseMap.create(:reviewee_id => team_id[0].t_id,
:reviewer_id => params[:reviewer_id],
:reviewed_object_id => assignment.id)
else
raise "Self review already assigned!"
end
redirect_to :controller => 'submitted_content', :action => 'edit', :id => params[:reviewer_id]
rescue
redirect_to :controller => 'submitted_content', :action => 'edit', :id => params[:reviewer_id], :msg => $!
end
end</pre>

==Testing==
Tests have been added to confirm all of the new functionality, below are some test samples that were implemented with the changes:

<pre>test "method_questionnaire" do
@questionnaire = questionnaires(:questionnaire0)
@assignment = assignments(:assignment1)
reviewrespmap = SelfReviewResponseMap.new
reviewrespmap.assignment = @assignment
reviewrespmap.questionnaire 1
assert_equal reviewrespmap.assignment.questionnaires[0].type, "ReviewQuestionnaire"
end

test "method_get_title" do
p = SelfReviewResponseMap.new
assert_equal p.get_title, "Self Review"
end

test "method_contributor" do
p = SelfReviewResponseMap.new
p.reviewee = teams(:team0)
team_id = p.contributor
assert_equal p.reviewee.id, team_id.id
end

test "reviewer_reviewee_same_team_test" do
p = SelfReviewResponseMap.new
p.reviewee = teams(:team0)
@participant = participants(:par1)
team_id = TeamsUser.find_by_sql(["SELECT t.id as t_id FROM teams_users u, teams t WHERE u.team_id = t.id and t.parent_id = ? and user_id = ?", @participant.parent_id, @participant.user_id])
assert_equal p.reviewee.id, team_id[0].t_id
end</pre>

== Live Demo ==
A live version of Expertiza, running with the self-review improvement, may be found at http://152.7.99.42:3000/

==References==
# [https://github.com/expertiza/expertiza Expertiza on GitHub]
# [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Documentation]
# [http://expertiza.ncsu.edu/ Expertiza Homepage]
# [https://github.com/saiteja09/expertiza Feature Fork]

CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature

2016-03-30T23:37:19Z

Magoff2: Added more edits to conform with peer reviews

This page will discuss the newly added peer self review feature that was added to the Expertiza project.

== Background ==
Developed by both students and faculty at [https://en.wikipedia.org/wiki/North_Carolina_State_University North Carolina State University] using [http://rubyonrails.org/ Ruby on Rails], [http://expertiza.ncsu.edu/ Expertiza] is a educational based web application that allows to students to peer review other student's work. In Expertiza, instructors are in charge of courses and within each course, they may create a series of assignments for students to contribute to, either as a member of a team or individually. Students or Teams may submit their assignments to the system through multiple means including file uploads and embedded links. Then assignments may become available to peer review by other members of the course, which provides a way to [https://en.wikipedia.org/wiki/Crowdsourcing crowd-source] grading on the work.

== Problem Statement ==
Expertiza previously contained a self-review feature where student's were able to review their own work after submitting their assignments but it was removed due to the inconsistency with the other types of reviews. The task was to re-implement the feature in a way that ensured the overall design would remain intact. The self-review feature should allow students to review their own submission using the same rubric that was provided to other peer reviewers of the assignment. By reviewing their own work, students will be able to assess the artifact through the rubric and may be inspired to make improvements between rounds of peer-reviews.

=== What Needs Done: ===
The following tasks were given to be completed by the team:
* The self-review feature should use the same questionnaire_id as a peer-review. That way developers may call "''assignment.get_review_questionnaire_id(round)''" to get a questionnaire for the self-review.
* A method called "''self_review_response_map?''" should be added to ''review_response_map.rb''. The method will return true if the response_map is a self_response map. In order to determine the result the method shall compare the ''reviewer_id'' and ''reviewee_id'' in the response_map record and if the participant is a member of the reviewee team, true will be returned.
* Student shall do a self-review in the "your work" section. There should be a button called "Review my own work" (or "our own work" if it is a team assignment). When the button is clicked a new review_response_map record is created. Within the map, the reviewer_id is the participant id and the reviewee_id is the team_id.
* If the response_map record for self-review exists, a hyperlink with the text "begin" should appear. A student may click the link and fill in the questionnaire just like how they would for a regular peer review.
* If the self-review response_map exists and there has already been a response, two links entitled "view" and "edit" will appear that will function similarly to peer reviews.
* If the self-review was completed in the last round and the current round uses a different questionnaire (using the ''vary_rubric_by_round'' feature), a link called "update" will appear, which brings students to a new page to fill in the new rubric for the new round.
* In ''grades_controller.view_my_scores,'' self-review responses shall be excluded.
* In ''grades_controller.view_team,'' self-review responses shall be excluded.
* In ''grades_controller.view,'' self-review responses shall be excluded.
* The method called "''add_self_reviewer"'' in ''ReviewMappingController'', shall allow instructors to create self-review response maps. This method needs to be made functional again.
* Automated tests must be created.

== Files Modified in Project ==
The following files were modified in creating the new self-review feature
* ''review_response_map.rb''
* ''review_mapping_controller.rb''
* ''response_controller.rb''
* ''_set_dynamic_review.html.erb''
* ''_main.html.erb''
* ''_review_strategy.html.erb''
* ''response.html.erb''
* ''routes.rb''
* ''test_helper.rb''
* ''submitted_content_controller_test.rb''
* ''factories.rb''
* ''test_helper.rb''

The following files were created:
* ''self_review_response_map.rb''
* ''_self_review.html.erb''
* ''20160321221146_add_columnselfreviewenabled.rb''

The following test classes were created:
* ''self_review_response_maps.rb''
* ''self_review_response_map_test.rb''
* ''response_map_test.rb''

The following fixtures were modified:
* ''response_maps.yml''
* ''participants.yml''
* ''assignments.yml''
* ''questionnaires.yml''
* ''roles.yml''
* ''users.yml''
* ''assignment_questionnaires.yml''
* ''response_maps.yml''
* ''responses.yml''
* ''teams.yml''
* ''teams_users.yml''

== User Interface Walkthrough ==
Below are instructions that will guide users through the new functionality included in the update in order to test it.

=== Instructor Perspective ===
When creating a new assignment, an instructor will have an option to enable self-reviews. In order to allow for self-reviews to be completed, the instructor must check the box while either creating or editing the assignment under the ''Review Strategy'' tab.

=== Student Perspective ===
If self-reviews are available on an assignment the following will be available for students to use.

# During the beginning stages of an assignment under "your work" the User Interface will show a label called Self-Review and a button which reads "Review my/our own work" (depending on whether it is an individual or team assignment).
# After selecting "Review my/our own work" the button will change to "Begin" (just like how a peer review works).
# Once the user selects "Begin" they will be taken to a questionnaire to complete. The questionnaire is the same one that a peer reviewer would complete.
# Similarly to a peer review, a user may either "Save" or "Submit" their self-review.
# After a user saves a self-review, "View" and "Edit" links will appear. However, once a user submits their self-review, they will be unable to edit the peer review.
# If there are multiple rounds of submissions and reviews, then in all following rounds an update link will appear to allow for students to update their self-review.
# If late submissions are allowed (via Expertiza "submission allowed" flag) then a user may begin and submit self reviews even in other review stages.
# If a self-review is not submitted throughout the duration of the assignment then "Work yet to be submitted" will be shown.
# Scores from self-reviews will not be considered when calculating grades throughout the assignment.

==Testing from UI==
To test this application from UI, follow these steps:

* First, for students to be able to do self-review, instructor must enable self-reviews for a given assignment. This can be done as follows:

# Login as Instructor
# Click 'Manage Assignments' and search for an existing assignment/create a new assignment. In 'Review Strategy' tab of assignment option, check the box associated with 'Allow self reviews?' and hit 'Save'

Now, as a student (part to this assignment) one gets a chance to perform self-review of their work.

* Performing Self Review:
# Login as Student and select the assignment you wish to self-review
# In 'Your work' tab of the assignment, at the very bottom of the page you'll find an option to 'Review your work'. On clicking this button, you'll get an option to 'Begin' self-review
# Similar to peer-reviews, you'll have questionnaire and options to 'Save' and 'Submit' your responses
# If you select to 'Save' your response, in the 'Your work' tab, you'll find 'View' and 'Edit' links which will allow you to view and edit your response respectively
# If you click 'Submit' and submit your response (Hit 'Ok' in the prompt), in the 'Your work' tab, you'll find 'View' link which will allow you to view your submitted response.

The links changes per round of submission (if there are multiple rounds)
# In submission stage, you are allowed to submit self-review and thus you can see 'Review your work button'. Upon clicking it, you'll see a 'Begin' link. On successful submission of your response, you'll have 'View' option. On successfully saving a response, you'll have 'View' and 'Edit'
# In review stage, you'll only have an option to 'View' your response
# If there are multiple rounds of submissions, then you'll have a new 'Update' option to submit a new response for new/same questionnaire (similar to peer-reviews) for all upcoming rounds of submissions.
# Finally, after the assignment is finished, you can 'View' your self-review.

== Database modification ==
In order to implement the self-review feature a modification of the database was required to add the column, ''is_selfreview_enabled'', to the ''assignments'' table. Below is the new database migration:

<pre>#E1600
class AddColumnselfreviewenabled < ActiveRecord::Migration
def self.up
add_column :assignments, :is_selfreview_enabled, :boolean
end

def self.down
remove_column :assignments, :is_selfreview_enabled, :boolean
end
end</pre>

== Design Pattern Usage ==
The self-review feature was implemented using the Model View Controller (MVC) pattern. The MVC pattern was chosen due to its current existence in the design in addition to it being a rails standard. There were no other new design patterns used in this implementation.

== Notable Code Changes ==
The largest change to the codebase to accommodate for the new self-review feature was the addition of a new type of Response Map called ''"SelfReviewResponseMap."'' The new model class is shown below:

<pre>#E1600
class SelfReviewResponseMap < ResponseMap
belongs_to :reviewee, :class_name => 'Team', :foreign_key => 'reviewee_id'
belongs_to :assignment, :class_name => 'Assignment', :foreign_key => 'reviewed_object_id'

def questionnaire(round)
if self.assignment.varying_rubrics_by_round?
Questionnaire.find(self.assignment.get_review_questionnaire_id(round))
else
Questionnaire.find(self.assignment.get_review_questionnaire_id)
end
end

def contributor
Team.find_by_id(self.reviewee_id)
end

def get_title
return "Self Review"
end
end</pre>In order to take full advantage of the new feature, instructors had to have the ability to turn it on or off as they see fit. As a result a checkbox to goggle the self-review feature was added to the assignment settings page in ''_general.html.erb''. Below is some sample code demonstrating the addition of a checkbox to the assignment settings:

<pre>
<tr>
<td style='padding:5px' id='assignment_is_selfreview_enabled'>
<input name="assignment_form[assignment][is_selfreview_enabled]" type="hidden" value="false"/>
<%= check_box_tag('assignment_form[assignment][is_selfreview_enabled]', 'true', @assignment_form.assignment.is_selfreview_enabled) %>
<%= label_tag('assignment_form[assignment][is_selfreview_enabled]', 'Allow self reviews?') %>
</td>
</tr></pre>

Changes were also made to ''review_mapping_controller.rb'' in order to accommodate the new self-review feature. The following method was added to handle the creation of new self-review for team members.

<pre>#E1600
# Start self review if not started yet
def start_self_review
assignment = Assignment.find(params[:assignment_id])
team_id = TeamsUser.find_by_sql(["SELECT t.id as t_id FROM teams_users u, teams t WHERE u.team_id = t.id and t.parent_id = ? and user_id = ?", assignment.id, params[:reviewer_userid]])

begin
#ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
if SelfReviewResponseMap.where(['reviewee_id = ? and reviewer_id = ?', team_id[0].t_id, params[:reviewer_id]]).first.nil?
SelfReviewResponseMap.create(:reviewee_id => team_id[0].t_id,
:reviewer_id => params[:reviewer_id],
:reviewed_object_id => assignment.id)
else
raise "Self review already assigned!"
end
redirect_to :controller => 'submitted_content', :action => 'edit', :id => params[:reviewer_id]
rescue
redirect_to :controller => 'submitted_content', :action => 'edit', :id => params[:reviewer_id], :msg => $!
end
end</pre>

==Testing==
Tests have been added to confirm all of the new functionality, below are some test samples that were implemented with the changes:

<pre>test "method_questionnaire" do
@questionnaire = questionnaires(:questionnaire0)
@assignment = assignments(:assignment1)
reviewrespmap = SelfReviewResponseMap.new
reviewrespmap.assignment = @assignment
reviewrespmap.questionnaire 1
assert_equal reviewrespmap.assignment.questionnaires[0].type, "ReviewQuestionnaire"
end

test "method_get_title" do
p = SelfReviewResponseMap.new
assert_equal p.get_title, "Self Review"
end

test "method_contributor" do
p = SelfReviewResponseMap.new
p.reviewee = teams(:team0)
team_id = p.contributor
assert_equal p.reviewee.id, team_id.id
end

test "reviewer_reviewee_same_team_test" do
p = SelfReviewResponseMap.new
p.reviewee = teams(:team0)
@participant = participants(:par1)
team_id = TeamsUser.find_by_sql(["SELECT t.id as t_id FROM teams_users u, teams t WHERE u.team_id = t.id and t.parent_id = ? and user_id = ?", @participant.parent_id, @participant.user_id])
assert_equal p.reviewee.id, team_id[0].t_id
end</pre>

==References==
# [https://github.com/expertiza/expertiza Expertiza on GitHub]
# [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Documentation]
# [http://expertiza.ncsu.edu/ Expertiza Homepage]
# [https://github.com/saiteja09/expertiza Feature Fork]

CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature

2016-03-30T20:31:43Z

Magoff2: /* Walkthrough */

This page will discuss the newly added peer self review feature that was added to the Expertiza project.

== Background ==
Developed by both students and faculty at [https://en.wikipedia.org/wiki/North_Carolina_State_University North Carolina State University] using [http://rubyonrails.org/ Ruby on Rails], [http://expertiza.ncsu.edu/ Expertiza] is a educational based web application that allows to students to peer review other student's work. In Expertiza, instructors are in charge of courses and within each course, they may create a series of assignments for students to contribute to, either as a member of a team or individually. Students or Teams may submit their assignments to the system through multiple means including file uploads and embedded links. Then assignments may become available to peer review by other members of the course, which provides a way to [https://en.wikipedia.org/wiki/Crowdsourcing crowd-source] grading on the work.

== Problem Statement ==
Expertiza previously contained a self-review feature where student's were able to review their own work after submitting their assignments but it was removed due to the inconsistency with the other types of reviews. The task was to re-implement the feature in a way that ensured the overall design would remain intact. The self-review feature should allow students to review their own submission using the same rubric that was provided to other peer reviewers of the assignment. By reviewing their own work, students will be able to assess the artifact through the rubric and may be inspired to make improvements between rounds of peer-reviews.

=== What Needs Done: ===
The following tasks were given to be completed by the team:
* The self-review feature should use the same questionnaire_id as a peer-review. That way developers may call "''assignment.get_review_questionnaire_id(round)''" to get a questionnaire for the self-review.
* A method called "''self_review_response_map?''" should be added to ''review_response_map.rb''. The method will return true if the response_map is a self_response map. In order to determine the result the method shall compare the ''reviewer_id'' and ''reviewee_id'' in the response_map record and if the participant is a member of the reviewee team, true will be returned.
* Student shall do a self-review in the "your work" section. There should be a button called "Review my own work" (or "our own work" if it is a team assignment). When the button is clicked a new review_response_map record is created. Within the map, the reviewer_id is the participant id and the reviewee_id is the team_id.
* If the response_map record for self-review exists, a hyperlink with the text "begin" should appear. A student may click the link and fill in the questionnaire just like how they would for a regular peer review.
* If the self-review response_map exists and there has already been a response, two links entitled "view" and "edit" will appear that will function similarly to peer reviews.
* If the self-review was completed in the last round and the current round uses a different questionnaire (using the ''vary_rubric_by_round'' feature), a link called "update" will appear, which brings students to a new page to fill in the new rubric for the new round.
* In ''grades_controller.view_my_scores,'' self-review responses shall be excluded.
* In ''grades_controller.view_team,'' self-review responses shall be excluded.
* In ''grades_controller.view,'' self-review responses shall be excluded.
* The method called "''add_self_reviewer"'' in ''ReviewMappingController'', shall allow instructors to create self-review response maps. This method needs to be made functional again.
* Automated tests must be created.

== Files Modified in Project ==
The following files were modified in creating the new self-review feature
* ''review_response_map.rb''
* ''review_mapping_controller.rb''
* ''response_controller.rb''
* ''_set_dynamic_review.html.erb''
* ''_main.html.erb''
* ''_review_strategy.html.erb''
* ''response.html.erb''
* ''routes.rb''
* ''test_helper.rb''
* ''submitted_content_controller_test.rb''
* ''factories.rb''
* ''test_helper.rb''

The following files were created:
* ''self_review_response_map.rb''
* ''_self_review.html.erb''
* ''20160321221146_add_columnselfreviewenabled.rb''

The following test classes were created:
* ''self_review_response_maps.rb''
* ''self_review_response_map_test.rb''
* ''response_map_test.rb''

The following fixtures were modified:
* ''response_maps.yml''
* ''participants.yml''
* ''assignments.yml''
* ''questionnaires.yml''
* ''roles.yml''
* ''users.yml''
* ''assignment_questionnaires.yml''
* ''response_maps.yml''
* ''responses.yml''
* ''teams.yml''
* ''teams_users.yml''

== User Interface Walkthrough ==
Below are instructions that will guide users through the new functionality included in the update in order to test it.

=== Instructor Perspective ===
When creating a new assignment, an instructor will have an option to enable self-reviews. In order to allow for self-reviews to be completed, the instructor must check the box while either creating or editing the assignment under the ''Review Strategy'' tab.

=== Student Perspective ===
If self-reviews are available on an assignment the following will be available for students to use.

# During the beginning stages of an assignment under "your work" the User Interface will show a label called Self-Review and a button which reads "Review my/our own work" (depending on whether it is an individual or team assignment).
# After selecting "Review my/our own work" the button will change to "Begin" (just like how a peer review works).
# Once the user selects "Begin" they will be taken to a questionnaire to complete. The questionnaire is the same one that a peer reviewer would complete.
# Similarly to a peer review, a user may either "Save" or "Submit" their self-review.
# After a user saves a self-review, "View" and "Edit" links will appear. However, once a user submits their self-review, they will be unable to edit the peer review.
# If there are multiple rounds of submissions and reviews, then in all following rounds an update link will appear to allow for students to update their self-review.
# If late submissions are allowed (via Expertiza "submission allowed" flag) then a user may begin and submit self reviews even in other review stages.
# If a self-review is not submitted throughout the duration of the assignment then "Work yet to be submitted" will be shown.
# Scores from self-reviews will not be considered when calculating grades throughout the assignment.

== Database modification ==
In order to implement the self-review feature a modification of the database was required to add the column, ''is_selfreview_enabled'', to the ''assignments'' table. Below is the new database migration:

<pre>#E1600
class AddColumnselfreviewenabled < ActiveRecord::Migration
def self.up
add_column :assignments, :is_selfreview_enabled, :boolean
end

def self.down
remove_column :assignments, :is_selfreview_enabled, :boolean
end
end</pre>

== Notable Code Changes ==
The largest change to the codebase to accommodate for the new self-review feature was the addition of a new type of Response Map called ''"SelfReviewResponseMap."'' The new model class is shown below:

<pre>#E1600
class SelfReviewResponseMap < ResponseMap
belongs_to :reviewee, :class_name => 'Team', :foreign_key => 'reviewee_id'
belongs_to :assignment, :class_name => 'Assignment', :foreign_key => 'reviewed_object_id'

def questionnaire(round)
if self.assignment.varying_rubrics_by_round?
Questionnaire.find(self.assignment.get_review_questionnaire_id(round))
else
Questionnaire.find(self.assignment.get_review_questionnaire_id)
end
end

def contributor
Team.find_by_id(self.reviewee_id)
end

def get_title
return "Self Review"
end
end</pre>In order to take full advantage of the new feature, instructors had to have the ability to turn it on or off as they see fit. As a result a checkbox to goggle the self-review feature was added to the assignment settings page in ''_general.html.erb''. Below is some sample code demonstrating the addition of a checkbox to the assignment settings:

<pre>
<tr>
<td style='padding:5px' id='assignment_is_selfreview_enabled'>
<input name="assignment_form[assignment][is_selfreview_enabled]" type="hidden" value="false"/>
<%= check_box_tag('assignment_form[assignment][is_selfreview_enabled]', 'true', @assignment_form.assignment.is_selfreview_enabled) %>
<%= label_tag('assignment_form[assignment][is_selfreview_enabled]', 'Allow self reviews?') %>
</td>
</tr></pre>

Changes were also made to ''review_mapping_controller.rb'' in order to accommodate the new self-review feature. The following method was added to handle the creation of new self-review for team members.

<pre>#E1600
# Start self review if not started yet
def start_self_review
assignment = Assignment.find(params[:assignment_id])
team_id = TeamsUser.find_by_sql(["SELECT t.id as t_id FROM teams_users u, teams t WHERE u.team_id = t.id and t.parent_id = ? and user_id = ?", assignment.id, params[:reviewer_userid]])

begin
#ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
if SelfReviewResponseMap.where(['reviewee_id = ? and reviewer_id = ?', team_id[0].t_id, params[:reviewer_id]]).first.nil?
SelfReviewResponseMap.create(:reviewee_id => team_id[0].t_id,
:reviewer_id => params[:reviewer_id],
:reviewed_object_id => assignment.id)
else
raise "Self review already assigned!"
end
redirect_to :controller => 'submitted_content', :action => 'edit', :id => params[:reviewer_id]
rescue
redirect_to :controller => 'submitted_content', :action => 'edit', :id => params[:reviewer_id], :msg => $!
end
end</pre>

==Testing==
Tests have been added to confirm all of the new functionality, below are some test samples that were implemented with the changes:

<pre>test "method_questionnaire" do
@questionnaire = questionnaires(:questionnaire0)
@assignment = assignments(:assignment1)
reviewrespmap = SelfReviewResponseMap.new
reviewrespmap.assignment = @assignment
reviewrespmap.questionnaire 1
assert_equal reviewrespmap.assignment.questionnaires[0].type, "ReviewQuestionnaire"
end

test "method_get_title" do
p = SelfReviewResponseMap.new
assert_equal p.get_title, "Self Review"
end

test "method_contributor" do
p = SelfReviewResponseMap.new
p.reviewee = teams(:team0)
team_id = p.contributor
assert_equal p.reviewee.id, team_id.id
end

test "reviewer_reviewee_same_team_test" do
p = SelfReviewResponseMap.new
p.reviewee = teams(:team0)
@participant = participants(:par1)
team_id = TeamsUser.find_by_sql(["SELECT t.id as t_id FROM teams_users u, teams t WHERE u.team_id = t.id and t.parent_id = ? and user_id = ?", @participant.parent_id, @participant.user_id])
assert_equal p.reviewee.id, team_id[0].t_id
end</pre>

==References==
# [https://github.com/expertiza/expertiza Expertiza on GitHub]
# [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Documentation]
# [http://expertiza.ncsu.edu/ Expertiza Homepage]
# [https://github.com/saiteja09/expertiza Feature Fork]

CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature

2016-03-30T20:27:19Z

Magoff2: /* Instructor Perspective */

This page will discuss the newly added peer self review feature that was added to the Expertiza project.

== Background ==
Developed by both students and faculty at [https://en.wikipedia.org/wiki/North_Carolina_State_University North Carolina State University] using [http://rubyonrails.org/ Ruby on Rails], [http://expertiza.ncsu.edu/ Expertiza] is a educational based web application that allows to students to peer review other student's work. In Expertiza, instructors are in charge of courses and within each course, they may create a series of assignments for students to contribute to, either as a member of a team or individually. Students or Teams may submit their assignments to the system through multiple means including file uploads and embedded links. Then assignments may become available to peer review by other members of the course, which provides a way to [https://en.wikipedia.org/wiki/Crowdsourcing crowd-source] grading on the work.

== Problem Statement ==
Expertiza previously contained a self-review feature where student's were able to review their own work after submitting their assignments but it was removed due to the inconsistency with the other types of reviews. The task was to re-implement the feature in a way that ensured the overall design would remain intact. The self-review feature should allow students to review their own submission using the same rubric that was provided to other peer reviewers of the assignment. By reviewing their own work, students will be able to assess the artifact through the rubric and may be inspired to make improvements between rounds of peer-reviews.

=== What Needs Done: ===
The following tasks were given to be completed by the team:
* The self-review feature should use the same questionnaire_id as a peer-review. That way developers may call "''assignment.get_review_questionnaire_id(round)''" to get a questionnaire for the self-review.
* A method called "''self_review_response_map?''" should be added to ''review_response_map.rb''. The method will return true if the response_map is a self_response map. In order to determine the result the method shall compare the ''reviewer_id'' and ''reviewee_id'' in the response_map record and if the participant is a member of the reviewee team, true will be returned.
* Student shall do a self-review in the "your work" section. There should be a button called "Review my own work" (or "our own work" if it is a team assignment). When the button is clicked a new review_response_map record is created. Within the map, the reviewer_id is the participant id and the reviewee_id is the team_id.
* If the response_map record for self-review exists, a hyperlink with the text "begin" should appear. A student may click the link and fill in the questionnaire just like how they would for a regular peer review.
* If the self-review response_map exists and there has already been a response, two links entitled "view" and "edit" will appear that will function similarly to peer reviews.
* If the self-review was completed in the last round and the current round uses a different questionnaire (using the ''vary_rubric_by_round'' feature), a link called "update" will appear, which brings students to a new page to fill in the new rubric for the new round.
* In ''grades_controller.view_my_scores,'' self-review responses shall be excluded.
* In ''grades_controller.view_team,'' self-review responses shall be excluded.
* In ''grades_controller.view,'' self-review responses shall be excluded.
* The method called "''add_self_reviewer"'' in ''ReviewMappingController'', shall allow instructors to create self-review response maps. This method needs to be made functional again.
* Automated tests must be created.

== Files Modified in Project ==
The following files were modified in creating the new self-review feature
* ''review_response_map.rb''
* ''review_mapping_controller.rb''
* ''response_controller.rb''
* ''_set_dynamic_review.html.erb''
* ''_main.html.erb''
* ''_review_strategy.html.erb''
* ''response.html.erb''
* ''routes.rb''
* ''test_helper.rb''
* ''submitted_content_controller_test.rb''
* ''factories.rb''
* ''test_helper.rb''

The following files were created:
* ''self_review_response_map.rb''
* ''_self_review.html.erb''
* ''20160321221146_add_columnselfreviewenabled.rb''

The following test classes were created:
* ''self_review_response_maps.rb''
* ''self_review_response_map_test.rb''
* ''response_map_test.rb''

The following fixtures were modified:
* ''response_maps.yml''
* ''participants.yml''
* ''assignments.yml''
* ''questionnaires.yml''
* ''roles.yml''
* ''users.yml''
* ''assignment_questionnaires.yml''
* ''response_maps.yml''
* ''responses.yml''
* ''teams.yml''
* ''teams_users.yml''

== Walkthrough ==
Below are walkthroughs that will guide users through the new functionality included in the update.

=== Instructor Perspective ===
When creating a new assignment, an instructor will have an option to enable self-reviews. In order to allow for self-reviews to be completed, the instructor must check the box while either creating or editing the assignment under the ''Review Strategy'' tab.

=== Student Perspective ===
If self-reviews are available on an assignment the following will be available for students to use.

# During the beginning stages of an assignment under "your work" the User Interface will show a label called Self-Review and a button which reads "Review my/our own work" (depending on whether it is an individual or team assignment).
# After selecting "Review my/our own work" the button will change to "Begin" (just like how a peer review works).
# Once the user selects "Begin" they will be taken to a questionnaire to complete. The questionnaire is the same one that a peer reviewer would complete.
# Similarly to a peer review, a user may either "Save" or "Submit" their self-review.
# After a user saves a self-review, "View" and "Edit" links will appear. However, once a user submits their self-review, they will be unable to edit the peer review.
# If there are multiple rounds of submissions and reviews, then in all following rounds an update link will appear to allow for students to update their self-review.
# If late submissions are allowed (via Expertiza "submission allowed" flag) then a user may begin and submit self reviews even in other review stages.
# If a self-review is not submitted throughout the duration of the assignment then "Work yet to be submitted" will be shown.
# Scores from self-reviews will not be considered when calculating grades throughout the assignment.

== Database modification ==
In order to implement the self-review feature a modification of the database was required to add the column, ''is_selfreview_enabled'', to the ''assignments'' table. Below is the new database migration:

<pre>#E1600
class AddColumnselfreviewenabled < ActiveRecord::Migration
def self.up
add_column :assignments, :is_selfreview_enabled, :boolean
end

def self.down
remove_column :assignments, :is_selfreview_enabled, :boolean
end
end</pre>

== Notable Code Changes ==
The largest change to the codebase to accommodate for the new self-review feature was the addition of a new type of Response Map called ''"SelfReviewResponseMap."'' The new model class is shown below:

<pre>#E1600
class SelfReviewResponseMap < ResponseMap
belongs_to :reviewee, :class_name => 'Team', :foreign_key => 'reviewee_id'
belongs_to :assignment, :class_name => 'Assignment', :foreign_key => 'reviewed_object_id'

def questionnaire(round)
if self.assignment.varying_rubrics_by_round?
Questionnaire.find(self.assignment.get_review_questionnaire_id(round))
else
Questionnaire.find(self.assignment.get_review_questionnaire_id)
end
end

def contributor
Team.find_by_id(self.reviewee_id)
end

def get_title
return "Self Review"
end
end</pre>In order to take full advantage of the new feature, instructors had to have the ability to turn it on or off as they see fit. As a result a checkbox to goggle the self-review feature was added to the assignment settings page in ''_general.html.erb''. Below is some sample code demonstrating the addition of a checkbox to the assignment settings:

<pre>
<tr>
<td style='padding:5px' id='assignment_is_selfreview_enabled'>
<input name="assignment_form[assignment][is_selfreview_enabled]" type="hidden" value="false"/>
<%= check_box_tag('assignment_form[assignment][is_selfreview_enabled]', 'true', @assignment_form.assignment.is_selfreview_enabled) %>
<%= label_tag('assignment_form[assignment][is_selfreview_enabled]', 'Allow self reviews?') %>
</td>
</tr></pre>

Changes were also made to ''review_mapping_controller.rb'' in order to accommodate the new self-review feature. The following method was added to handle the creation of new self-review for team members.

<pre>#E1600
# Start self review if not started yet
def start_self_review
assignment = Assignment.find(params[:assignment_id])
team_id = TeamsUser.find_by_sql(["SELECT t.id as t_id FROM teams_users u, teams t WHERE u.team_id = t.id and t.parent_id = ? and user_id = ?", assignment.id, params[:reviewer_userid]])

begin
#ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
if SelfReviewResponseMap.where(['reviewee_id = ? and reviewer_id = ?', team_id[0].t_id, params[:reviewer_id]]).first.nil?
SelfReviewResponseMap.create(:reviewee_id => team_id[0].t_id,
:reviewer_id => params[:reviewer_id],
:reviewed_object_id => assignment.id)
else
raise "Self review already assigned!"
end
redirect_to :controller => 'submitted_content', :action => 'edit', :id => params[:reviewer_id]
rescue
redirect_to :controller => 'submitted_content', :action => 'edit', :id => params[:reviewer_id], :msg => $!
end
end</pre>

==Testing==
Tests have been added to confirm all of the new functionality, below are some test samples that were implemented with the changes:

<pre>test "method_questionnaire" do
@questionnaire = questionnaires(:questionnaire0)
@assignment = assignments(:assignment1)
reviewrespmap = SelfReviewResponseMap.new
reviewrespmap.assignment = @assignment
reviewrespmap.questionnaire 1
assert_equal reviewrespmap.assignment.questionnaires[0].type, "ReviewQuestionnaire"
end

test "method_get_title" do
p = SelfReviewResponseMap.new
assert_equal p.get_title, "Self Review"
end

test "method_contributor" do
p = SelfReviewResponseMap.new
p.reviewee = teams(:team0)
team_id = p.contributor
assert_equal p.reviewee.id, team_id.id
end

test "reviewer_reviewee_same_team_test" do
p = SelfReviewResponseMap.new
p.reviewee = teams(:team0)
@participant = participants(:par1)
team_id = TeamsUser.find_by_sql(["SELECT t.id as t_id FROM teams_users u, teams t WHERE u.team_id = t.id and t.parent_id = ? and user_id = ?", @participant.parent_id, @participant.user_id])
assert_equal p.reviewee.id, team_id[0].t_id
end</pre>

==References==
# [https://github.com/expertiza/expertiza Expertiza on GitHub]
# [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Documentation]
# [http://expertiza.ncsu.edu/ Expertiza Homepage]
# [https://github.com/saiteja09/expertiza Feature Fork]

CSC/ECE 517 Spring 2016

2016-03-23T17:54:10Z

Magoff2: /* Writing Assignment 2 */

==Calibration Assignment Submissions==
*[[Calibration Assignment Submission (OmniAuth)]]
*[[Calibration Assignment Submission (Patch_verb)]]

==Writing Assignment 2==
[[CSC/ECE 517 Spring 2016/Mozilla Implement HTML5 form validation]]

[[CSC/ECE 517 Spring 2016/Functional Tests for Questionnaire Controller]]

[[CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature]]

CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature

2016-03-23T17:52:21Z

Magoff2:

This page will discuss the newly added peer self review feature that was added to the Expertiza project.

== Background ==
Developed by both students and faculty at [https://en.wikipedia.org/wiki/North_Carolina_State_University North Carolina State University] using [http://rubyonrails.org/ Ruby on Rails], [http://expertiza.ncsu.edu/ Expertiza] is a educational based web application that allows to students to peer review other student's work. In Expertiza, instructors are in charge of courses and within each course, they may create a series of assignments for students to contribute to, either as a member of a team or individually. Students or Teams may submit their assignments to the system through multiple means including file uploads and embedded links. Then assignments may become available to peer review by other members of the course, which provides a way to [https://en.wikipedia.org/wiki/Crowdsourcing crowd-source] grading on the work.

== Problem Statement ==
Expertiza previously contained a self-review feature where student's were able to review their own work after submitting their assignments but it was removed due to the inconsistency with the other types of reviews. The task was to re-implement the feature in a way that ensured the overall design would remain intact. The self-review feature should allow students to review their own submission using the same rubric that was provided to other peer reviewers of the assignment. By reviewing their own work, students will be able to assess the artifact through the rubric and may be inspired to make improvements between rounds of peer-reviews.

=== What Needs Done: ===
The following tasks were given to be completed by the team:
* The self-review feature should use the same questionnaire_id as a peer-review. That way developers may call "''assignment.get_review_questionnaire_id(round)''" to get a questionnaire for the self-review.
* A method called "''self_review_response_map?''" should be added to ''review_response_map.rb''. The method will return true if the response_map is a self_response map. In order to determine the result the method shall compare the ''reviewer_id'' and ''reviewee_id'' in the response_map record and if the participant is a member of the reviewee team, true will be returned.
* Student shall do a self-review in the "your work" section. There should be a button called "Review my own work" (or "our own work" if it is a team assignment). When the button is clicked a new review_response_map record is created. Within the map, the reviewer_id is the participant id and the reviewee_id is the team_id.
* If the response_map record for self-review exists, a hyperlink with the text "begin" should appear. A student may click the link and fill in the questionnaire just like how they would for a regular peer review.
* If the self-review response_map exists and there has already been a response, two links entitled "view" and "edit" will appear that will function similarly to peer reviews.
* If the self-review was completed in the last round and the current round uses a different questionnaire (using the ''vary_rubric_by_round'' feature), a link called "update" will appear, which brings students to a new page to fill in the new rubric for the new round.
* In ''grades_controller.view_my_scores,'' self-review responses shall be excluded.
* In ''grades_controller.view_team,'' self-review responses shall be excluded.
* In ''grades_controller.view,'' self-review responses shall be excluded.
* The method called "''add_self_reviewer"'' in ''ReviewMappingController'', shall allow instructors to create self-review response maps. This method needs to be made functional again.
* Automated tests must be created.

== Files Modified in Project ==
The following files were modified in creating the new self-review feature
* ''review_response_map.rb''
* ''review_mapping_controller.rb''
* ''response_controller.rb''
* ''_set_dynamic_review.html.erb''
* ''_main.html.erb''
* ''_review_strategy.html.erb''
* ''response.html.erb''
* ''routes.rb''
* ''test_helper.rb''
* ''submitted_content_controller_test.rb''
* ''factories.rb''
* ''test_helper.rb''

The following files were created:
* ''self_review_response_map.rb''
* ''_self_review.html.erb''
* ''20160321221146_add_columnselfreviewenabled.rb''

The following test classes were created:
* ''self_review_response_maps.rb''
* ''self_review_response_map_test.rb''
* ''response_map_test.rb''

The following fixtures were modified:
* ''response_maps.yml''
* ''participants.yml''
* ''assignments.yml''
* ''questionnaires.yml''
* ''roles.yml''
* ''users.yml''
* ''assignment_questionnaires.yml''
* ''response_maps.yml''
* ''responses.yml''
* ''teams.yml''
* ''teams_users.yml''

== Walkthrough ==
Below are walkthroughs that will guide users through the new functionality included in the update.

=== Instructor Perspective ===
When creating a new assignment, an instructor will have an option to enable self-reviews. In order to allow for self-reviews to be completed, the instructor must check the box while either creating or editing the assignment.

=== Student Perspective ===
If self-reviews are available on an assignment the following will be available for students to use.

# During the beginning stages of an assignment under "your work" the User Interface will show a label called Self-Review and a button which reads "Review my/our own work" (depending on whether it is an individual or team assignment).
# After selecting "Review my/our own work" the button will change to "Begin" (just like how a peer review works).
# Once the user selects "Begin" they will be taken to a questionnaire to complete. The questionnaire is the same one that a peer reviewer would complete.
# Similarly to a peer review, a user may either "Save" or "Submit" their self-review.
# After a user saves a self-review, "View" and "Edit" links will appear. However, once a user submits their self-review, they will be unable to edit the peer review.
# If there are multiple rounds of submissions and reviews, then in all following rounds an update link will appear to allow for students to update their self-review.
# If late submissions are allowed (via Expertiza "submission allowed" flag) then a user may begin and submit self reviews even in other review stages.
# If a self-review is not submitted throughout the duration of the assignment then "Work yet to be submitted" will be shown.
# Scores from self-reviews will not be considered when calculating grades throughout the assignment.

== Database modification ==
In order to implement the self-review feature a modification of the database was required to add the column, ''is_selfreview_enabled'', to the ''assignments'' table. Below is the new database migration:

<pre>#E1600
class AddColumnselfreviewenabled < ActiveRecord::Migration
def self.up
add_column :assignments, :is_selfreview_enabled, :boolean
end

def self.down
remove_column :assignments, :is_selfreview_enabled, :boolean
end
end</pre>

== Notable Code Changes ==
The largest change to the codebase to accommodate for the new self-review feature was the addition of a new type of Response Map called ''"SelfReviewResponseMap."'' The new model class is shown below:

<pre>#E1600
class SelfReviewResponseMap < ResponseMap
belongs_to :reviewee, :class_name => 'Team', :foreign_key => 'reviewee_id'
belongs_to :assignment, :class_name => 'Assignment', :foreign_key => 'reviewed_object_id'

def questionnaire(round)
if self.assignment.varying_rubrics_by_round?
Questionnaire.find(self.assignment.get_review_questionnaire_id(round))
else
Questionnaire.find(self.assignment.get_review_questionnaire_id)
end
end

def contributor
Team.find_by_id(self.reviewee_id)
end

def get_title
return "Self Review"
end
end</pre>In order to take full advantage of the new feature, instructors had to have the ability to turn it on or off as they see fit. As a result a checkbox to goggle the self-review feature was added to the assignment settings page in ''_general.html.erb''. Below is some sample code demonstrating the addition of a checkbox to the assignment settings:

<pre>
<tr>
<td style='padding:5px' id='assignment_is_selfreview_enabled'>
<input name="assignment_form[assignment][is_selfreview_enabled]" type="hidden" value="false"/>
<%= check_box_tag('assignment_form[assignment][is_selfreview_enabled]', 'true', @assignment_form.assignment.is_selfreview_enabled) %>
<%= label_tag('assignment_form[assignment][is_selfreview_enabled]', 'Allow self reviews?') %>
</td>
</tr></pre>

Changes were also made to ''review_mapping_controller.rb'' in order to accommodate the new self-review feature. The following method was added to handle the creation of new self-review for team members.

<pre>#E1600
# Start self review if not started yet
def start_self_review
assignment = Assignment.find(params[:assignment_id])
team_id = TeamsUser.find_by_sql(["SELECT t.id as t_id FROM teams_users u, teams t WHERE u.team_id = t.id and t.parent_id = ? and user_id = ?", assignment.id, params[:reviewer_userid]])

begin
#ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
if SelfReviewResponseMap.where(['reviewee_id = ? and reviewer_id = ?', team_id[0].t_id, params[:reviewer_id]]).first.nil?
SelfReviewResponseMap.create(:reviewee_id => team_id[0].t_id,
:reviewer_id => params[:reviewer_id],
:reviewed_object_id => assignment.id)
else
raise "Self review already assigned!"
end
redirect_to :controller => 'submitted_content', :action => 'edit', :id => params[:reviewer_id]
rescue
redirect_to :controller => 'submitted_content', :action => 'edit', :id => params[:reviewer_id], :msg => $!
end
end</pre>

==Testing==
Tests have been added to confirm all of the new functionality, below are some test samples that were implemented with the changes:

<pre>test "method_questionnaire" do
@questionnaire = questionnaires(:questionnaire0)
@assignment = assignments(:assignment1)
reviewrespmap = SelfReviewResponseMap.new
reviewrespmap.assignment = @assignment
reviewrespmap.questionnaire 1
assert_equal reviewrespmap.assignment.questionnaires[0].type, "ReviewQuestionnaire"
end

test "method_get_title" do
p = SelfReviewResponseMap.new
assert_equal p.get_title, "Self Review"
end

test "method_contributor" do
p = SelfReviewResponseMap.new
p.reviewee = teams(:team0)
team_id = p.contributor
assert_equal p.reviewee.id, team_id.id
end

test "reviewer_reviewee_same_team_test" do
p = SelfReviewResponseMap.new
p.reviewee = teams(:team0)
@participant = participants(:par1)
team_id = TeamsUser.find_by_sql(["SELECT t.id as t_id FROM teams_users u, teams t WHERE u.team_id = t.id and t.parent_id = ? and user_id = ?", @participant.parent_id, @participant.user_id])
assert_equal p.reviewee.id, team_id[0].t_id
end</pre>

==References==
# [https://github.com/expertiza/expertiza Expertiza on GitHub]
# [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Documentation]
# [http://expertiza.ncsu.edu/ Expertiza Homepage]
# [https://github.com/saiteja09/expertiza Feature Fork]

User:Magoff2

2016-03-23T17:51:52Z

Magoff2: moved User:Magoff2 to CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature: In order to publish on the wiki

#REDIRECT [[CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature]]

CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature

2016-03-23T17:51:52Z

Magoff2: moved User:Magoff2 to CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature: In order to publish on the wiki

= CSC/ECE 517 Spring 2016/oss E1600 =
This page will discuss the newly added peer self review feature that was added to the Expertiza project.

== Background ==
Developed by both students and faculty at [https://en.wikipedia.org/wiki/North_Carolina_State_University North Carolina State University] using [http://rubyonrails.org/ Ruby on Rails], [http://expertiza.ncsu.edu/ Expertiza] is a educational based web application that allows to students to peer review other student's work. In Expertiza, instructors are in charge of courses and within each course, they may create a series of assignments for students to contribute to, either as a member of a team or individually. Students or Teams may submit their assignments to the system through multiple means including file uploads and embedded links. Then assignments may become available to peer review by other members of the course, which provides a way to [https://en.wikipedia.org/wiki/Crowdsourcing crowd-source] grading on the work.

== Problem Statement ==
Expertiza previously contained a self-review feature where student's were able to review their own work after submitting their assignments but it was removed due to the inconsistency with the other types of reviews. The task was to re-implement the feature in a way that ensured the overall design would remain intact. The self-review feature should allow students to review their own submission using the same rubric that was provided to other peer reviewers of the assignment. By reviewing their own work, students will be able to assess the artifact through the rubric and may be inspired to make improvements between rounds of peer-reviews.

=== What Needs Done: ===
The following tasks were given to be completed by the team:
* The self-review feature should use the same questionnaire_id as a peer-review. That way developers may call "''assignment.get_review_questionnaire_id(round)''" to get a questionnaire for the self-review.
* A method called "''self_review_response_map?''" should be added to ''review_response_map.rb''. The method will return true if the response_map is a self_response map. In order to determine the result the method shall compare the ''reviewer_id'' and ''reviewee_id'' in the response_map record and if the participant is a member of the reviewee team, true will be returned.
* Student shall do a self-review in the "your work" section. There should be a button called "Review my own work" (or "our own work" if it is a team assignment). When the button is clicked a new review_response_map record is created. Within the map, the reviewer_id is the participant id and the reviewee_id is the team_id.
* If the response_map record for self-review exists, a hyperlink with the text "begin" should appear. A student may click the link and fill in the questionnaire just like how they would for a regular peer review.
* If the self-review response_map exists and there has already been a response, two links entitled "view" and "edit" will appear that will function similarly to peer reviews.
* If the self-review was completed in the last round and the current round uses a different questionnaire (using the ''vary_rubric_by_round'' feature), a link called "update" will appear, which brings students to a new page to fill in the new rubric for the new round.
* In ''grades_controller.view_my_scores,'' self-review responses shall be excluded.
* In ''grades_controller.view_team,'' self-review responses shall be excluded.
* In ''grades_controller.view,'' self-review responses shall be excluded.
* The method called "''add_self_reviewer"'' in ''ReviewMappingController'', shall allow instructors to create self-review response maps. This method needs to be made functional again.
* Automated tests must be created.

== Files Modified in Project ==
The following files were modified in creating the new self-review feature
* ''review_response_map.rb''
* ''review_mapping_controller.rb''
* ''response_controller.rb''
* ''_set_dynamic_review.html.erb''
* ''_main.html.erb''
* ''_review_strategy.html.erb''
* ''response.html.erb''
* ''routes.rb''
* ''test_helper.rb''
* ''submitted_content_controller_test.rb''
* ''factories.rb''
* ''test_helper.rb''

The following files were created:
* ''self_review_response_map.rb''
* ''_self_review.html.erb''
* ''20160321221146_add_columnselfreviewenabled.rb''

The following test classes were created:
* ''self_review_response_maps.rb''
* ''self_review_response_map_test.rb''
* ''response_map_test.rb''

The following fixtures were modified:
* ''response_maps.yml''
* ''participants.yml''
* ''assignments.yml''
* ''questionnaires.yml''
* ''roles.yml''
* ''users.yml''
* ''assignment_questionnaires.yml''
* ''response_maps.yml''
* ''responses.yml''
* ''teams.yml''
* ''teams_users.yml''

== Walkthrough ==
Below are walkthroughs that will guide users through the new functionality included in the update.

=== Instructor Perspective ===
When creating a new assignment, an instructor will have an option to enable self-reviews. In order to allow for self-reviews to be completed, the instructor must check the box while either creating or editing the assignment.

=== Student Perspective ===
If self-reviews are available on an assignment the following will be available for students to use.

# During the beginning stages of an assignment under "your work" the User Interface will show a label called Self-Review and a button which reads "Review my/our own work" (depending on whether it is an individual or team assignment).
# After selecting "Review my/our own work" the button will change to "Begin" (just like how a peer review works).
# Once the user selects "Begin" they will be taken to a questionnaire to complete. The questionnaire is the same one that a peer reviewer would complete.
# Similarly to a peer review, a user may either "Save" or "Submit" their self-review.
# After a user saves a self-review, "View" and "Edit" links will appear. However, once a user submits their self-review, they will be unable to edit the peer review.
# If there are multiple rounds of submissions and reviews, then in all following rounds an update link will appear to allow for students to update their self-review.
# If late submissions are allowed (via Expertiza "submission allowed" flag) then a user may begin and submit self reviews even in other review stages.
# If a self-review is not submitted throughout the duration of the assignment then "Work yet to be submitted" will be shown.
# Scores from self-reviews will not be considered when calculating grades throughout the assignment.

== Database modification ==
In order to implement the self-review feature a modification of the database was required to add the column, ''is_selfreview_enabled'', to the ''assignments'' table. Below is the new database migration:

<pre>#E1600
class AddColumnselfreviewenabled < ActiveRecord::Migration
def self.up
add_column :assignments, :is_selfreview_enabled, :boolean
end

def self.down
remove_column :assignments, :is_selfreview_enabled, :boolean
end
end</pre>

== Notable Code Changes ==
The largest change to the codebase to accommodate for the new self-review feature was the addition of a new type of Response Map called ''"SelfReviewResponseMap."'' The new model class is shown below:

<pre>#E1600
class SelfReviewResponseMap < ResponseMap
belongs_to :reviewee, :class_name => 'Team', :foreign_key => 'reviewee_id'
belongs_to :assignment, :class_name => 'Assignment', :foreign_key => 'reviewed_object_id'

def questionnaire(round)
if self.assignment.varying_rubrics_by_round?
Questionnaire.find(self.assignment.get_review_questionnaire_id(round))
else
Questionnaire.find(self.assignment.get_review_questionnaire_id)
end
end

def contributor
Team.find_by_id(self.reviewee_id)
end

def get_title
return "Self Review"
end
end</pre>In order to take full advantage of the new feature, instructors had to have the ability to turn it on or off as they see fit. As a result a checkbox to goggle the self-review feature was added to the assignment settings page in ''_general.html.erb''. Below is some sample code demonstrating the addition of a checkbox to the assignment settings:

<pre>
<tr>
<td style='padding:5px' id='assignment_is_selfreview_enabled'>
<input name="assignment_form[assignment][is_selfreview_enabled]" type="hidden" value="false"/>
<%= check_box_tag('assignment_form[assignment][is_selfreview_enabled]', 'true', @assignment_form.assignment.is_selfreview_enabled) %>
<%= label_tag('assignment_form[assignment][is_selfreview_enabled]', 'Allow self reviews?') %>
</td>
</tr></pre>

Changes were also made to ''review_mapping_controller.rb'' in order to accommodate the new self-review feature. The following method was added to handle the creation of new self-review for team members.

<pre>#E1600
# Start self review if not started yet
def start_self_review
assignment = Assignment.find(params[:assignment_id])
team_id = TeamsUser.find_by_sql(["SELECT t.id as t_id FROM teams_users u, teams t WHERE u.team_id = t.id and t.parent_id = ? and user_id = ?", assignment.id, params[:reviewer_userid]])

begin
#ACS Removed the if condition(and corressponding else) which differentiate assignments as team and individual assignments
# to treat all assignments as team assignments
if SelfReviewResponseMap.where(['reviewee_id = ? and reviewer_id = ?', team_id[0].t_id, params[:reviewer_id]]).first.nil?
SelfReviewResponseMap.create(:reviewee_id => team_id[0].t_id,
:reviewer_id => params[:reviewer_id],
:reviewed_object_id => assignment.id)
else
raise "Self review already assigned!"
end
redirect_to :controller => 'submitted_content', :action => 'edit', :id => params[:reviewer_id]
rescue
redirect_to :controller => 'submitted_content', :action => 'edit', :id => params[:reviewer_id], :msg => $!
end
end</pre>

==Testing==
Tests have been added to confirm all of the new functionality, below are some test samples that were implemented with the changes:

<pre>test "method_questionnaire" do
@questionnaire = questionnaires(:questionnaire0)
@assignment = assignments(:assignment1)
reviewrespmap = SelfReviewResponseMap.new
reviewrespmap.assignment = @assignment
reviewrespmap.questionnaire 1
assert_equal reviewrespmap.assignment.questionnaires[0].type, "ReviewQuestionnaire"
end

test "method_get_title" do
p = SelfReviewResponseMap.new
assert_equal p.get_title, "Self Review"
end

test "method_contributor" do
p = SelfReviewResponseMap.new
p.reviewee = teams(:team0)
team_id = p.contributor
assert_equal p.reviewee.id, team_id.id
end

test "reviewer_reviewee_same_team_test" do
p = SelfReviewResponseMap.new
p.reviewee = teams(:team0)
@participant = participants(:par1)
team_id = TeamsUser.find_by_sql(["SELECT t.id as t_id FROM teams_users u, teams t WHERE u.team_id = t.id and t.parent_id = ? and user_id = ?", @participant.parent_id, @participant.user_id])
assert_equal p.reviewee.id, team_id[0].t_id
end</pre>

==References==
# [https://github.com/expertiza/expertiza Expertiza on GitHub]
# [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Documentation]
# [http://expertiza.ncsu.edu/ Expertiza Homepage]
# [https://github.com/saiteja09/expertiza Feature Fork]

CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature

2016-03-23T17:49:19Z

Magoff2: Added another notable code section

CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature

2016-03-23T17:43:52Z

Magoff2: Added more changed files

= CSC/ECE 517 Spring 2016/oss E1600 =
This page will discuss the newly added peer self review feature that was added to the Expertiza project.

== Background ==
Developed by both students and faculty at [https://en.wikipedia.org/wiki/North_Carolina_State_University North Carolina State University] using [http://rubyonrails.org/ Ruby on Rails], [http://expertiza.ncsu.edu/ Expertiza] is a educational based web application that allows to students to peer review other student's work. In Expertiza, instructors are in charge of courses and within each course, they may create a series of assignments for students to contribute to, either as a member of a team or individually. Students or Teams may submit their assignments to the system through multiple means including file uploads and embedded links. Then assignments may become available to peer review by other members of the course, which provides a way to [https://en.wikipedia.org/wiki/Crowdsourcing crowd-source] grading on the work.

== Problem Statement ==
Expertiza previously contained a self-review feature where student's were able to review their own work after submitting their assignments but it was removed due to the inconsistency with the other types of reviews. The task was to re-implement the feature in a way that ensured the overall design would remain intact. The self-review feature should allow students to review their own submission using the same rubric that was provided to other peer reviewers of the assignment. By reviewing their own work, students will be able to assess the artifact through the rubric and may be inspired to make improvements between rounds of peer-reviews.

=== What Needs Done: ===
The following tasks were given to be completed by the team:
* The self-review feature should use the same questionnaire_id as a peer-review. That way developers may call "''assignment.get_review_questionnaire_id(round)''" to get a questionnaire for the self-review.
* A method called "''self_review_response_map?''" should be added to ''review_response_map.rb''. The method will return true if the response_map is a self_response map. In order to determine the result the method shall compare the ''reviewer_id'' and ''reviewee_id'' in the response_map record and if the participant is a member of the reviewee team, true will be returned.
* Student shall do a self-review in the "your work" section. There should be a button called "Review my own work" (or "our own work" if it is a team assignment). When the button is clicked a new review_response_map record is created. Within the map, the reviewer_id is the participant id and the reviewee_id is the team_id.
* If the response_map record for self-review exists, a hyperlink with the text "begin" should appear. A student may click the link and fill in the questionnaire just like how they would for a regular peer review.
* If the self-review response_map exists and there has already been a response, two links entitled "view" and "edit" will appear that will function similarly to peer reviews.
* If the self-review was completed in the last round and the current round uses a different questionnaire (using the ''vary_rubric_by_round'' feature), a link called "update" will appear, which brings students to a new page to fill in the new rubric for the new round.
* In ''grades_controller.view_my_scores,'' self-review responses shall be excluded.
* In ''grades_controller.view_team,'' self-review responses shall be excluded.
* In ''grades_controller.view,'' self-review responses shall be excluded.
* The method called "''add_self_reviewer"'' in ''ReviewMappingController'', shall allow instructors to create self-review response maps. This method needs to be made functional again.
* Automated tests must be created.

== Files Modified in Project ==
The following files were modified in creating the new self-review feature
* ''review_response_map.rb''
* ''review_mapping_controller.rb''
* ''response_controller.rb''
* ''_set_dynamic_review.html.erb''
* ''_main.html.erb''
* ''_review_strategy.html.erb''
* ''response.html.erb''
* ''routes.rb''
* ''test_helper.rb''
* ''submitted_content_controller_test.rb''
* ''factories.rb''
* ''test_helper.rb''

The following files were created:
* ''self_review_response_map.rb''
* ''_self_review.html.erb''
* ''20160321221146_add_columnselfreviewenabled.rb''

The following test classes were created:
* ''self_review_response_maps.rb''
* ''self_review_response_map_test.rb''
* ''response_map_test.rb''

The following fixtures were modified:
* ''response_maps.yml''
* ''participants.yml''
* ''assignments.yml''
* ''questionnaires.yml''
* ''roles.yml''
* ''users.yml''
* ''assignment_questionnaires.yml''
* ''response_maps.yml''
* ''responses.yml''
* ''teams.yml''
* ''teams_users.yml''

== Walkthrough ==
Below are walkthroughs that will guide users through the new functionality included in the update.

=== Instructor Perspective ===
When creating a new assignment, an instructor will have an option to enable self-reviews. In order to allow for self-reviews to be completed, the instructor must check the box while either creating or editing the assignment.

=== Student Perspective ===
If self-reviews are available on an assignment the following will be available for students to use.

# During the beginning stages of an assignment under "your work" the User Interface will show a label called Self-Review and a button which reads "Review my/our own work" (depending on whether it is an individual or team assignment).
# After selecting "Review my/our own work" the button will change to "Begin" (just like how a peer review works).
# Once the user selects "Begin" they will be taken to a questionnaire to complete. The questionnaire is the same one that a peer reviewer would complete.
# Similarly to a peer review, a user may either "Save" or "Submit" their self-review.
# After a user saves a self-review, "View" and "Edit" links will appear. However, once a user submits their self-review, they will be unable to edit the peer review.
# If there are multiple rounds of submissions and reviews, then in all following rounds an update link will appear to allow for students to update their self-review.
# If late submissions are allowed (via Expertiza "submission allowed" flag) then a user may begin and submit self reviews even in other review stages.
# If a self-review is not submitted throughout the duration of the assignment then "Work yet to be submitted" will be shown.
# Scores from self-reviews will not be considered when calculating grades throughout the assignment.

== Database modification ==
In order to implement the self-review feature a modification of the database was required to add the column, ''is_selfreview_enabled'', to the ''assignments'' table. Below is the new database migration:

<pre>#E1600
class AddColumnselfreviewenabled < ActiveRecord::Migration
def self.up
add_column :assignments, :is_selfreview_enabled, :boolean
end

def self.down
remove_column :assignments, :is_selfreview_enabled, :boolean
end
end</pre>

== Notable Code Changes ==
The largest change to the codebase to accommodate for the new self-review feature was the addition of a new type of Response Map called ''"SelfReviewResponseMap."'' The new model class is shown below:

<pre>#E1600
class SelfReviewResponseMap < ResponseMap
belongs_to :reviewee, :class_name => 'Team', :foreign_key => 'reviewee_id'
belongs_to :assignment, :class_name => 'Assignment', :foreign_key => 'reviewed_object_id'

def questionnaire(round)
if self.assignment.varying_rubrics_by_round?
Questionnaire.find(self.assignment.get_review_questionnaire_id(round))
else
Questionnaire.find(self.assignment.get_review_questionnaire_id)
end
end

def contributor
Team.find_by_id(self.reviewee_id)
end

def get_title
return "Self Review"
end
end</pre>In order to take full advantage of the new feature, instructors had to have the ability to turn it on or off as they see fit. As a result a checkbox to goggle the self-review feature was added to the assignment settings page in ''_general.html.erb''. Below is some sample code demonstrating the addition of a checkbox to the assignment settings:

<pre>
<tr>
<td style='padding:5px' id='assignment_is_selfreview_enabled'>
<input name="assignment_form[assignment][is_selfreview_enabled]" type="hidden" value="false"/>
<%= check_box_tag('assignment_form[assignment][is_selfreview_enabled]', 'true', @assignment_form.assignment.is_selfreview_enabled) %>
<%= label_tag('assignment_form[assignment][is_selfreview_enabled]', 'Allow self reviews?') %>
</td>
</tr></pre>

==Testing==
Tests have been added to confirm all of the new functionality, below are some test samples that were implemented with the changes:

<pre>test "method_questionnaire" do
@questionnaire = questionnaires(:questionnaire0)
@assignment = assignments(:assignment1)
reviewrespmap = SelfReviewResponseMap.new
reviewrespmap.assignment = @assignment
reviewrespmap.questionnaire 1
assert_equal reviewrespmap.assignment.questionnaires[0].type, "ReviewQuestionnaire"
end

test "method_get_title" do
p = SelfReviewResponseMap.new
assert_equal p.get_title, "Self Review"
end

test "method_contributor" do
p = SelfReviewResponseMap.new
p.reviewee = teams(:team0)
team_id = p.contributor
assert_equal p.reviewee.id, team_id.id
end

test "reviewer_reviewee_same_team_test" do
p = SelfReviewResponseMap.new
p.reviewee = teams(:team0)
@participant = participants(:par1)
team_id = TeamsUser.find_by_sql(["SELECT t.id as t_id FROM teams_users u, teams t WHERE u.team_id = t.id and t.parent_id = ? and user_id = ?", @participant.parent_id, @participant.user_id])
assert_equal p.reviewee.id, team_id[0].t_id
end</pre>

==References==
# [https://github.com/expertiza/expertiza Expertiza on GitHub]
# [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Documentation]
# [http://expertiza.ncsu.edu/ Expertiza Homepage]
# [https://github.com/saiteja09/expertiza Feature Fork]

CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature

2016-03-23T02:36:29Z

Magoff2: Added more sample tests

= CSC/ECE 517 Spring 2016/oss E1600 =
This page will discuss the newly added peer self review feature that was added to the Expertiza project.

== Background ==
Developed by both students and faculty at [https://en.wikipedia.org/wiki/North_Carolina_State_University North Carolina State University] using [http://rubyonrails.org/ Ruby on Rails], [http://expertiza.ncsu.edu/ Expertiza] is a educational based web application that allows to students to peer review other student's work. In Expertiza, instructors are in charge of courses and within each course, they may create a series of assignments for students to contribute to, either as a member of a team or individually. Students or Teams may submit their assignments to the system through multiple means including file uploads and embedded links. Then assignments may become available to peer review by other members of the course, which provides a way to [https://en.wikipedia.org/wiki/Crowdsourcing crowd-source] grading on the work.

== Problem Statement ==
Expertiza previously contained a self-review feature where student's were able to review their own work after submitting their assignments but it was removed due to the inconsistency with the other types of reviews. The task was to re-implement the feature in a way that ensured the overall design would remain intact. The self-review feature should allow students to review their own submission using the same rubric that was provided to other peer reviewers of the assignment. By reviewing their own work, students will be able to assess the artifact through the rubric and may be inspired to make improvements between rounds of peer-reviews.

=== What Needs Done: ===
The following tasks were given to be completed by the team:
* The self-review feature should use the same questionnaire_id as a peer-review. That way developers may call "''assignment.get_review_questionnaire_id(round)''" to get a questionnaire for the self-review.
* A method called "''self_review_response_map?''" should be added to ''review_response_map.rb''. The method will return true if the response_map is a self_response map. In order to determine the result the method shall compare the ''reviewer_id'' and ''reviewee_id'' in the response_map record and if the participant is a member of the reviewee team, true will be returned.
* Student shall do a self-review in the "your work" section. There should be a button called "Review my own work" (or "our own work" if it is a team assignment). When the button is clicked a new review_response_map record is created. Within the map, the reviewer_id is the participant id and the reviewee_id is the team_id.
* If the response_map record for self-review exists, a hyperlink with the text "begin" should appear. A student may click the link and fill in the questionnaire just like how they would for a regular peer review.
* If the self-review response_map exists and there has already been a response, two links entitled "view" and "edit" will appear that will function similarly to peer reviews.
* If the self-review was completed in the last round and the current round uses a different questionnaire (using the ''vary_rubric_by_round'' feature), a link called "update" will appear, which brings students to a new page to fill in the new rubric for the new round.
* In ''grades_controller.view_my_scores,'' self-review responses shall be excluded.
* In ''grades_controller.view_team,'' self-review responses shall be excluded.
* In ''grades_controller.view,'' self-review responses shall be excluded.
* The method called "''add_self_reviewer"'' in ''ReviewMappingController'', shall allow instructors to create self-review response maps. This method needs to be made functional again.
* Automated tests must be created.

== Files Modified in Project ==
The following files were modified in creating the new self-review feature
* ''review_response_map.rb''
* ''review_mapping_controller.rb''
* ''response_controller.rb''
* ''_set_dynamic_review.html.erb''
* ''_main.html.erb''
* ''_general.html.erb''
* ''response.html.erb''
* ''routes.rb''

The following files were created:
* ''self_review_response_map.rb''
* ''_self_review.html.erb''
* ''20160321221146_add_columnselfreviewenabled.rb''

The following test classes were created:
* ''self_review_response_maps.rb''
* ''self_review_response_map_test.rb''

== Walkthrough ==
Below are walkthroughs that will guide users through the new functionality included in the update.

=== Instructor Perspective ===
When creating a new assignment, an instructor will have an option to enable self-reviews. In order to allow for self-reviews to be completed, the instructor must check the box while either creating or editing the assignment.

=== Student Perspective ===
If self-reviews are available on an assignment the following will be available for students to use.

# During the beginning stages of an assignment under "your work" the User Interface will show a label called Self-Review and a button which reads "Review my/our own work" (depending on whether it is an individual or team assignment).
# After selecting "Review my/our own work" the button will change to "Begin" (just like how a peer review works).
# Once the user selects "Begin" they will be taken to a questionnaire to complete. The questionnaire is the same one that a peer reviewer would complete.
# Similarly to a peer review, a user may either "Save" or "Submit" their self-review.
# After a user saves a self-review, "View" and "Edit" links will appear. However, once a user submits their self-review, they will be unable to edit the peer review.
# If there are multiple rounds of submissions and reviews, then in all following rounds an update link will appear to allow for students to update their self-review.
# If late submissions are allowed (via Expertiza "submission allowed" flag) then a user may begin and submit self reviews even in other review stages.
# If a self-review is not submitted throughout the duration of the assignment then "Work yet to be submitted" will be shown.
# Scores from self-reviews will not be considered when calculating grades throughout the assignment.

== Database modification ==
In order to implement the self-review feature a modification of the database was required to add the column, ''is_selfreview_enabled'', to the ''assignments'' table. Below is the new database migration:

<pre>#E1600
class AddColumnselfreviewenabled < ActiveRecord::Migration
def self.up
add_column :assignments, :is_selfreview_enabled, :boolean
end

def self.down
remove_column :assignments, :is_selfreview_enabled, :boolean
end
end</pre>

== Notable Code Changes ==
The largest change to the codebase to accommodate for the new self-review feature was the addition of a new type of Response Map called ''"SelfReviewResponseMap."'' The new model class is shown below:

<pre>#E1600
class SelfReviewResponseMap < ResponseMap
belongs_to :reviewee, :class_name => 'Team', :foreign_key => 'reviewee_id'
belongs_to :assignment, :class_name => 'Assignment', :foreign_key => 'reviewed_object_id'

def questionnaire(round)
if self.assignment.varying_rubrics_by_round?
Questionnaire.find(self.assignment.get_review_questionnaire_id(round))
else
Questionnaire.find(self.assignment.get_review_questionnaire_id)
end
end

def contributor
Team.find_by_id(self.reviewee_id)
end

def get_title
return "Self Review"
end
end</pre>In order to take full advantage of the new feature, instructors had to have the ability to turn it on or off as they see fit. As a result a checkbox to goggle the self-review feature was added to the assignment settings page in ''_general.html.erb''. Below is some sample code demonstrating the addition of a checkbox to the assignment settings:

<pre>
<tr>
<td style='padding:5px' id='assignment_is_selfreview_enabled'>
<input name="assignment_form[assignment][is_selfreview_enabled]" type="hidden" value="false"/>
<%= check_box_tag('assignment_form[assignment][is_selfreview_enabled]', 'true', @assignment_form.assignment.is_selfreview_enabled) %>
<%= label_tag('assignment_form[assignment][is_selfreview_enabled]', 'Allow self reviews?') %>
</td>
</tr></pre>

==Testing==
Tests have been added to confirm all of the new functionality, below are some test samples that were implemented with the changes:

<pre>test "method_questionnaire" do
@questionnaire = questionnaires(:questionnaire0)
@assignment = assignments(:assignment1)
reviewrespmap = SelfReviewResponseMap.new
reviewrespmap.assignment = @assignment
reviewrespmap.questionnaire 1
assert_equal reviewrespmap.assignment.questionnaires[0].type, "ReviewQuestionnaire"
end

test "method_get_title" do
p = SelfReviewResponseMap.new
assert_equal p.get_title, "Self Review"
end

test "method_contributor" do
p = SelfReviewResponseMap.new
p.reviewee = teams(:team0)
team_id = p.contributor
assert_equal p.reviewee.id, team_id.id
end

test "reviewer_reviewee_same_team_test" do
p = SelfReviewResponseMap.new
p.reviewee = teams(:team0)
@participant = participants(:par1)
team_id = TeamsUser.find_by_sql(["SELECT t.id as t_id FROM teams_users u, teams t WHERE u.team_id = t.id and t.parent_id = ? and user_id = ?", @participant.parent_id, @participant.user_id])
assert_equal p.reviewee.id, team_id[0].t_id
end</pre>

==References==
# [https://github.com/expertiza/expertiza Expertiza on GitHub]
# [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Documentation]
# [http://expertiza.ncsu.edu/ Expertiza Homepage]
# [https://github.com/saiteja09/expertiza Feature Fork]

CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature

2016-03-23T02:34:54Z

Magoff2: Added some references

= CSC/ECE 517 Spring 2016/oss E1600 =
This page will discuss the newly added peer self review feature that was added to the Expertiza project.

== Background ==
Developed by both students and faculty at [https://en.wikipedia.org/wiki/North_Carolina_State_University North Carolina State University] using [http://rubyonrails.org/ Ruby on Rails], [http://expertiza.ncsu.edu/ Expertiza] is a educational based web application that allows to students to peer review other student's work. In Expertiza, instructors are in charge of courses and within each course, they may create a series of assignments for students to contribute to, either as a member of a team or individually. Students or Teams may submit their assignments to the system through multiple means including file uploads and embedded links. Then assignments may become available to peer review by other members of the course, which provides a way to [https://en.wikipedia.org/wiki/Crowdsourcing crowd-source] grading on the work.

== Problem Statement ==
Expertiza previously contained a self-review feature where student's were able to review their own work after submitting their assignments but it was removed due to the inconsistency with the other types of reviews. The task was to re-implement the feature in a way that ensured the overall design would remain intact. The self-review feature should allow students to review their own submission using the same rubric that was provided to other peer reviewers of the assignment. By reviewing their own work, students will be able to assess the artifact through the rubric and may be inspired to make improvements between rounds of peer-reviews.

=== What Needs Done: ===
The following tasks were given to be completed by the team:
* The self-review feature should use the same questionnaire_id as a peer-review. That way developers may call "''assignment.get_review_questionnaire_id(round)''" to get a questionnaire for the self-review.
* A method called "''self_review_response_map?''" should be added to ''review_response_map.rb''. The method will return true if the response_map is a self_response map. In order to determine the result the method shall compare the ''reviewer_id'' and ''reviewee_id'' in the response_map record and if the participant is a member of the reviewee team, true will be returned.
* Student shall do a self-review in the "your work" section. There should be a button called "Review my own work" (or "our own work" if it is a team assignment). When the button is clicked a new review_response_map record is created. Within the map, the reviewer_id is the participant id and the reviewee_id is the team_id.
* If the response_map record for self-review exists, a hyperlink with the text "begin" should appear. A student may click the link and fill in the questionnaire just like how they would for a regular peer review.
* If the self-review response_map exists and there has already been a response, two links entitled "view" and "edit" will appear that will function similarly to peer reviews.
* If the self-review was completed in the last round and the current round uses a different questionnaire (using the ''vary_rubric_by_round'' feature), a link called "update" will appear, which brings students to a new page to fill in the new rubric for the new round.
* In ''grades_controller.view_my_scores,'' self-review responses shall be excluded.
* In ''grades_controller.view_team,'' self-review responses shall be excluded.
* In ''grades_controller.view,'' self-review responses shall be excluded.
* The method called "''add_self_reviewer"'' in ''ReviewMappingController'', shall allow instructors to create self-review response maps. This method needs to be made functional again.
* Automated tests must be created.

== Files Modified in Project ==
The following files were modified in creating the new self-review feature
* ''review_response_map.rb''
* ''review_mapping_controller.rb''
* ''response_controller.rb''
* ''_set_dynamic_review.html.erb''
* ''_main.html.erb''
* ''_general.html.erb''
* ''response.html.erb''
* ''routes.rb''

The following files were created:
* ''self_review_response_map.rb''
* ''_self_review.html.erb''
* ''20160321221146_add_columnselfreviewenabled.rb''

The following test classes were created:
* ''self_review_response_maps.rb''
* ''self_review_response_map_test.rb''

== Walkthrough ==
Below are walkthroughs that will guide users through the new functionality included in the update.

=== Instructor Perspective ===
When creating a new assignment, an instructor will have an option to enable self-reviews. In order to allow for self-reviews to be completed, the instructor must check the box while either creating or editing the assignment.

=== Student Perspective ===
If self-reviews are available on an assignment the following will be available for students to use.

# During the beginning stages of an assignment under "your work" the User Interface will show a label called Self-Review and a button which reads "Review my/our own work" (depending on whether it is an individual or team assignment).
# After selecting "Review my/our own work" the button will change to "Begin" (just like how a peer review works).
# Once the user selects "Begin" they will be taken to a questionnaire to complete. The questionnaire is the same one that a peer reviewer would complete.
# Similarly to a peer review, a user may either "Save" or "Submit" their self-review.
# After a user saves a self-review, "View" and "Edit" links will appear. However, once a user submits their self-review, they will be unable to edit the peer review.
# If there are multiple rounds of submissions and reviews, then in all following rounds an update link will appear to allow for students to update their self-review.
# If late submissions are allowed (via Expertiza "submission allowed" flag) then a user may begin and submit self reviews even in other review stages.
# If a self-review is not submitted throughout the duration of the assignment then "Work yet to be submitted" will be shown.
# Scores from self-reviews will not be considered when calculating grades throughout the assignment.

== Database modification ==
In order to implement the self-review feature a modification of the database was required to add the column, ''is_selfreview_enabled'', to the ''assignments'' table. Below is the new database migration:

<pre>#E1600
class AddColumnselfreviewenabled < ActiveRecord::Migration
def self.up
add_column :assignments, :is_selfreview_enabled, :boolean
end

def self.down
remove_column :assignments, :is_selfreview_enabled, :boolean
end
end</pre>

== Notable Code Changes ==
The largest change to the codebase to accommodate for the new self-review feature was the addition of a new type of Response Map called ''"SelfReviewResponseMap."'' The new model class is shown below:

<pre>#E1600
class SelfReviewResponseMap < ResponseMap
belongs_to :reviewee, :class_name => 'Team', :foreign_key => 'reviewee_id'
belongs_to :assignment, :class_name => 'Assignment', :foreign_key => 'reviewed_object_id'

def questionnaire(round)
if self.assignment.varying_rubrics_by_round?
Questionnaire.find(self.assignment.get_review_questionnaire_id(round))
else
Questionnaire.find(self.assignment.get_review_questionnaire_id)
end
end

def contributor
Team.find_by_id(self.reviewee_id)
end

def get_title
return "Self Review"
end
end</pre>In order to take full advantage of the new feature, instructors had to have the ability to turn it on or off as they see fit. As a result a checkbox to goggle the self-review feature was added to the assignment settings page in ''_general.html.erb''. Below is some sample code demonstrating the addition of a checkbox to the assignment settings:

<pre>
<tr>
<td style='padding:5px' id='assignment_is_selfreview_enabled'>
<input name="assignment_form[assignment][is_selfreview_enabled]" type="hidden" value="false"/>
<%= check_box_tag('assignment_form[assignment][is_selfreview_enabled]', 'true', @assignment_form.assignment.is_selfreview_enabled) %>
<%= label_tag('assignment_form[assignment][is_selfreview_enabled]', 'Allow self reviews?') %>
</td>
</tr></pre>

==Testing==
Tests have been added to confirm all of the new functionality, below are some test samples that were implemented with the changes:

<pre>test "method_questionnaire" do
@questionnaire = questionnaires(:questionnaire0)
@assignment = assignments(:assignment1)
reviewrespmap = SelfReviewResponseMap.new
reviewrespmap.assignment = @assignment
reviewrespmap.questionnaire 1
assert_equal reviewrespmap.assignment.questionnaires[0].type, "ReviewQuestionnaire"
end

test "method_get_title" do
p = SelfReviewResponseMap.new
assert_equal p.get_title, "Self Review"
end</pre>

==References==
# [https://github.com/expertiza/expertiza Expertiza on GitHub]
# [http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza Documentation]
# [http://expertiza.ncsu.edu/ Expertiza Homepage]
# [https://github.com/saiteja09/expertiza Feature Fork]

CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature

2016-03-23T02:31:47Z

Magoff2:

= CSC/ECE 517 Spring 2016/oss E1600 =
This page will discuss the newly added peer self review feature that was added to the Expertiza project.

== Background ==
Developed by both students and faculty at [https://en.wikipedia.org/wiki/North_Carolina_State_University North Carolina State University] using [http://rubyonrails.org/ Ruby on Rails], [http://expertiza.ncsu.edu/ Expertiza] is a educational based web application that allows to students to peer review other student's work. In Expertiza, instructors are in charge of courses and within each course, they may create a series of assignments for students to contribute to, either as a member of a team or individually. Students or Teams may submit their assignments to the system through multiple means including file uploads and embedded links. Then assignments may become available to peer review by other members of the course, which provides a way to [https://en.wikipedia.org/wiki/Crowdsourcing crowd-source] grading on the work.

== Problem Statement ==
Expertiza previously contained a self-review feature where student's were able to review their own work after submitting their assignments but it was removed due to the inconsistency with the other types of reviews. The task was to re-implement the feature in a way that ensured the overall design would remain intact. The self-review feature should allow students to review their own submission using the same rubric that was provided to other peer reviewers of the assignment. By reviewing their own work, students will be able to assess the artifact through the rubric and may be inspired to make improvements between rounds of peer-reviews.

=== What Needs Done: ===
The following tasks were given to be completed by the team:
* The self-review feature should use the same questionnaire_id as a peer-review. That way developers may call "''assignment.get_review_questionnaire_id(round)''" to get a questionnaire for the self-review.
* A method called "''self_review_response_map?''" should be added to ''review_response_map.rb''. The method will return true if the response_map is a self_response map. In order to determine the result the method shall compare the ''reviewer_id'' and ''reviewee_id'' in the response_map record and if the participant is a member of the reviewee team, true will be returned.
* Student shall do a self-review in the "your work" section. There should be a button called "Review my own work" (or "our own work" if it is a team assignment). When the button is clicked a new review_response_map record is created. Within the map, the reviewer_id is the participant id and the reviewee_id is the team_id.
* If the response_map record for self-review exists, a hyperlink with the text "begin" should appear. A student may click the link and fill in the questionnaire just like how they would for a regular peer review.
* If the self-review response_map exists and there has already been a response, two links entitled "view" and "edit" will appear that will function similarly to peer reviews.
* If the self-review was completed in the last round and the current round uses a different questionnaire (using the ''vary_rubric_by_round'' feature), a link called "update" will appear, which brings students to a new page to fill in the new rubric for the new round.
* In ''grades_controller.view_my_scores,'' self-review responses shall be excluded.
* In ''grades_controller.view_team,'' self-review responses shall be excluded.
* In ''grades_controller.view,'' self-review responses shall be excluded.
* The method called "''add_self_reviewer"'' in ''ReviewMappingController'', shall allow instructors to create self-review response maps. This method needs to be made functional again.
* Automated tests must be created.

== Files Modified in Project ==
The following files were modified in creating the new self-review feature
* ''review_response_map.rb''
* ''review_mapping_controller.rb''
* ''response_controller.rb''
* ''_set_dynamic_review.html.erb''
* ''_main.html.erb''
* ''_general.html.erb''
* ''response.html.erb''
* ''routes.rb''

The following files were created:
* ''self_review_response_map.rb''
* ''_self_review.html.erb''
* ''20160321221146_add_columnselfreviewenabled.rb''

The following test classes were created:
* ''self_review_response_maps.rb''
* ''self_review_response_map_test.rb''

== Walkthrough ==
Below are walkthroughs that will guide users through the new functionality included in the update.

=== Instructor Perspective ===
When creating a new assignment, an instructor will have an option to enable self-reviews. In order to allow for self-reviews to be completed, the instructor must check the box while either creating or editing the assignment.

=== Student Perspective ===
If self-reviews are available on an assignment the following will be available for students to use.

# During the beginning stages of an assignment under "your work" the User Interface will show a label called Self-Review and a button which reads "Review my/our own work" (depending on whether it is an individual or team assignment).
# After selecting "Review my/our own work" the button will change to "Begin" (just like how a peer review works).
# Once the user selects "Begin" they will be taken to a questionnaire to complete. The questionnaire is the same one that a peer reviewer would complete.
# Similarly to a peer review, a user may either "Save" or "Submit" their self-review.
# After a user saves a self-review, "View" and "Edit" links will appear. However, once a user submits their self-review, they will be unable to edit the peer review.
# If there are multiple rounds of submissions and reviews, then in all following rounds an update link will appear to allow for students to update their self-review.
# If late submissions are allowed (via Expertiza "submission allowed" flag) then a user may begin and submit self reviews even in other review stages.
# If a self-review is not submitted throughout the duration of the assignment then "Work yet to be submitted" will be shown.
# Scores from self-reviews will not be considered when calculating grades throughout the assignment.

== Database modification ==
In order to implement the self-review feature a modification of the database was required to add the column, ''is_selfreview_enabled'', to the ''assignments'' table. Below is the new database migration:

<pre>#E1600
class AddColumnselfreviewenabled < ActiveRecord::Migration
def self.up
add_column :assignments, :is_selfreview_enabled, :boolean
end

def self.down
remove_column :assignments, :is_selfreview_enabled, :boolean
end
end</pre>

== Notable Code Changes ==
The largest change to the codebase to accommodate for the new self-review feature was the addition of a new type of Response Map called ''"SelfReviewResponseMap."'' The new model class is shown below:

<pre>#E1600
class SelfReviewResponseMap < ResponseMap
belongs_to :reviewee, :class_name => 'Team', :foreign_key => 'reviewee_id'
belongs_to :assignment, :class_name => 'Assignment', :foreign_key => 'reviewed_object_id'

def questionnaire(round)
if self.assignment.varying_rubrics_by_round?
Questionnaire.find(self.assignment.get_review_questionnaire_id(round))
else
Questionnaire.find(self.assignment.get_review_questionnaire_id)
end
end

def contributor
Team.find_by_id(self.reviewee_id)
end

def get_title
return "Self Review"
end
end</pre>In order to take full advantage of the new feature, instructors had to have the ability to turn it on or off as they see fit. As a result a checkbox to goggle the self-review feature was added to the assignment settings page in ''_general.html.erb''. Below is some sample code demonstrating the addition of a checkbox to the assignment settings:

<pre>
<tr>
<td style='padding:5px' id='assignment_is_selfreview_enabled'>
<input name="assignment_form[assignment][is_selfreview_enabled]" type="hidden" value="false"/>
<%= check_box_tag('assignment_form[assignment][is_selfreview_enabled]', 'true', @assignment_form.assignment.is_selfreview_enabled) %>
<%= label_tag('assignment_form[assignment][is_selfreview_enabled]', 'Allow self reviews?') %>
</td>
</tr></pre>

==Testing==
Tests have been added to confirm all of the new functionality, below are some test samples that were implemented with the changes:

<pre>test "method_questionnaire" do
@questionnaire = questionnaires(:questionnaire0)
@assignment = assignments(:assignment1)
reviewrespmap = SelfReviewResponseMap.new
reviewrespmap.assignment = @assignment
reviewrespmap.questionnaire 1
assert_equal reviewrespmap.assignment.questionnaires[0].type, "ReviewQuestionnaire"
end

test "method_get_title" do
p = SelfReviewResponseMap.new
assert_equal p.get_title, "Self Review"
end</pre>

CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature

2016-03-23T02:28:47Z

Magoff2: /* Background */

= CSC/ECE 517 Spring 2016/oss E1600 =
This page will discuss the newly added peer self review feature that was added to the Expertiza project.

== Background ==
Developed by both students and faculty at [https://en.wikipedia.org/wiki/North_Carolina_State_University North Carolina State University], Expertiza is a educational based web application that allows to students to peer review other student's work. In Expertiza, instructors are in charge of courses and within each course, they may create a series of assignments for students to contribute to, either as a member of a team or individually. Students or Teams may submit their assignments to the system through multiple means including file uploads and embedded links. Then assignments may become available to peer review by other members of the course, which provides a way to [https://en.wikipedia.org/wiki/Crowdsourcing crowd-source] grading on the work.

== Problem Statement ==
Expertiza previously contained a self-review feature where student's were able to review their own work after submitting their assignments but it was removed due to the inconsistency with the other types of reviews. The task was to re-implement the feature in a way that ensured the overall design would remain intact. The self-review feature should allow students to review their own submission using the same rubric that was provided to other peer reviewers of the assignment. By reviewing their own work, students will be able to assess the artifact through the rubric and may be inspired to make improvements between rounds of peer-reviews.

=== What Needs Done: ===
The following tasks were given to be completed by the team:
* The self-review feature should use the same questionnaire_id as a peer-review. That way developers may call "''assignment.get_review_questionnaire_id(round)''" to get a questionnaire for the self-review.
* A method called "''self_review_response_map?''" should be added to ''review_response_map.rb''. The method will return true if the response_map is a self_response map. In order to determine the result the method shall compare the ''reviewer_id'' and ''reviewee_id'' in the response_map record and if the participant is a member of the reviewee team, true will be returned.
* Student shall do a self-review in the "your work" section. There should be a button called "Review my own work" (or "our own work" if it is a team assignment). When the button is clicked a new review_response_map record is created. Within the map, the reviewer_id is the participant id and the reviewee_id is the team_id.
* If the response_map record for self-review exists, a hyperlink with the text "begin" should appear. A student may click the link and fill in the questionnaire just like how they would for a regular peer review.
* If the self-review response_map exists and there has already been a response, two links entitled "view" and "edit" will appear that will function similarly to peer reviews.
* If the self-review was completed in the last round and the current round uses a different questionnaire (using the ''vary_rubric_by_round'' feature), a link called "update" will appear, which brings students to a new page to fill in the new rubric for the new round.
* In ''grades_controller.view_my_scores,'' self-review responses shall be excluded.
* In ''grades_controller.view_team,'' self-review responses shall be excluded.
* In ''grades_controller.view,'' self-review responses shall be excluded.
* The method called "''add_self_reviewer"'' in ''ReviewMappingController'', shall allow instructors to create self-review response maps. This method needs to be made functional again.
* Automated tests must be created.

== Files Modified in Project ==
The following files were modified in creating the new self-review feature
* ''review_response_map.rb''
* ''review_mapping_controller.rb''
* ''response_controller.rb''
* ''_set_dynamic_review.html.erb''
* ''_main.html.erb''
* ''_general.html.erb''
* ''response.html.erb''
* ''routes.rb''

The following files were created:
* ''self_review_response_map.rb''
* ''_self_review.html.erb''
* ''20160321221146_add_columnselfreviewenabled.rb''

The following test classes were created:
* ''self_review_response_maps.rb''
* ''self_review_response_map_test.rb''

== Walkthrough ==
Below are walkthroughs that will guide users through the new functionality included in the update.

=== Instructor Perspective ===
When creating a new assignment, an instructor will have an option to enable self-reviews. In order to allow for self-reviews to be completed, the instructor must check the box while either creating or editing the assignment.

=== Student Perspective ===
If self-reviews are available on an assignment the following will be available for students to use.

# During the beginning stages of an assignment under "your work" the User Interface will show a label called Self-Review and a button which reads "Review my/our own work" (depending on whether it is an individual or team assignment).
# After selecting "Review my/our own work" the button will change to "Begin" (just like how a peer review works).
# Once the user selects "Begin" they will be taken to a questionnaire to complete. The questionnaire is the same one that a peer reviewer would complete.
# Similarly to a peer review, a user may either "Save" or "Submit" their self-review.
# After a user saves a self-review, "View" and "Edit" links will appear. However, once a user submits their self-review, they will be unable to edit the peer review.
# If there are multiple rounds of submissions and reviews, then in all following rounds an update link will appear to allow for students to update their self-review.
# If late submissions are allowed (via Expertiza "submission allowed" flag) then a user may begin and submit self reviews even in other review stages.
# If a self-review is not submitted throughout the duration of the assignment then "Work yet to be submitted" will be shown.
# Scores from self-reviews will not be considered when calculating grades throughout the assignment.

== Database modification ==
In order to implement the self-review feature a modification of the database was required to add the column, ''is_selfreview_enabled'', to the ''assignments'' table. Below is the new database migration:

<pre>#E1600
class AddColumnselfreviewenabled < ActiveRecord::Migration
def self.up
add_column :assignments, :is_selfreview_enabled, :boolean
end

def self.down
remove_column :assignments, :is_selfreview_enabled, :boolean
end
end</pre>

== Notable Code Changes ==
The largest change to the codebase to accommodate for the new self-review feature was the addition of a new type of Response Map called ''"SelfReviewResponseMap."'' The new model class is shown below:

<pre>#E1600
class SelfReviewResponseMap < ResponseMap
belongs_to :reviewee, :class_name => 'Team', :foreign_key => 'reviewee_id'
belongs_to :assignment, :class_name => 'Assignment', :foreign_key => 'reviewed_object_id'

def questionnaire(round)
if self.assignment.varying_rubrics_by_round?
Questionnaire.find(self.assignment.get_review_questionnaire_id(round))
else
Questionnaire.find(self.assignment.get_review_questionnaire_id)
end
end

def contributor
Team.find_by_id(self.reviewee_id)
end

def get_title
return "Self Review"
end
end</pre>In order to take full advantage of the new feature, instructors had to have the ability to turn it on or off as they see fit. As a result a checkbox to goggle the self-review feature was added to the assignment settings page in ''_general.html.erb''. Below is some sample code demonstrating the addition of a checkbox to the assignment settings:

<pre>
<tr>
<td style='padding:5px' id='assignment_is_selfreview_enabled'>
<input name="assignment_form[assignment][is_selfreview_enabled]" type="hidden" value="false"/>
<%= check_box_tag('assignment_form[assignment][is_selfreview_enabled]', 'true', @assignment_form.assignment.is_selfreview_enabled) %>
<%= label_tag('assignment_form[assignment][is_selfreview_enabled]', 'Allow self reviews?') %>
</td>
</tr></pre>

==Testing==
Tests have been added to confirm all of the new functionality, below are some test samples that were implemented with the changes:

<pre>test "method_questionnaire" do
@questionnaire = questionnaires(:questionnaire0)
@assignment = assignments(:assignment1)
reviewrespmap = SelfReviewResponseMap.new
reviewrespmap.assignment = @assignment
reviewrespmap.questionnaire 1
assert_equal reviewrespmap.assignment.questionnaires[0].type, "ReviewQuestionnaire"
end

test "method_get_title" do
p = SelfReviewResponseMap.new
assert_equal p.get_title, "Self Review"
end</pre>

CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature

2016-03-23T01:42:45Z

Magoff2:

= CSC/ECE 517 Spring 2016/oss E1600 =
This page will discuss the newly added peer self review feature that was added to the Expertiza project.

== Background ==
Developed by both students and faculty at [[North Carolina State University]], Expertiza is a educational based web application that allows to students to peer review other student's work. In Expertiza, instructors are in charge of courses and within each course, they may create a series of assignments for students to contribute to, either as a member of a team or individually. Students or Teams may submit their assignments to the system through multiple means including file uploads and embedded links. Then assignments may become available to peer review by other members of the course, which provides a way to [[Crowdsourcing|crowd-source]] grading on the work.

== Problem Statement ==
Expertiza previously contained a self-review feature where student's were able to review their own work after submitting their assignments but it was removed due to the inconsistency with the other types of reviews. The task was to re-implement the feature in a way that ensured the overall design would remain intact. The self-review feature should allow students to review their own submission using the same rubric that was provided to other peer reviewers of the assignment. By reviewing their own work, students will be able to assess the artifact through the rubric and may be inspired to make improvements between rounds of peer-reviews.

=== What Needs Done: ===
The following tasks were given to be completed by the team:
* The self-review feature should use the same questionnaire_id as a peer-review. That way developers may call "''assignment.get_review_questionnaire_id(round)''" to get a questionnaire for the self-review.
* A method called "''self_review_response_map?''" should be added to ''review_response_map.rb''. The method will return true if the response_map is a self_response map. In order to determine the result the method shall compare the ''reviewer_id'' and ''reviewee_id'' in the response_map record and if the participant is a member of the reviewee team, true will be returned.
* Student shall do a self-review in the "your work" section. There should be a button called "Review my own work" (or "our own work" if it is a team assignment). When the button is clicked a new review_response_map record is created. Within the map, the reviewer_id is the participant id and the reviewee_id is the team_id.
* If the response_map record for self-review exists, a hyperlink with the text "begin" should appear. A student may click the link and fill in the questionnaire just like how they would for a regular peer review.
* If the self-review response_map exists and there has already been a response, two links entitled "view" and "edit" will appear that will function similarly to peer reviews.
* If the self-review was completed in the last round and the current round uses a different questionnaire (using the ''vary_rubric_by_round'' feature), a link called "update" will appear, which brings students to a new page to fill in the new rubric for the new round.
* In ''grades_controller.view_my_scores,'' self-review responses shall be excluded.
* In ''grades_controller.view_team,'' self-review responses shall be excluded.
* In ''grades_controller.view,'' self-review responses shall be excluded.
* The method called "''add_self_reviewer"'' in ''ReviewMappingController'', shall allow instructors to create self-review response maps. This method needs to be made functional again.
* Automated tests must be created.

== Files Modified in Project ==
The following files were modified in creating the new self-review feature
* ''review_response_map.rb''
* ''review_mapping_controller.rb''
* ''response_controller.rb''
* ''_set_dynamic_review.html.erb''
* ''_main.html.erb''
* ''_general.html.erb''
* ''response.html.erb''
* ''routes.rb''

The following files were created:
* ''self_review_response_map.rb''
* ''_self_review.html.erb''
* ''20160321221146_add_columnselfreviewenabled.rb''

The following test classes were created:
* ''self_review_response_maps.rb''
* ''self_review_response_map_test.rb''

== Walkthrough ==
Below are walkthroughs that will guide users through the new functionality included in the update.

=== Instructor Perspective ===
When creating a new assignment, an instructor will have an option to enable self-reviews. In order to allow for self-reviews to be completed, the instructor must check the box while either creating or editing the assignment.

=== Student Perspective ===
If self-reviews are available on an assignment the following will be available for students to use.

# During the beginning stages of an assignment under "your work" the User Interface will show a label called Self-Review and a button which reads "Review my/our own work" (depending on whether it is an individual or team assignment).
# After selecting "Review my/our own work" the button will change to "Begin" (just like how a peer review works).
# Once the user selects "Begin" they will be taken to a questionnaire to complete. The questionnaire is the same one that a peer reviewer would complete.
# Similarly to a peer review, a user may either "Save" or "Submit" their self-review.
# After a user saves a self-review, "View" and "Edit" links will appear. However, once a user submits their self-review, they will be unable to edit the peer review.
# If there are multiple rounds of submissions and reviews, then in all following rounds an update link will appear to allow for students to update their self-review.
# If late submissions are allowed (via Expertiza "submission allowed" flag) then a user may begin and submit self reviews even in other review stages.
# If a self-review is not submitted throughout the duration of the assignment then "Work yet to be submitted" will be shown.
# Scores from self-reviews will not be considered when calculating grades throughout the assignment.

== Database modification ==
In order to implement the self-review feature a modification of the database was required to add the column, ''is_selfreview_enabled'', to the ''assignments'' table. Below is the new database migration:

<pre>#E1600
class AddColumnselfreviewenabled < ActiveRecord::Migration
def self.up
add_column :assignments, :is_selfreview_enabled, :boolean
end

def self.down
remove_column :assignments, :is_selfreview_enabled, :boolean
end
end</pre>

== Notable Code Changes ==
The largest change to the codebase to accommodate for the new self-review feature was the addition of a new type of Response Map called ''"SelfReviewResponseMap."'' The new model class is shown below:

<pre>#E1600
class SelfReviewResponseMap < ResponseMap
belongs_to :reviewee, :class_name => 'Team', :foreign_key => 'reviewee_id'
belongs_to :assignment, :class_name => 'Assignment', :foreign_key => 'reviewed_object_id'

def questionnaire(round)
if self.assignment.varying_rubrics_by_round?
Questionnaire.find(self.assignment.get_review_questionnaire_id(round))
else
Questionnaire.find(self.assignment.get_review_questionnaire_id)
end
end

def contributor
Team.find_by_id(self.reviewee_id)
end

def get_title
return "Self Review"
end
end</pre>In order to take full advantage of the new feature, instructors had to have the ability to turn it on or off as they see fit. As a result a checkbox to goggle the self-review feature was added to the assignment settings page in ''_general.html.erb''. Below is some sample code demonstrating the addition of a checkbox to the assignment settings:

<pre>
<tr>
<td style='padding:5px' id='assignment_is_selfreview_enabled'>
<input name="assignment_form[assignment][is_selfreview_enabled]" type="hidden" value="false"/>
<%= check_box_tag('assignment_form[assignment][is_selfreview_enabled]', 'true', @assignment_form.assignment.is_selfreview_enabled) %>
<%= label_tag('assignment_form[assignment][is_selfreview_enabled]', 'Allow self reviews?') %>
</td>
</tr></pre>

==Testing==
Tests have been added to confirm all of the new functionality, below are some test samples that were implemented with the changes:

<pre>test "method_questionnaire" do
@questionnaire = questionnaires(:questionnaire0)
@assignment = assignments(:assignment1)
reviewrespmap = SelfReviewResponseMap.new
reviewrespmap.assignment = @assignment
reviewrespmap.questionnaire 1
assert_equal reviewrespmap.assignment.questionnaires[0].type, "ReviewQuestionnaire"
end

test "method_get_title" do
p = SelfReviewResponseMap.new
assert_equal p.get_title, "Self Review"
end</pre>

CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature

2016-03-23T01:23:40Z

Magoff2: Added db mod and started notable code changes

= CSC/ECE 517 Spring 2016/oss E1600 =
This page will discuss the newly added peer self review feature that was added to the Expertiza project.

== Background ==
Developed by both students and faculty at [[North Carolina State University]], Expertiza is a educational based web application that allows to students to peer review other student's work. In Expertiza, instructors are in charge of courses and within each course, they may create a series of assignments for students to contribute to, either as a member of a team or individually. Students or Teams may submit their assignments to the system through multiple means including file uploads and embedded links. Then assignments may become available to peer review by other members of the course, which provides a way to [[Crowdsourcing|crowd-source]] grading on the work.

== Problem Statement ==
Expertiza previously contained a self-review feature where student's were able to review their own work after submitting their assignments but it was removed due to the inconsistency with the other types of reviews. The task was to re-implement the feature in a way that ensured the overall design would remain intact. The self-review feature should allow students to review their own submission using the same rubric that was provided to other peer reviewers of the assignment. By reviewing their own work, students will be able to assess the artifact through the rubric and may be inspired to make improvements between rounds of peer-reviews.

=== What Needs Done: ===
The following tasks were given to be completed by the team:
* The self-review feature should use the same questionnaire_id as a peer-review. That way developers may call "''assignment.get_review_questionnaire_id(round)''" to get a questionnaire for the self-review.
* A method called "''self_review_response_map?''" should be added to ''review_response_map.rb''. The method will return true if the response_map is a self_response map. In order to determine the result the method shall compare the ''reviewer_id'' and ''reviewee_id'' in the response_map record and if the participant is a member of the reviewee team, true will be returned.
* Student shall do a self-review in the "your work" section. There should be a button called "Review my own work" (or "our own work" if it is a team assignment). When the button is clicked a new review_response_map record is created. Within the map, the reviewer_id is the participant id and the reviewee_id is the team_id.
* If the response_map record for self-review exists, a hyperlink with the text "begin" should appear. A student may click the link and fill in the questionnaire just like how they would for a regular peer review.
* If the self-review response_map exists and there has already been a response, two links entitled "view" and "edit" will appear that will function similarly to peer reviews.
* If the self-review was completed in the last round and the current round uses a different questionnaire (using the ''vary_rubric_by_round'' feature), a link called "update" will appear, which brings students to a new page to fill in the new rubric for the new round.
* In ''grades_controller.view_my_scores,'' self-review responses shall be excluded.
* In ''grades_controller.view_team,'' self-review responses shall be excluded.
* In ''grades_controller.view,'' self-review responses shall be excluded.
* The method called "''add_self_reviewer"'' in ''ReviewMappingController'', shall allow instructors to create self-review response maps. This method needs to be made functional again.
* Automated tests must be created.

== Files Modified in Project ==
The following files were modified in creating the new self-review feature
* ''review_response_map.rb''
* ''review_mapping_controller.rb''
* ''response_controller.rb''
* ''_set_dynamic_review.html.erb''
* ''_main.html.erb''
* ''_general.html.erb''
* ''response.html.erb''
* ''routes.rb''

The following files were created:
* ''self_review_response_map.rb''
* ''_self_review.html.erb''
* ''20160321221146_add_columnselfreviewenabled.rb''

The following test classes were created:
* ''self_review_response_maps.rb''
* ''self_review_response_map_test.rb''

== Walkthrough ==
Below are walkthroughs that will guide users through the new functionality included in the update.

=== Instructor Perspective ===
When creating a new assignment, an instructor will have an option to enable self-reviews. In order to allow for self-reviews to be completed, the instructor must check the box while either creating or editing the assignment.

=== Student Perspective ===
If self-reviews are available on an assignment the following will be available for students to use.

# During the beginning stages of an assignment under "your work" the User Interface will show a label called Self-Review and a button which reads "Review my/our own work" (depending on whether it is an individual or team assignment).
# After selecting "Review my/our own work" the button will change to "Begin" (just like how a peer review works).
# Once the user selects "Begin" they will be taken to a questionnaire to complete. The questionnaire is the same one that a peer reviewer would complete.
# Similarly to a peer review, a user may either "Save" or "Submit" their self-review.
# After a user saves a self-review, "View" and "Edit" links will appear. However, once a user submits their self-review, they will be unable to edit the peer review.
# If there are multiple rounds of submissions and reviews, then in all following rounds an update link will appear to allow for students to update their self-review.
# If late submissions are allowed (via Expertiza "submission allowed" flag) then a user may begin and submit self reviews even in other review stages.
# If a self-review is not submitted throughout the duration of the assignment then "Work yet to be submitted" will be shown.
# Scores from self-reviews will not be considered when calculating grades throughout the assignment.

== Database modification ==
In order to implement the self-review feature a modification of the database was required to add the column, ''is_selfreview_enabled'', to the ''assignments'' table. Below is the new database migration:

<pre>#E1600
class AddColumnselfreviewenabled < ActiveRecord::Migration
def self.up
add_column :assignments, :is_selfreview_enabled, :boolean
end

def self.down
remove_column :assignments, :is_selfreview_enabled, :boolean
end
end</pre>

== Notable Code Changes ==
The largest change to the codebase to accomodate for the new self-review feature was the addition of a new type of Response Map called ''"SelfReviewResponseMap."'' The new model class is shown below:

<pre>#E1600
class SelfReviewResponseMap < ResponseMap
belongs_to :reviewee, :class_name => 'Team', :foreign_key => 'reviewee_id'
belongs_to :assignment, :class_name => 'Assignment', :foreign_key => 'reviewed_object_id'

def questionnaire(round)
if self.assignment.varying_rubrics_by_round?
Questionnaire.find(self.assignment.get_review_questionnaire_id(round))
else
Questionnaire.find(self.assignment.get_review_questionnaire_id)
end
end

def contributor
Team.find_by_id(self.reviewee_id)
end

def get_title
return "Self Review"
end
end</pre>

CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature

2016-03-22T20:22:50Z

Magoff2: /* Student Perspective */

= CSC/ECE 517 Spring 2016/oss E1600 =
This page will discuss the newly added peer self review feature that was added to the Expertiza project.

== Background ==
Developed by both students and faculty at [[North Carolina State University]], Expertiza is a educational based web application that allows to students to peer review other student's work. In Expertiza, instructors are in charge of courses and within each course, they may create a series of assignments for students to contribute to, either as a member of a team or individually. Students or Teams may submit their assignments to the system through multiple means including file uploads and embedded links. Then assignments may become available to peer review by other members of the course, which provides a way to [[Crowdsourcing|crowd-source]] grading on the work.

== Problem Statement ==
Expertiza previously contained a self-review feature where student's were able to review their own work after submitting their assignments but it was removed due to the inconsistency with the other types of reviews. The task was to re-implement the feature in a way that ensured the overall design would remain intact. The self-review feature should allow students to review their own submission using the same rubric that was provided to other peer reviewers of the assignment. By reviewing their own work, students will be able to assess the artifact through the rubric and may be inspired to make improvements between rounds of peer-reviews.

=== What Needs Done: ===
The following tasks were given to be completed by the team:
* The self-review feature should use the same questionnaire_id as a peer-review. That way developers may call "''assignment.get_review_questionnaire_id(round)''" to get a questionnaire for the self-review.
* A method called "''self_review_response_map?''" should be added to ''review_response_map.rb''. The method will return true if the response_map is a self_response map. In order to determine the result the method shall compare the ''reviewer_id'' and ''reviewee_id'' in the response_map record and if the participant is a member of the reviewee team, true will be returned.
* Student shall do a self-review in the "your work" section. There should be a button called "Review my own work" (or "our own work" if it is a team assignment). When the button is clicked a new review_response_map record is created. Within the map, the reviewer_id is the participant id and the reviewee_id is the team_id.
* If the response_map record for self-review exists, a hyperlink with the text "begin" should appear. A student may click the link and fill in the questionnaire just like how they would for a regular peer review.
* If the self-review response_map exists and there has already been a response, two links entitled "view" and "edit" will appear that will function similarly to peer reviews.
* If the self-review was completed in the last round and the current round uses a different questionnaire (using the ''vary_rubric_by_round'' feature), a link called "update" will appear, which brings students to a new page to fill in the new rubric for the new round.
* In ''grades_controller.view_my_scores,'' self-review responses shall be excluded.
* In ''grades_controller.view_team,'' self-review responses shall be excluded.
* In ''grades_controller.view,'' self-review responses shall be excluded.
* The method called "''add_self_reviewer"'' in ''ReviewMappingController'', shall allow instructors to create self-review response maps. This method needs to be made functional again.
* Automated tests must be created.

== Files Modified in Project ==
The following files were modified in creating the new self-review feature
* ''review_response_map.rb''
* ''review_mapping_controller.rb''
* ''response_controller.rb''
* ''_set_dynamic_review.html.erb''
* ''_main.html.erb''
* ''_general.html.erb''
* ''response.html.erb''
* ''routes.rb''

The following files were created:
* ''self_review_response_map.rb''
* ''_self_review.html.erb''
* ''20160321221146_add_columnselfreviewenabled.rb''

The following test classes were created:
* ''self_review_response_maps.rb''
* ''self_review_response_map_test.rb''

== Walkthrough ==
Below are walkthroughs that will guide users through the new functionality included in the update.

=== Instructor Perspective ===
When creating a new assignment, an instructor will have an option to enable self-reviews. In order to allow for self-reviews to be completed, the instructor must check the box while either creating or editing the assignment.

=== Student Perspective ===
If self-reviews are available on an assignment the following will be available for students to use.

# During the beginning stages of an assignment under "your work" the User Interface will show a label called Self-Review and a button which reads "Review my/our own work" (depending on whether it is an individual or team assignment).
# After selecting "Review my/our own work" the button will change to "Begin" (just like how a peer review works).
# Once the user selects "Begin" they will be taken to a questionnaire to complete. The questionnaire is the same one that a peer reviewer would complete.
# Similarly to a peer review, a user may either "Save" or "Submit" their self-review.
# After a user saves a self-review, "View" and "Edit" links will appear. However, once a user submits their self-review, they will be unable to edit the peer review.
# If there are multiple rounds of submissions and reviews, then in all following rounds an update link will appear to allow for students to update their self-review.
# If late submissions are allowed (via Expertiza "submission allowed" flag) then a user may begin and submit self reviews even in other review stages.
# If a self-review is not submitted throughout the duration of the assignment then "Work yet to be submitted" will be shown.
# Scores from self-reviews will not be considered when calculating grades throughout the assignment.

CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature

2016-03-22T20:21:27Z

Magoff2: Added walkthrough

= CSC/ECE 517 Spring 2016/oss E1600 =
This page will discuss the newly added peer self review feature that was added to the Expertiza project.

== Background ==
Developed by both students and faculty at [[North Carolina State University]], Expertiza is a educational based web application that allows to students to peer review other student's work. In Expertiza, instructors are in charge of courses and within each course, they may create a series of assignments for students to contribute to, either as a member of a team or individually. Students or Teams may submit their assignments to the system through multiple means including file uploads and embedded links. Then assignments may become available to peer review by other members of the course, which provides a way to [[Crowdsourcing|crowd-source]] grading on the work.

== Problem Statement ==
Expertiza previously contained a self-review feature where student's were able to review their own work after submitting their assignments but it was removed due to the inconsistency with the other types of reviews. The task was to re-implement the feature in a way that ensured the overall design would remain intact. The self-review feature should allow students to review their own submission using the same rubric that was provided to other peer reviewers of the assignment. By reviewing their own work, students will be able to assess the artifact through the rubric and may be inspired to make improvements between rounds of peer-reviews.

=== What Needs Done: ===
The following tasks were given to be completed by the team:
* The self-review feature should use the same questionnaire_id as a peer-review. That way developers may call "''assignment.get_review_questionnaire_id(round)''" to get a questionnaire for the self-review.
* A method called "''self_review_response_map?''" should be added to ''review_response_map.rb''. The method will return true if the response_map is a self_response map. In order to determine the result the method shall compare the ''reviewer_id'' and ''reviewee_id'' in the response_map record and if the participant is a member of the reviewee team, true will be returned.
* Student shall do a self-review in the "your work" section. There should be a button called "Review my own work" (or "our own work" if it is a team assignment). When the button is clicked a new review_response_map record is created. Within the map, the reviewer_id is the participant id and the reviewee_id is the team_id.
* If the response_map record for self-review exists, a hyperlink with the text "begin" should appear. A student may click the link and fill in the questionnaire just like how they would for a regular peer review.
* If the self-review response_map exists and there has already been a response, two links entitled "view" and "edit" will appear that will function similarly to peer reviews.
* If the self-review was completed in the last round and the current round uses a different questionnaire (using the ''vary_rubric_by_round'' feature), a link called "update" will appear, which brings students to a new page to fill in the new rubric for the new round.
* In ''grades_controller.view_my_scores,'' self-review responses shall be excluded.
* In ''grades_controller.view_team,'' self-review responses shall be excluded.
* In ''grades_controller.view,'' self-review responses shall be excluded.
* The method called "''add_self_reviewer"'' in ''ReviewMappingController'', shall allow instructors to create self-review response maps. This method needs to be made functional again.
* Automated tests must be created.

== Files Modified in Project ==
The following files were modified in creating the new self-review feature
* ''review_response_map.rb''
* ''review_mapping_controller.rb''
* ''response_controller.rb''
* ''_set_dynamic_review.html.erb''
* ''_main.html.erb''
* ''_general.html.erb''
* ''response.html.erb''
* ''routes.rb''

The following files were created:
* ''self_review_response_map.rb''
* ''_self_review.html.erb''
* ''20160321221146_add_columnselfreviewenabled.rb''

The following test classes were created:
* ''self_review_response_maps.rb''
* ''self_review_response_map_test.rb''

== Walkthrough ==
Below are walkthroughs that will guide users through the new functionality included in the update.

=== Instructor Perspective ===
When creating a new assignment, an instructor will have an option to enable self-reviews. In order to allow for self-reviews to be completed, the instructor must check the box while either creating or editing the assignment.

=== Student Perspective ===
If self-reviews are available on an assignment the following will be available for students to use.

1. During the beginning stages of an assignment under "your work" the User Interface will show a label called Self-Review and a button which reads "Review my/our own work" (depending on whether it is an individual or team assignment).
2. After selecting "Review my/our own work" the button will change to "Begin" (just like how a peer review works).
3. Once the user selects "Begin" they will be taken to a questionnaire to complete. The questionnaire is the same one that a peer reviewer would complete.
4. Similarly to a peer review, a user may either "Save" or "Submit" their self-review.
5. After a user saves a self-review, "View" and "Edit" links will appear. However, once a user submits their self-review, they will be unable to edit the peer review.
6. If there are multiple rounds of submissions and reviews, then in all following rounds an update link will appear to allow for students to update their self-review.
7. If late submissions are allowed (via Expertiza "submission allowed" flag) then a user may begin and submit self reviews even in other review stages.
8. If a self-review is not submitted throughout the duration of the assignment then "Work yet to be submitted" will be shown.
9. Scores from self-reviews will not be considered when calculating grades throughout the assignment.

CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature

2016-03-22T01:58:22Z

Magoff2:

= CSC/ECE 517 Spring 2016/oss E1600 =
This page will discuss the newly added peer self review feature that was added to the Expertiza project.

== Background ==
Developed by both students and faculty at [[North Carolina State University]], Expertiza is a educational based web application that allows to students to peer review other student's work. In Expertiza, instructors are in charge of courses and within each course, they may create a series of assignments for students to contribute to, either as a member of a team or individually. Students or Teams may submit their assignments to the system through multiple means including file uploads and embedded links. Then assignments may become available to peer review by other members of the course, which provides a way to [[Crowdsourcing|crowd-source]] grading on the work.

== Problem Statement ==
Expertiza previously contained a self-review feature where student's were able to review their own work after submitting their assignments but it was removed due to the inconsistency with the other types of reviews. The task was to re-implement the feature in a way that ensured the overall design would remain intact. The self-review feature should allow students to review their own submission using the same rubric that was provided to other peer reviewers of the assignment. By reviewing their own work, students will be able to assess the artifact through the rubric and may be inspired to make improvements between rounds of peer-reviews.

=== What Needs Done: ===
The following tasks were given to be completed by the team:
* The self-review feature should use the same questionnaire_id as a peer-review. That way developers may call "''assignment.get_review_questionnaire_id(round)''" to get a questionnaire for the self-review.
* A method called "''self_review_response_map?''" should be added to ''review_response_map.rb''. The method will return true if the response_map is a self_response map. In order to determine the result the method shall compare the ''reviewer_id'' and ''reviewee_id'' in the response_map record and if the participant is a member of the reviewee team, true will be returned.
* Student shall do a self-review in the "your work" section. There should be a button called "Review my own work" (or "our own work" if it is a team assignment). When the button is clicked a new review_response_map record is created. Within the map, the reviewer_id is the participant id and the reviewee_id is the team_id.
* If the response_map record for self-review exists, a hyperlink with the text "begin" should appear. A student may click the link and fill in the questionnaire just like how they would for a regular peer review.
* If the self-review response_map exists and there has already been a response, two links entitled "view" and "edit" will appear that will function similarly to peer reviews.
* If the self-review was completed in the last round and the current round uses a different questionnaire (using the ''vary_rubric_by_round'' feature), a link called "update" will appear, which brings students to a new page to fill in the new rubric for the new round.
* In ''grades_controller.view_my_scores,'' self-review responses shall be excluded.
* In ''grades_controller.view_team,'' self-review responses shall be excluded.
* In ''grades_controller.view,'' self-review responses shall be excluded.
* The method called "''add_self_reviewer"'' in ''ReviewMappingController'', shall allow instructors to create self-review response maps. This method needs to be made functional again.
* Automated tests must be created.

== Files Modified in Project ==
The following files were modified in creating the new self-review feature
* ''review_response_map.rb''
* ''review_mapping_controller.rb''
* ''response_controller.rb''
* ''_set_dynamic_review.html.erb''
* ''_main.html.erb''
* ''_general.html.erb''
* ''response.html.erb''
* ''routes.rb''

The following files were created:
* ''self_review_response_map.rb''
* ''_self_review.html.erb''
* ''20160321221146_add_columnselfreviewenabled.rb''

The following test classes were created:
* ''self_review_response_maps.rb''
* ''self_review_response_map_test.rb''

CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature

2016-03-22T01:58:05Z

Magoff2:

= CSC/ECE 517 Spring 2016/oss E1600 =
This page will discuss the newly added peer self review feature that was added to the Expertiza project.

== Background ==
Developed by both students and faculty at [[North Carolina State University]], Expertiza is a educational based web application that allows to students to peer review other student's work. In Expertiza, instructors are in charge of courses and within each course, they may create a series of assignments for students to contribute to, either as a member of a team or individually. Students or Teams may submit their assignments to the system through multiple means including file uploads and embedded links. Then assignments may become available to peer review by other members of the course, which provides a way to [[Crowdsourcing|crowd-source]] grading on the work.

== Problem Statement ==
Expertiza previously contained a self-review feature where student's were able to review their own work after submitting their assignments but it was removed due to the inconsistency with the other types of reviews. The task was to re-implement the feature in a way that ensured the overall design would remain intact. The self-review feature should allow students to review their own submission using the same rubric that was provided to other peer reviewers of the assignment. By reviewing their own work, students will be able to assess the artifact through the rubric and may be inspired to make improvements between rounds of peer-reviews.

=== What Needs Done: ===
The following tasks were given to be completed by the team:
* The self-review feature should use the same questionnaire_id as a peer-review. That way developers may call "''assignment.get_review_questionnaire_id(round)''" to get a questionnaire for the self-review.
* A method called "''self_review_response_map?''" should be added to ''review_response_map.rb''. The method will return true if the response_map is a self_response map. In order to determine the result the method shall compare the ''reviewer_id'' and ''reviewee_id'' in the response_map record and if the participant is a member of the reviewee team, true will be returned.
* Student shall do a self-review in the "your work" section. There should be a button called "Review my own work" (or "our own work" if it is a team assignment). When the button is clicked a new review_response_map record is created. Within the map, the reviewer_id is the participant id and the reviewee_id is the team_id.
* If the response_map record for self-review exists, a hyperlink with the text "begin" should appear. A student may click the link and fill in the questionnaire just like how they would for a regular peer review.
* If the self-review response_map exists and there has already been a response, two links entitled "view" and "edit" will appear that will function similarly to peer reviews.
* If the self-review was completed in the last round and the current round uses a different questionnaire (using the ''vary_rubric_by_round'' feature), a link called "update" will appear, which brings students to a new page to fill in the new rubric for the new round.
* In ''grades_controller.view_my_scores,'' self-review responses shall be excluded.
* In ''grades_controller.view_team,'' self-review responses shall be excluded.
* In ''grades_controller.view,'' self-review responses shall be excluded.
* The method called "''add_self_reviewer"'' in ''ReviewMappingController'', shall allow instructors to create self-review response maps. This method needs to be made functional again.
* Automated tests must be created.

== Files Modified in Project ==
The following files were modified in creating the new self-review feature
* ''review_response_map.rb''
* ''review_mapping_controller.rb''
* ''response_controller.rb''
* ''_set_dynamic_review.html.erb''
* ''_main.html.erb''
* ''_general.html.erb''
* ''response.html.erb''
* ''routes.rb''

The following files were created:
* ''self_review_response_map.rb''
* ''_self_review.html.erb''
* ''20160321221146_add_columnselfreviewenabled.rb''

The following test classes were created:
* ''self_review_response_maps.rb''
* ''self_review_response_map_test.rb''

CSC/ECE 517 Spring 2016 / Expertiza Self-Review Feature

2016-03-22T01:57:37Z

Magoff2: Added background, problem statement and files modified

= CSC/ECE 517 Spring 2016/oss E1600 =
This page will discuss the newly added peer self review feature that was added to the Expertiza project.

== Background ==
Developed by both students and faculty at [[North Carolina State University]], Expertiza is a educational based web application that allows to students to peer review other student's work. In Expertiza, instructors are in charge of courses and within each course, they may create a series of assignments for students to contribute to, either as a member of a team or individually. Students or Teams may submit their assignments to the system through multiple means including file uploads and embedded links. Then assignments may become available to peer review by other members of the course, which provides a way to [[Crowdsourcing|crowd-source]] grading on the work.

== Problem Statement ==
Expertiza previously contained a self-review feature where student's were able to review their own work after submitting their assignments but it was removed due to the inconsistency with the other types of reviews. The task was to re-implement the feature in a way that ensured the overall design would remain intact. The self-review feature should allow students to review their own submission using the same rubric that was provided to other peer reviewers of the assignment. By reviewing their own work, students will be able to assess the artifact through the rubric and may be inspired to make improvements between rounds of peer-reviews.

=== What Needs Done: ===
The following tasks were given to be completed by the team:
* The self-review feature should use the same questionnaire_id as a peer-review. That way developers may call "''assignment.get_review_questionnaire_id(round)''" to get a questionnaire for the self-review.
* A method called "''self_review_response_map?''" should be added to ''review_response_map.rb''. The method will return true if the response_map is a self_response map. In order to determine the result the method shall compare the ''reviewer_id'' and ''reviewee_id'' in the response_map record and if the participant is a member of the reviewee team, true will be returned.
* Student shall do a self-review in the "your work" section. There should be a button called "Review my own work" (or "our own work" if it is a team assignment). When the button is clicked a new review_response_map record is created. Within the map, the reviewer_id is the participant id and the reviewee_id is the team_id.
* If the response_map record for self-review exists, a hyperlink with the text "begin" should appear. A student may click the link and fill in the questionnaire just like how they would for a regular peer review.
* If the self-review response_map exists and there has already been a response, two links entitled "view" and "edit" will appear that will function similarly to peer reviews.
* If the self-review was completed in the last round and the current round uses a different questionnaire (using the ''vary_rubric_by_round'' feature), a link called "update" will appear, which brings students to a new page to fill in the new rubric for the new round.
* In ''grades_controller.view_my_scores,'' self-review responses shall be excluded.
* In ''grades_controller.view_team,'' self-review responses shall be excluded.
* In ''grades_controller.view,'' self-review responses shall be excluded.
* The method called "''add_self_reviewer"'' in ''ReviewMappingController'', shall allow instructors to create self-review response maps. This method needs to be made functional again.
* Automated tests must be created.

== Files Modified in Project ==
The following files were modified in creating the new self-review feature
* ''review_response_map.rb''
* ''review_mapping_controller.rb''
* ''response_controller.rb''
* ''_set_dynamic_review.html.erb''
* ''_main.html.erb''
* ''_general.html.erb''
* ''response.html.erb''
* ''routes.rb''

The following files were created:
* ''self_review_response_map.rb''
* ''_self_review.html.erb''
* ''20160321221146_add_columnselfreviewenabled.rb''

The following test classes were created:
* ''self_review_response_maps.rb''
* ''self_review_response_map_test.rb''