Expertiza_Wiki - User contributions [en]

User:Mrohatg2

2015-12-04T23:38:12Z

Zganatr: /* Running the Project */

<h1>E1575 - Share the data in Expertiza to a remote server via PRML format</h1>

== Problem Statement ==
Educational peer-review systems like Expertiza contains a huge volume of data accumulated during the course of its use.
Each peer-review system has a different database design. The relational model is so diverse that, it is often difficult to share the data across different peer-review systems.

In order to migrate a student’s data from one peer-review system to another, one will have to do the following:
#Understand the database design/schema of the source peer-review system
#Understand the database design/schema of the destination peer-review system
#Find the equivalent tables and relations in the destination peer-review system for the source peer-review system
#Retrieve the data from the source peer-review system
#Modify it to match the schema of the destination peer-review system
#Insert the data to the destination peer-review system database.

This is a very tedious job. Moreover, with such a diverse schema it is quite difficult to leverage the power of this large structured data and run any sort of analytics on it.

== Solution ==
One solution to the above mentioned problem is to have a common schema which can capture the essence of all the reviews in a peer-review system to its entirety. Moreover, this schema should not capture any information specific to a particular peer-review system. Once such a schema standard is in place the different peer-review systems can export the data in their database to this new standard and the data can be easily shared across different peer-review systems.
=== PRML ===
Peer Review Markup Language is such a standard schema which can capture information about different reviews to its entirety.

== Scope of the Project ==
The scope of this project is to export the data from the Expertiza database to PRML format.

== Expertiza Design Document ==
[[File:Pg_development.png]]

== Expertiza Database Diagram ==
[[File:PRML.png]]

== Expertiza database schema to PRML database schema map ==
{| class="wikitable"
|-
! Table Name
! Courses
! Course
|-
!Attributes
| id
| CourseId
|-
|
|null
|CourseCIPCode
|-
|
|name
|CourseTitle
|-
|
|info
|CourseDescription
|-
|
|null
|CourseLevelID
|-
|
|created_at
|CourseCreated
|-
|
|null
|CourseStarted
|-
|
|null
|CourseEnded
|-
! Table Name
! Assignments
! Assignment
|-
!Attributes
| id
| AssignmentId
|-
|
|null
|AssignmentCIPCode
|-
|
|name
|AssignmentTitle
|-
|
|spec_location
|AssignmentDescription
|-
|
|course_id
|CourseID
|-

!TABLE NAME
!due_dates, deadline_types
!Task
|-
!ATTRIBUTES
|due_dates.id
|TaskID
|-
|
|due_dates.deadline_type_id
|TaskTypeID
|-
|
|deadline_types.name
|TaskTitle
|-
|
|due_dates.description_url
|TaskDescription
|-
|
|NULL
|TaskOpen
|-
|
|due_dates.due_at
|TaskDue
|-
!TABLE NAME
!questions, questionnaires
!criterion
|-
!ATTRIBUTES
|questions.id
|CriterionID
|-
|
|questions.txt
|CriterionTitle
|-
|
|NULL
|CriterionDescription
|
|-
|
|questions.type
|Type
|-
|
|questionnaires.max_question_score
|MaxLabel
|-
|
|questionnaires.min_question_score
|MinLabel
|-
!TABLE NAME
!question_advices
!Level
|-
!ATTRIBUTES
|id
|LevelID
|-
|
|score
|LevelLabel
|-
|
|advice
|LevelDescription
|-
!TABLE NAME
!questions
!Rubric
|-
!ATTRIBUTES
|
|TaskID
|-
|
|questions.id
|CriterionID
|-
!TABLE NAME
!teams
!Actor
|-
!ATTRIBUTES
|id
|ActorID
|-
|
|type
|
|-
|
|parent_id
|
|-
!TABLE NAME
!participants
!Actor
|-
|
|id
|ActorID
|-
|
|type
|-
|
|parent_id
|-
!
!
!ActorTask
|-
!ATTRIBUTES
|
|ActorID
|-
|
|
|TaskID
|-
|
!teams_users
!Participant
|-
|
|user_id
|ParticipantID
|-
|
|team_id
|
|-
|
|
|AppID
|-
!TABLE NAME
!participants
!Participant
|-
!ATTRIBUTES
|user_id
|ParticipantID
|-
|
|id
|
|-
|
|
|AppID
|-
!TABLE NAME
|
!ActorParticipant
|-
!ATTRIBUTES
|
|ActorID
|-
|
|
|ParticipantID
|-
|
|
|RoleID
|-
!TABLE NAME
|
!Enrollment
|-
!ATTRIBUTES
|
|ParticipantID
|-
|
|
|AppID
|-
|
|
|CourseID
|-
!TABLE NAME
!Teams
!Artifact
|-
!ATTRIBUTES
|
|ActorID
|-
|
|
|TaskID
|-
|
|name
|ArtifactContent
|-
|
|NULL
|ArtifactCharLength
|-
|
|NULL
|ArtifactOpen
|-
|
|NULL
|ArtifactEnd
|-
!TABLE NAME
|
!Item
|-
!ATTRIBUTES
|
|ItemContent
|-
|
|
|ArtifactId
|-
!TABLE NAME
|
!Review
|-
!ATTRIBUTES
|
|AssessorActorID
|-
|
|
|TaskID
|-
|
|
|AssessedArtifactID
|-
|
|
|CritiqueArtifactID
|-
!TABLE NAME
|
!ReviewCriterionLevel
|-
!ATTRIBUTES
|
|AssessorActorID
|-
|
|
|TaskID
|-
|
|
|AssessedArtifactID
|-
|
|
|CriterionID
|-
|
|
|CritiqueArtifactID
|-
|
|
|EvalMode
|-
|
|
|EvalLevelID
|-
|
|
|ValueOrdinal
|-
|
|
|ValueCardinal
|-
|
|
|Comment
|}

== Implementation ==
We have used an Extract, Transform and Load [https://en.wikipedia.org/wiki/Extract,_transform,_load ETL] tool, [http://community.pentaho.com/projects/data-integration/ Pentaho Kettle] to perform the data migration from Expertiza to PRML database.

[[File:diagram.png]]

The Pentaho Kettle tool extracts data from the expertise schema, performs transformation on it and load the data in the PRML format.
The tables are mapped as shown in the schema map above.
The operations performed by the ETL tool:

'''Extraction'''
The data is extracted from the expertise database and brought into the staging area by this operation of the ETL tool. It is the staging area in which all the transformation are done.

'''Transformation'''
Many operations are performed on the data in the staging area so that the expertise schema can be converted to the PRML schema. This is called transformation of the data. An example of transformation is while mapping of participants table in the expertiza database to actors table in the PRML database. Each value of the id field is incremented by 1000 while inserting in the participants table.

'''Loading:'''
The transformed data when moved from the staging area to the PRML database is called as loading. There are three types of loading implemented on the tables depending on the size of the table – initial load,partial loading and full loading.
Initial Loading:The first time the data is loaded from the expertiza database to PRML database, it is the initial load.

Partial Loading: Only the new or updated entries in the expertiza table are transformed and loaded in the corresponding PRML table. This is generally done for table with very large number of entries. Eg: Reviews

Full Loading: All the entries from the expertiza table are transformed and loaded in the corresponding PRML table. This is generally done for tables will less number of entries.
Eg: Courses

Full and partial loading is implemented with the help of timestamps and checksums.

== Testing ==
We have tested our conversion by using a set of sample expertiza data. We run the extract, transform and load methodology on it. Queries are run on the PRML database to check if it gives the same results as the expertiza database.
Though the testing is not through, this is the only way the project can be tested.

==Running the Project==
'''Required Software:'''
*Pentaho’s Data Integration (Kettle).
*MySQL
*JAVA

'''Setup:'''
*Download and Install MySQL and JAVA
*Import to MySQL expertiza database dump file.
*Import to MySQL PRML database dump file.
*Download Pentaho's Data Integration(Kettle) Community Edition (its a copy deployment hence no installation is required).
*Download MySql Connector jar file and copy to <pentaho_root_directory\data-integration\lib>
*Start Spoon.bat if you are using a windows machine or Spoon.sh if you using Linux (pentaho_root_directory\data-integration)
*Download the transformations and jobs attached
*You can open a kettle transformation (.ktr file) using Spoon and run it (Make sure proper MySql DB connections are configured)
*You may also open the kettle job (.kjb file) using spoon and run it (Make sure the path for transformations in the job are correct)

User:Mrohatg2

2015-12-04T23:25:43Z

Zganatr: /* Implementation */

User:Mrohatg2

2015-12-04T22:21:05Z

Zganatr:

<h1>E1575 - Share the data in Expertiza to a remote server via PRML format</h1>

== Problem Statement ==
Educational peer-review systems like Expertiza contains a huge volume of data accumulated during the course of its use.
Each peer-review system has a different database design. The relational model is so diverse that, it is often difficult to share the data across different peer-review systems.

In order to migrate a student’s data from one peer-review system to another, one will have to do the following:
#Understand the database design/schema of the source peer-review system
#Understand the database design/schema of the destination peer-review system
#Find the equivalent tables and relations in the destination peer-review system for the source peer-review system
#Retrieve the data from the source peer-review system
#Modify it to match the schema of the destination peer-review system
#Insert the data to the destination peer-review system database.

This is a very tedious job. Moreover, with such a diverse schema it is quite difficult to leverage the power of this large structured data and run any sort of analytics on it.

== Solution ==
One solution to the above mentioned problem is to have a common schema which can capture the essence of all the reviews in a peer-review system to its entirety. Moreover, this schema should not capture any information specific to a particular peer-review system. Once such a schema standard is in place the different peer-review systems can export the data in their database to this new standard and the data can be easily shared across different peer-review systems.
=== PRML ===
Peer Review Markup Language is such a standard schema which can capture information about different reviews to its entirety.

== Scope of the Project ==
The scope of this project is to export the data from the Expertiza database to PRML format.

== Expertiza Design Document ==
[[File:Pg_development.png]]

== Expertiza Database Diagram ==
[[File:PRML.png]]

== Expertiza database schema to PRML database schema map ==
{| class="wikitable"
|-
! Table Name
! Courses
! Course
|-
!Attributes
| id
| CourseId
|-
|
|null
|CourseCIPCode
|-
|
|name
|CourseTitle
|-
|
|info
|CourseDescription
|-
|
|null
|CourseLevelID
|-
|
|created_at
|CourseCreated
|-
|
|null
|CourseStarted
|-
|
|null
|CourseEnded
|-
! Table Name
! Assignments
! Assignment
|-
!Attributes
| id
| AssignmentId
|-
|
|null
|AssignmentCIPCode
|-
|
|name
|AssignmentTitle
|-
|
|spec_location
|AssignmentDescription
|-
|
|course_id
|CourseID
|-

!TABLE NAME
!due_dates, deadline_types
!Task
|-
!ATTRIBUTES
|due_dates.id
|TaskID
|-
|
|due_dates.deadline_type_id
|TaskTypeID
|-
|
|deadline_types.name
|TaskTitle
|-
|
|due_dates.description_url
|TaskDescription
|-
|
|NULL
|TaskOpen
|-
|
|due_dates.due_at
|TaskDue
|-
!TABLE NAME
!questions, questionnaires
!criterion
|-
!ATTRIBUTES
|questions.id
|CriterionID
|-
|
|questions.txt
|CriterionTitle
|-
|
|NULL
|CriterionDescription
|
|-
|
|questions.type
|Type
|-
|
|questionnaires.max_question_score
|MaxLabel
|-
|
|questionnaires.min_question_score
|MinLabel
|-
!TABLE NAME
!question_advices
!Level
|-
!ATTRIBUTES
|id
|LevelID
|-
|
|score
|LevelLabel
|-
|
|advice
|LevelDescription
|-
!TABLE NAME
!questions
!Rubric
|-
!ATTRIBUTES
|
|TaskID
|-
|
|questions.id
|CriterionID
|-
!TABLE NAME
!teams
!Actor
|-
!ATTRIBUTES
|id
|ActorID
|-
|
|type
|
|-
|
|parent_id
|
|-
!TABLE NAME
!participants
!Actor
|-
|
|id
|ActorID
|-
|
|type
|-
|
|parent_id
|-
!
!
!ActorTask
|-
!ATTRIBUTES
|
|ActorID
|-
|
|
|TaskID
|-
|
!teams_users
!Participant
|-
|
|user_id
|ParticipantID
|-
|
|team_id
|
|-
|
|
|AppID
|-
!TABLE NAME
!participants
!Participant
|-
!ATTRIBUTES
|user_id
|ParticipantID
|-
|
|id
|
|-
|
|
|AppID
|-
!TABLE NAME
|
!ActorParticipant
|-
!ATTRIBUTES
|
|ActorID
|-
|
|
|ParticipantID
|-
|
|
|RoleID
|-
!TABLE NAME
|
!Enrollment
|-
!ATTRIBUTES
|
|ParticipantID
|-
|
|
|AppID
|-
|
|
|CourseID
|-
!TABLE NAME
!Teams
!Artifact
|-
!ATTRIBUTES
|
|ActorID
|-
|
|
|TaskID
|-
|
|name
|ArtifactContent
|-
|
|NULL
|ArtifactCharLength
|-
|
|NULL
|ArtifactOpen
|-
|
|NULL
|ArtifactEnd
|-
!TABLE NAME
|
!Item
|-
!ATTRIBUTES
|
|ItemContent
|-
|
|
|ArtifactId
|-
!TABLE NAME
|
!Review
|-
!ATTRIBUTES
|
|AssessorActorID
|-
|
|
|TaskID
|-
|
|
|AssessedArtifactID
|-
|
|
|CritiqueArtifactID
|-
!TABLE NAME
|
!ReviewCriterionLevel
|-
!ATTRIBUTES
|
|AssessorActorID
|-
|
|
|TaskID
|-
|
|
|AssessedArtifactID
|-
|
|
|CriterionID
|-
|
|
|CritiqueArtifactID
|-
|
|
|EvalMode
|-
|
|
|EvalLevelID
|-
|
|
|ValueOrdinal
|-
|
|
|ValueCardinal
|-
|
|
|Comment
|}

== Implementation ==
We have used an Extract, Transform and Load [https://en.wikipedia.org/wiki/Extract,_transform,_load ETL] tool, [http://community.pentaho.com/projects/data-integration/ Pentaho Kettle] to perform the data migration from Expertiza to PRML database.

[[File:diagram.png]]

The Pentaho Kettle tool extracts data from the expertise schema, performs transformation on it and load the data in the PRML format.
The tables are mapped as shown in the schema map above.
The operations performed by the ETL tool:

'''Extraction'''
The data is extracted from the expertise database and brought into the staging area by this operation of the ETL tool. It is the staging area in which all the transformation are done.

'''Transformation'''
Many operations are performed on the data in the staging area so that the expertise schema can be converted to the PRML schema. This is called transformation of the data.
Some of the transformation performed for the project are:

'''Loading:'''
The transformed data when moved from the staging area to the PRML database is called as loading. There are three types of loading implemented on the tables depending on the size of the table – initial load,partial loading and full loading.
Initial Loading:The first time the data is loaded from the expertiza database to PRML database, it is the initial load.

Partial Loading: Only the new or updated entries in the expertiza table are transformed and loaded in the corresponding PRML table. This is generally done for table with very large number of entries. Eg: Reviews

Full Loading: All the entries from the expertiza table are transformed and loaded in the corresponding PRML table. This is generally done for tables will less number of entries.
Eg: Courses

Full and partial loading is implemented with the help of timestamps and checksums.

== Testing ==
We have tested our conversion by using a set of sample expertiza data. We run the extract, transform and load methodology on it. Queries are run on the PRML database to check if it gives the same results as the expertiza database.
Though the testing is not through, this is the only way the project can be tested.

==Running the Project==
'''Required Software:'''
*Pentaho’s Data Integration (Kettle).
*MySQL
*JAVA

'''Setup:'''
*Download and Install MySQL and JAVA
*Import to MySQL expertiza database dump file.
*Import to MySQL PRML database dump file.
*Download Pentaho's Data Integration(Kettle) Community Edition (its a copy deployment hence no installation is required).
*

User:Mrohatg2

2015-12-04T21:48:29Z

Zganatr: /* Implementation */

<h1>E1575 - Share the data in Expertiza to a remote server via PRML format</h1>

== Problem Statement ==
Educational peer-review systems like Expertiza contains a huge volume of data accumulated during the course of its use.
Each peer-review system has a different database design. The relational model is so diverse that, it is often difficult to share the data across different peer-review systems.

In order to migrate a student’s data from one peer-review system to another, one will have to do the following:
#Understand the database design/schema of the source peer-review system
#Understand the database design/schema of the destination peer-review system
#Find the equivalent tables and relations in the destination peer-review system for the source peer-review system
#Retrieve the data from the source peer-review system
#Modify it to match the schema of the destination peer-review system
#Insert the data to the destination peer-review system database.

This is a very tedious job. Moreover, with such a diverse schema it is quite difficult to leverage the power of this large structured data and run any sort of analytics on it.

== Solution ==
One solution to the above mentioned problem is to have a common schema which can capture the essence of all the reviews in a peer-review system to its entirety. Moreover, this schema should not capture any information specific to a particular peer-review system. Once such a schema standard is in place the different peer-review systems can export the data in their database to this new standard and the data can be easily shared across different peer-review systems.
=== PRML ===
Peer Review Markup Language is such a standard schema which can capture information about different reviews to its entirety.

== Scope of the Project ==
The scope of this project is to export the data from the Expertiza database to PRML format.

== Expertiza Design Document ==
[[File:Pg_development.png]]

== Expertiza Database Diagram ==
[[File:PRML.png]]

== Expertiza database schema to PRML database schema map ==
{| class="wikitable"
|-
! Table Name
! Courses
! Course
|-
!Attributes
| id
| CourseId
|-
|
|null
|CourseCIPCode
|-
|
|name
|CourseTitle
|-
|
|info
|CourseDescription
|-
|
|null
|CourseLevelID
|-
|
|created_at
|CourseCreated
|-
|
|null
|CourseStarted
|-
|
|null
|CourseEnded
|-
! Table Name
! Assignments
! Assignment
|-
!Attributes
| id
| AssignmentId
|-
|
|null
|AssignmentCIPCode
|-
|
|name
|AssignmentTitle
|-
|
|spec_location
|AssignmentDescription
|-
|
|course_id
|CourseID
|-

!TABLE NAME
!due_dates, deadline_types
!Task
|-
!ATTRIBUTES
|due_dates.id
|TaskID
|-
|
|due_dates.deadline_type_id
|TaskTypeID
|-
|
|deadline_types.name
|TaskTitle
|-
|
|due_dates.description_url
|TaskDescription
|-
|
|NULL
|TaskOpen
|-
|
|due_dates.due_at
|TaskDue
|-
!TABLE NAME
!questions, questionnaires
!criterion
|-
!ATTRIBUTES
|questions.id
|CriterionID
|-
|
|questions.txt
|CriterionTitle
|-
|
|NULL
|CriterionDescription
|
|-
|
|questions.type
|Type
|-
|
|questionnaires.max_question_score
|MaxLabel
|-
|
|questionnaires.min_question_score
|MinLabel
|-
!TABLE NAME
!question_advices
!Level
|-
!ATTRIBUTES
|id
|LevelID
|-
|
|score
|LevelLabel
|-
|
|advice
|LevelDescription
|-
!TABLE NAME
!questions
!Rubric
|-
!ATTRIBUTES
|
|TaskID
|-
|
|questions.id
|CriterionID
|-
!TABLE NAME
!teams
!Actor
|-
!ATTRIBUTES
|id
|ActorID
|-
|
|type
|
|-
|
|parent_id
|
|-
!TABLE NAME
!participants
!Actor
|-
|
|id
|ActorID
|-
|
|type
|-
|
|parent_id
|-
!
!
!ActorTask
|-
!ATTRIBUTES
|
|ActorID
|-
|
|
|TaskID
|-
|
!teams_users
!Participant
|-
|
|user_id
|ParticipantID
|-
|
|team_id
|
|-
|
|
|AppID
|-
!TABLE NAME
!participants
!Participant
|-
!ATTRIBUTES
|user_id
|ParticipantID
|-
|
|id
|
|-
|
|
|AppID
|-
!TABLE NAME
|
!ActorParticipant
|-
!ATTRIBUTES
|
|ActorID
|-
|
|
|ParticipantID
|-
|
|
|RoleID
|-
!TABLE NAME
|
!Enrollment
|-
!ATTRIBUTES
|
|ParticipantID
|-
|
|
|AppID
|-
|
|
|CourseID
|-
!TABLE NAME
!Teams
!Artifact
|-
!ATTRIBUTES
|
|ActorID
|-
|
|
|TaskID
|-
|
|name
|ArtifactContent
|-
|
|NULL
|ArtifactCharLength
|-
|
|NULL
|ArtifactOpen
|-
|
|NULL
|ArtifactEnd
|-
!TABLE NAME
|
!Item
|-
!ATTRIBUTES
|
|ItemContent
|-
|
|
|ArtifactId
|-
!TABLE NAME
|
!Review
|-
!ATTRIBUTES
|
|AssessorActorID
|-
|
|
|TaskID
|-
|
|
|AssessedArtifactID
|-
|
|
|CritiqueArtifactID
|-
!TABLE NAME
|
!ReviewCriterionLevel
|-
!ATTRIBUTES
|
|AssessorActorID
|-
|
|
|TaskID
|-
|
|
|AssessedArtifactID
|-
|
|
|CriterionID
|-
|
|
|CritiqueArtifactID
|-
|
|
|EvalMode
|-
|
|
|EvalLevelID
|-
|
|
|ValueOrdinal
|-
|
|
|ValueCardinal
|-
|
|
|Comment
|}

== Implementation ==
We have used an Extract, Transform and Load (https://en.wikipedia.org/wiki/Extract,_transform,_loadETL) tool, [[Pentaho Kettle]] (http://community.pentaho.com/projects/data-integration/) to perform the data migration from Expertiza to PRML database.

[[File:diagram.png]]

The Pentaho Kettle tool extracts data from the expertise schema, performs transformation on it and load the data in the PRML format.
The tables are mapped as shown in the schema map above.
The operations performed by the ETL tool:

'''Extraction'''
The data is extracted from the expertise database and brought into the staging area by this operation of the ETL tool. It is the staging area in which all the transformation are done.

'''Transformation'''
Many operations are performed on the data in the staging area so that the expertise schema can be converted to the PRML schema. This is called transformation of the data.
Some of the transformation performed for the project are:

'''Loading:'''
The transformed data when moved from the staging area to the PRML database is called as loading. There are three types of loading implemented on the tables depending on the size of the table – initial load,partial loading and full loading.
Initial Loading:The first time the data is loaded from the expertiza database to PRML database, it is the initial load.

Partial Loading: Only the new or updated entries in the expertiza table are transformed and loaded in the corresponding PRML table. This is generally done for table with very large number of entries. Eg: Reviews

Full Loading: All the entries from the expertiza table are transformed and loaded in the corresponding PRML table. This is generally done for tables will less number of entries.
Eg: Courses

Full and partial loading is implemented with the help of timestamps and checksums.

== Testing ==
We have tested our conversion by using a set of sample expertiza data. We run the extract, transform and load methodology on it. Queries are run on the PRML database to check if it gives the same results as the expertiza database.
Though the testing is not through, this is the only way the project can be tested.

User:Mrohatg2

2015-12-04T21:45:39Z

Zganatr: /* Implementation */

<h1>E1575 - Share the data in Expertiza to a remote server via PRML format</h1>

== Problem Statement ==
Educational peer-review systems like Expertiza contains a huge volume of data accumulated during the course of its use.
Each peer-review system has a different database design. The relational model is so diverse that, it is often difficult to share the data across different peer-review systems.

In order to migrate a student’s data from one peer-review system to another, one will have to do the following:
#Understand the database design/schema of the source peer-review system
#Understand the database design/schema of the destination peer-review system
#Find the equivalent tables and relations in the destination peer-review system for the source peer-review system
#Retrieve the data from the source peer-review system
#Modify it to match the schema of the destination peer-review system
#Insert the data to the destination peer-review system database.

This is a very tedious job. Moreover, with such a diverse schema it is quite difficult to leverage the power of this large structured data and run any sort of analytics on it.

== Solution ==
One solution to the above mentioned problem is to have a common schema which can capture the essence of all the reviews in a peer-review system to its entirety. Moreover, this schema should not capture any information specific to a particular peer-review system. Once such a schema standard is in place the different peer-review systems can export the data in their database to this new standard and the data can be easily shared across different peer-review systems.
=== PRML ===
Peer Review Markup Language is such a standard schema which can capture information about different reviews to its entirety.

== Scope of the Project ==
The scope of this project is to export the data from the Expertiza database to PRML format.

== Expertiza Design Document ==
[[File:Pg_development.png]]

== Expertiza Database Diagram ==
[[File:PRML.png]]

== Expertiza database schema to PRML database schema map ==
{| class="wikitable"
|-
! Table Name
! Courses
! Course
|-
!Attributes
| id
| CourseId
|-
|
|null
|CourseCIPCode
|-
|
|name
|CourseTitle
|-
|
|info
|CourseDescription
|-
|
|null
|CourseLevelID
|-
|
|created_at
|CourseCreated
|-
|
|null
|CourseStarted
|-
|
|null
|CourseEnded
|-
! Table Name
! Assignments
! Assignment
|-
!Attributes
| id
| AssignmentId
|-
|
|null
|AssignmentCIPCode
|-
|
|name
|AssignmentTitle
|-
|
|spec_location
|AssignmentDescription
|-
|
|course_id
|CourseID
|-

!TABLE NAME
!due_dates, deadline_types
!Task
|-
!ATTRIBUTES
|due_dates.id
|TaskID
|-
|
|due_dates.deadline_type_id
|TaskTypeID
|-
|
|deadline_types.name
|TaskTitle
|-
|
|due_dates.description_url
|TaskDescription
|-
|
|NULL
|TaskOpen
|-
|
|due_dates.due_at
|TaskDue
|-
!TABLE NAME
!questions, questionnaires
!criterion
|-
!ATTRIBUTES
|questions.id
|CriterionID
|-
|
|questions.txt
|CriterionTitle
|-
|
|NULL
|CriterionDescription
|
|-
|
|questions.type
|Type
|-
|
|questionnaires.max_question_score
|MaxLabel
|-
|
|questionnaires.min_question_score
|MinLabel
|-
!TABLE NAME
!question_advices
!Level
|-
!ATTRIBUTES
|id
|LevelID
|-
|
|score
|LevelLabel
|-
|
|advice
|LevelDescription
|-
!TABLE NAME
!questions
!Rubric
|-
!ATTRIBUTES
|
|TaskID
|-
|
|questions.id
|CriterionID
|-
!TABLE NAME
!teams
!Actor
|-
!ATTRIBUTES
|id
|ActorID
|-
|
|type
|
|-
|
|parent_id
|
|-
!TABLE NAME
!participants
!Actor
|-
|
|id
|ActorID
|-
|
|type
|-
|
|parent_id
|-
!
!
!ActorTask
|-
!ATTRIBUTES
|
|ActorID
|-
|
|
|TaskID
|-
|
!teams_users
!Participant
|-
|
|user_id
|ParticipantID
|-
|
|team_id
|
|-
|
|
|AppID
|-
!TABLE NAME
!participants
!Participant
|-
!ATTRIBUTES
|user_id
|ParticipantID
|-
|
|id
|
|-
|
|
|AppID
|-
!TABLE NAME
|
!ActorParticipant
|-
!ATTRIBUTES
|
|ActorID
|-
|
|
|ParticipantID
|-
|
|
|RoleID
|-
!TABLE NAME
|
!Enrollment
|-
!ATTRIBUTES
|
|ParticipantID
|-
|
|
|AppID
|-
|
|
|CourseID
|-
!TABLE NAME
!Teams
!Artifact
|-
!ATTRIBUTES
|
|ActorID
|-
|
|
|TaskID
|-
|
|name
|ArtifactContent
|-
|
|NULL
|ArtifactCharLength
|-
|
|NULL
|ArtifactOpen
|-
|
|NULL
|ArtifactEnd
|-
!TABLE NAME
|
!Item
|-
!ATTRIBUTES
|
|ItemContent
|-
|
|
|ArtifactId
|-
!TABLE NAME
|
!Review
|-
!ATTRIBUTES
|
|AssessorActorID
|-
|
|
|TaskID
|-
|
|
|AssessedArtifactID
|-
|
|
|CritiqueArtifactID
|-
!TABLE NAME
|
!ReviewCriterionLevel
|-
!ATTRIBUTES
|
|AssessorActorID
|-
|
|
|TaskID
|-
|
|
|AssessedArtifactID
|-
|
|
|CriterionID
|-
|
|
|CritiqueArtifactID
|-
|
|
|EvalMode
|-
|
|
|EvalLevelID
|-
|
|
|ValueOrdinal
|-
|
|
|ValueCardinal
|-
|
|
|Comment
|}

== Implementation ==
We have used an Extract, Transform and Load (https://en.wikipedia.org/wiki/Extract,_transform,_loadETL) tool, [[Pentaho Kettle]] (http://community.pentaho.com/projects/data-integration/) to perform the data migration from Expertiza to PRML database.

[[File:diagram.png]]

The Pentaho Kettle tool extracts data from the expertise schema, performs transformation on it and load the data in the PRML format.
The tables are mapped as shown in the schema map above.
The operations performed by the ETL tool:

'''Extraction'''
The data is extracted from the expertise database and brought into the staging area by this operation of the ETL tool. It is the staging area in which all the transformation are done.

'''Transformation'''
Many operations are performed on the data in the staging area so that the expertise schema can be converted to the PRML schema. This is called transformation of the data.
Some of the transformation performed for the project are:

'''Loading:'''
The transformed data when moved from the staging area to the PRML database is called as loading. There are two types of loading implemented on the tables depending on the size of the table – partial loading and full loading.
Partial Loading: Only the new or updated entries in the expertiza table are transformed and loaded in the corresponding PRML table. This is generally done for table with very large number of entries. Eg: Reviews
Full Loading: All the entries from the expertiza table are transformed and loaded in the corresponding PRML table. This is generally done for tables will less number of entries.
Eg: Courses
Full and partial loading is implemented with the help of timestamps.

== Testing ==
We have tested our conversion by using a set of sample expertiza data. We run the extract, transform and load methodology on it. Queries are run on the PRML database to check if it gives the same results as the expertiza database.
Though the testing is not through, this is the only way the project can be tested.

File:Diagram.png

2015-12-04T21:45:04Z

Zganatr: uploaded a new version of "File:Diagram.png"

File:Diagram.png

2015-12-04T21:41:56Z

Zganatr:

User:Mrohatg2

2015-12-04T21:35:47Z

Zganatr:

<h1>E1575 - Share the data in Expertiza to a remote server via PRML format</h1>

== Problem Statement ==
Educational peer-review systems like Expertiza contains a huge volume of data accumulated during the course of its use.
Each peer-review system has a different database design. The relational model is so diverse that, it is often difficult to share the data across different peer-review systems.

In order to migrate a student’s data from one peer-review system to another, one will have to do the following:
#Understand the database design/schema of the source peer-review system
#Understand the database design/schema of the destination peer-review system
#Find the equivalent tables and relations in the destination peer-review system for the source peer-review system
#Retrieve the data from the source peer-review system
#Modify it to match the schema of the destination peer-review system
#Insert the data to the destination peer-review system database.

This is a very tedious job. Moreover, with such a diverse schema it is quite difficult to leverage the power of this large structured data and run any sort of analytics on it.

== Solution ==
One solution to the above mentioned problem is to have a common schema which can capture the essence of all the reviews in a peer-review system to its entirety. Moreover, this schema should not capture any information specific to a particular peer-review system. Once such a schema standard is in place the different peer-review systems can export the data in their database to this new standard and the data can be easily shared across different peer-review systems.
=== PRML ===
Peer Review Markup Language is such a standard schema which can capture information about different reviews to its entirety.

== Scope of the Project ==
The scope of this project is to export the data from the Expertiza database to PRML format.

== Expertiza Design Document ==
[[File:Pg_development.png]]

== Expertiza Database Diagram ==
[[File:PRML.png]]

== Expertiza database schema to PRML database schema map ==
{| class="wikitable"
|-
! Table Name
! Courses
! Course
|-
!Attributes
| id
| CourseId
|-
|
|null
|CourseCIPCode
|-
|
|name
|CourseTitle
|-
|
|info
|CourseDescription
|-
|
|null
|CourseLevelID
|-
|
|created_at
|CourseCreated
|-
|
|null
|CourseStarted
|-
|
|null
|CourseEnded
|-
! Table Name
! Assignments
! Assignment
|-
!Attributes
| id
| AssignmentId
|-
|
|null
|AssignmentCIPCode
|-
|
|name
|AssignmentTitle
|-
|
|spec_location
|AssignmentDescription
|-
|
|course_id
|CourseID
|-

!TABLE NAME
!due_dates, deadline_types
!Task
|-
!ATTRIBUTES
|due_dates.id
|TaskID
|-
|
|due_dates.deadline_type_id
|TaskTypeID
|-
|
|deadline_types.name
|TaskTitle
|-
|
|due_dates.description_url
|TaskDescription
|-
|
|NULL
|TaskOpen
|-
|
|due_dates.due_at
|TaskDue
|-
!TABLE NAME
!questions, questionnaires
!criterion
|-
!ATTRIBUTES
|questions.id
|CriterionID
|-
|
|questions.txt
|CriterionTitle
|-
|
|NULL
|CriterionDescription
|
|-
|
|questions.type
|Type
|-
|
|questionnaires.max_question_score
|MaxLabel
|-
|
|questionnaires.min_question_score
|MinLabel
|-
!TABLE NAME
!question_advices
!Level
|-
!ATTRIBUTES
|id
|LevelID
|-
|
|score
|LevelLabel
|-
|
|advice
|LevelDescription
|-
!TABLE NAME
!questions
!Rubric
|-
!ATTRIBUTES
|
|TaskID
|-
|
|questions.id
|CriterionID
|-
!TABLE NAME
!teams
!Actor
|-
!ATTRIBUTES
|id
|ActorID
|-
|
|type
|
|-
|
|parent_id
|
|-
!TABLE NAME
!participants
!Actor
|-
|
|id
|ActorID
|-
|
|type
|-
|
|parent_id
|-
!
!
!ActorTask
|-
!ATTRIBUTES
|
|ActorID
|-
|
|
|TaskID
|-
|
!teams_users
!Participant
|-
|
|user_id
|ParticipantID
|-
|
|team_id
|
|-
|
|
|AppID
|-
!TABLE NAME
!participants
!Participant
|-
!ATTRIBUTES
|user_id
|ParticipantID
|-
|
|id
|
|-
|
|
|AppID
|-
!TABLE NAME
|
!ActorParticipant
|-
!ATTRIBUTES
|
|ActorID
|-
|
|
|ParticipantID
|-
|
|
|RoleID
|-
!TABLE NAME
|
!Enrollment
|-
!ATTRIBUTES
|
|ParticipantID
|-
|
|
|AppID
|-
|
|
|CourseID
|-
!TABLE NAME
!Teams
!Artifact
|-
!ATTRIBUTES
|
|ActorID
|-
|
|
|TaskID
|-
|
|name
|ArtifactContent
|-
|
|NULL
|ArtifactCharLength
|-
|
|NULL
|ArtifactOpen
|-
|
|NULL
|ArtifactEnd
|-
!TABLE NAME
|
!Item
|-
!ATTRIBUTES
|
|ItemContent
|-
|
|
|ArtifactId
|-
!TABLE NAME
|
!Review
|-
!ATTRIBUTES
|
|AssessorActorID
|-
|
|
|TaskID
|-
|
|
|AssessedArtifactID
|-
|
|
|CritiqueArtifactID
|-
!TABLE NAME
|
!ReviewCriterionLevel
|-
!ATTRIBUTES
|
|AssessorActorID
|-
|
|
|TaskID
|-
|
|
|AssessedArtifactID
|-
|
|
|CriterionID
|-
|
|
|CritiqueArtifactID
|-
|
|
|EvalMode
|-
|
|
|EvalLevelID
|-
|
|
|ValueOrdinal
|-
|
|
|ValueCardinal
|-
|
|
|Comment
|}

== Implementation ==
We have used an Extract, Transform and Load (https://en.wikipedia.org/wiki/Extract,_transform,_loadETL) tool, [[Pentaho Kettle]] (http://community.pentaho.com/projects/data-integration/) to perform the data migration from Expertiza to PRML database.
[[File:diagram.png]]
The Pentaho Kettle tool extracts data from the expertise schema, performs transformation on it and load the data in the PRML format.
The tables are mapped as shown in the schema map above.
The operations performed by the ETL tool:

'''Extraction'''
The data is extracted from the expertise database and brought into the staging area by this operation of the ETL tool. It is the staging area in which all the transformation are done.

'''Transformation'''
Many operations are performed on the data in the staging area so that the expertise schema can be converted to the PRML schema. This is called transformation of the data.
Some of the transformation performed for the project are:

'''Loading:'''
The transformed data when moved from the staging area to the PRML database is called as loading. There are two types of loading implemented on the tables depending on the size of the table – partial loading and full loading.
Partial Loading: Only the new or updated entries in the expertiza table are transformed and loaded in the corresponding PRML table. This is generally done for table with very large number of entries. Eg: Reviews
Full Loading: All the entries from the expertiza table are transformed and loaded in the corresponding PRML table. This is generally done for tables will less number of entries.
Eg: Courses
Full and partial loading is implemented with the help of timestamps.

== Testing ==
We have tested our conversion by using a set of sample expertiza data. We run the extract, transform and load methodology on it. Queries are run on the PRML database to check if it gives the same results as the expertiza database.
Though the testing is not through, this is the only way the project can be tested.

User:Mrohatg2

2015-12-04T21:27:30Z

Zganatr:

<h1>E1575 - Share the data in Expertiza to a remote server via PRML format</h1>

== Problem Statement ==
Educational peer-review systems like Expertiza contains a huge volume of data accumulated during the course of its use.
Each peer-review system has a different database design. The relational model is so diverse that, it is often difficult to share the data across different peer-review systems.

In order to migrate a student’s data from one peer-review system to another, one will have to do the following:
#Understand the database design/schema of the source peer-review system
#Understand the database design/schema of the destination peer-review system
#Find the equivalent tables and relations in the destination peer-review system for the source peer-review system
#Retrieve the data from the source peer-review system
#Modify it to match the schema of the destination peer-review system
#Insert the data to the destination peer-review system database.

This is a very tedious job. Moreover, with such a diverse schema it is quite difficult to leverage the power of this large structured data and run any sort of analytics on it.

== Solution ==
One solution to the above mentioned problem is to have a common schema which can capture the essence of all the reviews in a peer-review system to its entirety. Moreover, this schema should not capture any information specific to a particular peer-review system. Once such a schema standard is in place the different peer-review systems can export the data in their database to this new standard and the data can be easily shared across different peer-review systems.
=== PRML ===
Peer Review Markup Language is such a standard schema which can capture information about different reviews to its entirety.

== Scope of the Project ==
The scope of this project is to export the data from the Expertiza database to PRML format.

== Expertiza Design Document ==
[[File:Pg_development.png]]

== Expertiza Database Diagram ==
[[File:PRML.png]]

== Expertiza database schema to PRML database schema map ==
{| class="wikitable"
|-
! Table Name
! Courses
! Course
|-
!Attributes
| id
| CourseId
|-
|
|null
|CourseCIPCode
|-
|
|name
|CourseTitle
|-
|
|info
|CourseDescription
|-
|
|null
|CourseLevelID
|-
|
|created_at
|CourseCreated
|-
|
|null
|CourseStarted
|-
|
|null
|CourseEnded
|-
! Table Name
! Assignments
! Assignment
|-
!Attributes
| id
| AssignmentId
|-
|
|null
|AssignmentCIPCode
|-
|
|name
|AssignmentTitle
|-
|
|spec_location
|AssignmentDescription
|-
|
|course_id
|CourseID
|-

!TABLE NAME
!due_dates, deadline_types
!Task
|-
!ATTRIBUTES
|due_dates.id
|TaskID
|-
|
|due_dates.deadline_type_id
|TaskTypeID
|-
|
|deadline_types.name
|TaskTitle
|-
|
|due_dates.description_url
|TaskDescription
|-
|
|NULL
|TaskOpen
|-
|
|due_dates.due_at
|TaskDue
|-
!TABLE NAME
!questions, questionnaires
!criterion
|-
!ATTRIBUTES
|questions.id
|CriterionID
|-
|
|questions.txt
|CriterionTitle
|-
|
|NULL
|CriterionDescription
|
|-
|
|questions.type
|Type
|-
|
|questionnaires.max_question_score
|MaxLabel
|-
|
|questionnaires.min_question_score
|MinLabel
|-
!TABLE NAME
!question_advices
!Level
|-
!ATTRIBUTES
|id
|LevelID
|-
|
|score
|LevelLabel
|-
|
|advice
|LevelDescription
|-
!TABLE NAME
!questions
!Rubric
|-
!ATTRIBUTES
|
|TaskID
|-
|
|questions.id
|CriterionID
|-
!TABLE NAME
!teams
!Actor
|-
!ATTRIBUTES
|id
|ActorID
|-
|
|type
|
|-
|
|parent_id
|
|-
!TABLE NAME
!participants
!Actor
|-
|
|id
|ActorID
|-
|
|type
|-
|
|parent_id
|-
!
!
!ActorTask
|-
!ATTRIBUTES
|
|ActorID
|-
|
|
|TaskID
|-
|
!teams_users
!Participant
|-
|
|user_id
|ParticipantID
|-
|
|team_id
|
|-
|
|
|AppID
|-
!TABLE NAME
!participants
!Participant
|-
!ATTRIBUTES
|user_id
|ParticipantID
|-
|
|id
|
|-
|
|
|AppID
|-
!TABLE NAME
|
!ActorParticipant
|-
!ATTRIBUTES
|
|ActorID
|-
|
|
|ParticipantID
|-
|
|
|RoleID
|-
!TABLE NAME
|
!Enrollment
|-
!ATTRIBUTES
|
|ParticipantID
|-
|
|
|AppID
|-
|
|
|CourseID
|-
!TABLE NAME
!Teams
!Artifact
|-
!ATTRIBUTES
|
|ActorID
|-
|
|
|TaskID
|-
|
|name
|ArtifactContent
|-
|
|NULL
|ArtifactCharLength
|-
|
|NULL
|ArtifactOpen
|-
|
|NULL
|ArtifactEnd
|-
!TABLE NAME
|
!Item
|-
!ATTRIBUTES
|
|ItemContent
|-
|
|
|ArtifactId
|-
!TABLE NAME
|
!Review
|-
!ATTRIBUTES
|
|AssessorActorID
|-
|
|
|TaskID
|-
|
|
|AssessedArtifactID
|-
|
|
|CritiqueArtifactID
|-
!TABLE NAME
|
!ReviewCriterionLevel
|-
!ATTRIBUTES
|
|AssessorActorID
|-
|
|
|TaskID
|-
|
|
|AssessedArtifactID
|-
|
|
|CriterionID
|-
|
|
|CritiqueArtifactID
|-
|
|
|EvalMode
|-
|
|
|EvalLevelID
|-
|
|
|ValueOrdinal
|-
|
|
|ValueCardinal
|-
|
|
|Comment
|}

== Implementation ==
We have used an Extract, Transform and Load (https://en.wikipedia.org/wiki/Extract,_transform,_loadETL) tool, [[Pentaho Kettle]] (http://community.pentaho.com/projects/data-integration/) to perform the data migration from Expertiza to PRML database.
[[File:diagram.png]]
The Pentaho Kettle tool extracts data from the expertise schema, performs transformation on it and load the data in the PRML format.
The tables are mapped as shown in the schema map above.
The operations performed by the ETL tool:

'''Extraction'''
The data is extracted from the expertise database and brought into the staging area by this operation of the ETL tool. It is the staging area in which all the transformation are done.

'''Transformation'''
Many operations are performed on the data in the staging area so that the expertise schema can be converted to the PRML schema. This is called transformation of the data.
Some of the transformation performed for the project are:

'''Loading:'''
The transformed data when moved from the staging area to the PRML database is called as loading. There are two types of loading implemented on the tables depending on the size of the table – partial loading and full loading.
Partial Loading: Only the new or updated entries in the expertiza table are transformed and loaded in the corresponding PRML table. This is generally done for table with very large number of entries. Eg: Reviews
Full Loading: All the entries from the expertiza table are transformed and loaded in the corresponding PRML table. This is generally done for tables will less number of entries.
Eg: Courses
Full and partial loading is implemented with the help of timestamps.

User:Mrohatg2

2015-12-04T21:20:16Z

Zganatr: /* Expertiza database schema to PRML database schema map */

User:Mrohatg2

2015-12-04T19:47:28Z

Zganatr: /* Expertiza database schema to PRML database schema map */

User:Mrohatg2

2015-12-04T19:41:33Z

Zganatr: /* Expertiza database schema to PRML database schema map */

User:Mrohatg2

2015-12-04T19:37:30Z

Zganatr:

File:PRML.png

2015-12-04T19:18:02Z

Zganatr: uploaded a new version of "File:PRML.png"

File:PRML.png

2015-12-04T19:17:31Z

Zganatr: uploaded a new version of "File:PRML.png"

File:PRML.png

2015-12-04T19:15:29Z

Zganatr:

CSC/ECE 517 Fall 2015 E1575 Share the data in Expertiza to a remote server via PRML format

2015-12-04T19:11:08Z

Zganatr: Created page with "== Problem Statement == Educational peer-review systems like Expertiza contains a huge volume of data accumulated during the course of its use. Each peer-review system has a dif..."

== Problem Statement ==
Educational peer-review systems like Expertiza contains a huge volume of data accumulated during the course of its use.
Each peer-review system has a different database design. The relational model is so diverse that, it is often difficult to share the data across different peer-review systems.

In order to migrate a student’s data from one peer-review system to another, one will have to do the following:
#Understand the database design/schema of the source peer-review system
#Understand the database design/schema of the destination peer-review system
#Find the equivalent tables and relations in the destination peer-review system for the source peer-review system
#Retrieve the data from the source peer-review system
#Modify it to match the schema of the destination peer-review system
#Insert the data to the destination peer-review system database.

This is a very tedious job. Moreover, with such a diverse schema it is quite difficult to leverage the power of this large structured data and run any sort of analytics on it.

== Solution ==
One solution to the above mentioned problem is to have a common schema which can capture the essence of all the reviews in a peer-review system to its entirety. Moreover, this schema should not capture any information specific to a particular peer-review system. Once such a schema standard is in place the different peer-review systems can export the data in their database to this new standard and the data can be easily shared across different peer-review systems.
=== PRML ===
Peer Review Markup Language is such a standard schema which can capture information about different reviews to its entirety.

== Scope of the Project ==
The scope of this project is to export the data from the Expertiza database to PRML format.

== Expertiza Design Document ==
[[File:Pg_development.png]]

== Expertiza Database Diagram ==
[[File:PRML.png]]

CSC/ECE 517 Fall 2015

2015-12-04T19:10:36Z

Zganatr: /* Final Project Design Document */

==Writing Assignment 2==
*[[CSC/ECE_517_Fall_2015/sample_page]]
*[[CSC/ECE_517_Fall_2015/ossE1558BGJ]]
*[[CSC/ECE 517 Fall 2015/oss/M1502/AAAASS]]
*[[CSC/ECE 517 Fall 2015/oss/M1503/IntegrateXMLParser]]
*[[CSC/ECE_517_Fall_2015/ossE1568BZHXJS]]
*[[CSC/ECE_517_Fall_2015/ossE1572VGA]]
*[[CSC/ECE_517_Fall_2015/oss_E1573_sap]]
*[[CSC/ECE 517 Fall 2015/oss E1559 rrz]]
*[[CSC/ECE 517 Fall 2015/oss E1570 avr]]
*[[CSC/ECE 517 Fall 2015/oss E1556 CHM]]
*[[CSC/ECE 517 Fall 2015/oss M1504 JJD]]
*[[CSC/ECE 517 Fall 2015/oss E1562 APS]]
*[[CSC/ECE 517 Fall 2015/oss M1501 GSN]]
*[[CSC/ECE 517 Fall 2015/oss M1501 GSN]]
*[[CSC/ECE 517 Fall 2015/oss E1550 KMM]]
*[[CSC/ECE 517 Fall 2015/oss E1551 RGS]]
*[[CSC/ECE 517 Fall 2015/oss E1555 GMR]]
*[[CSC/ECE 517 Fall 2015/oss E1552 NFR]]
*[[CSC/ECE 517 Fall 2015/oss E1565 AAJ]]
*[[CSC/ECE 517 Fall 2015/oss E1561 WZL]]
*[[CSC/ECE 517 Fall 2015/oss E1553 AAJ]]
*[[CSC/ECE 517 Fall 2015/oss E1554 AAR]]
*[[CSC/ECE 517 Fall 2015/oss E1569 JNR]]
*[[CSC/ECE 517 Fall 2015/oss E1560 PSV]]
*[[CSC/ECE 517 Fall 2015/oss M1505 MSV]]
*[[CSC/ECE 517 Fall 2015/oss E1557 GXM]]
*[[CSC/ECE 517 Fall 2015/oss E1566 ARB]]
*[[CSC/ECE 517 Fall 2015/oss E1567 APT]]
*[[CSC/ECE 517 Fall 2015/oss E1574 BKS]]
*[[CSC/ECE 517 Fall 2015/ossA1550RAN]]
*[[CSC/ECE 517 Fall 2015/oss E1571]]
*[[CSC/ECE 517 Fall 2015/oss E1563 ASA]]

==Final Project Design Document==
*[[CSC/ECE 517 Fall 2015 E1577 MayYellowRoverJump]]
*[[CSC/ECE 517 Fall 2015 E1586 AnonymousChatBetweenAuthorAndReviewer]]
*[[CSC/ECE 517 Fall 2015 E1580 Text metrics]]
*[[CSC/ECE 517 Fall 2015 E1582 Create integration tests for the instructor interface using capybara and rspec]]
*[[CSC/ECE 517 Fall 2015 E1576 Refactoring submitted content (hyperlinks and files)]]
*[[CSC/ECE 517 Fall 2015 E1590 Integration testing for Team creation]]
*[[CSC/ECE 517 Fall 2015 E1585 Use Ajax for Add Participants, Add TA ,Edit Questionnaires Screens]]
*[[CSC/ECE 517 Fall 2015 E1581 Integration testing for student interface]]
*[[CSC/ECE 517 Fall 2015 E1583 Fix the CSS used for Menu Item]]
*[[CSC/ECE 517 Fall 2015 E1591 Integration testing for peer review]]
*[[CSC/ECE 517 Fall 2015 E1589 Automating production setup and deployment]]
*[[CSC/ECE 517 Fall 2015 M1502 Improve HTTP monitoring devtool support]]
*[[CSC/ECE 517 Fall 2015 M1503 Integrate xml5ever XML parser]]
*[[CSC/ECE 517 Fall 2015 M1504 Implement support for missing XMLHttpRequest APIs]]
*[[CSC/ECE 517 Fall 2015 M1505 Add conformance tests to unicode-bidi and fix conformance bugs]]
*[[CSC/ECE 517 Fall 2015 M1501 Report CSS errors to the devtools, both stored and live]]
*[[CSC/ECE 517 Fall 2015 E1579 Instructor account creation over the web]]
*[[CSC/ECE 517 Fall 2015 A1550 Web Socket Implementation in Apache Ambari]]
*[[CSC/ECE 517 Fall 2015 E1584 Send Feedback to Support]]
*[[CSC/ECE 517 Fall 2015 E1575 Share the data in Expertiza to a remote server via PRML format]]

CSC/ECE 517 Fall 2015/oss E1559 rrz

2015-10-31T21:41:00Z

Zganatr:

== E1559: Refactoring JoinTeamRequestsController and InvitationController classes ==
This page gives a breif description on the expertiza based oss project that aimed at refactoring join_team_request_controller.rb and invitation_controller.rb files so that they follow the DRY principle and Ruby on Rails coding practices.
The VCL image of the project is: http://152.46.17.13:3000/

== Code Refactoring ==
Code refactoring is process of changing the code to make it more maintainable, without changing the functionality of the code. Some of the reasons for performing refactoring are:
* To remove duplicate code.
* To make the code more maintainable.
*To divide functionality of the class

== Introduction to Expertiza ==
Expertiza is a web application where students can submit and review learning objects like code, writings, etc. It gives scope for creation of reusable learning objects. Students submit assignments, which can than graded through peer reviews. The Expertiza project is supported by the National Science Foundation.

== Problem Statement ==
==== Classes involved====
''JoinTeamRequestsController'' and ''InvitationController''

====What the controller does====
'''invitation_controller.rb''' is used by a user to invite other users to join his/her team. It performs validation before creating a request. Following chunk of code checks whether the user is allowed to get the invite or not.
def action_allowed? # user specified only have access to the functionality of the controller
['Student', 'Instructor', 'Teaching Assistant'].include?(current_role_name)
end
Now, invited user can accept or reject the request.
Once the user has accepted the request, he can be seen as a part of the team.

'''join_team_requests_controller.rb''' is used when user decides to join a team.
This is achieved by creating an advertisement for the team.
Once the advertisement is created, it is shown in the Topic Selection section.
The user who wants to join the team can send a "Request" to the members of the team.
The members can then decide whether to send him/her an invite or decline the request.

==== What's wrong with the code ====
The invitation_controller.rb is doing the required task but it is difficult to understand the code, hence it becomes difficult to maintain the code. And the functions in the ''accept'' and ''create'' method can be broken down into separate methods.

In join_team_request_controller.rb has duplicate code in various methods which can be removed by creating a separate method for this common code.

==== What needs to be done ====
'''invitation_controller.rb'''
*Rename to Invitations_Controller.rb, as is not in accordance with current naming convention.
*Add comments explaining what each method does, and comments on how important variables are used as currently there are no comments.
*Refactor create and accept methods. Shorten and clarify them by adding private methods, as create and accept methods currently have a lot of code.
*Change the find_by_sql call(s) to Rails (Active Record) statements.
*Make sure that it can be used by a user with a TA or instructor account, if they are participating in this assignment.
*Change grammatically wrong or awkward flash messages.

'''join_team_requests_controller.rb'''
*Add comments to the code.
*Remove duplicate code, from create and accept methods.
*Decline and destroy method should check for successful operation before returning.
*Change grammatically wrong or awkward flash messages.

== Implementation ==
==== Renamed invitation_controller.rb to invitations_controller.rb====
The controller renaming had to be incorporated in different files of the project. The table contain the file names along with the lines before and after the changes.

{| class="wikitable"
|-
! File Name !! Line no. !! Before !! After
|-
| config/routes.rb ||160 || resources :invitation do || resources :invitations do
|-
| config/routes.rb ||170

|| resources :join_team_requests do
collection do
get :edit
end
end
|| resources :join_team_requests do
collection do
post :decline
get :edit
end
end
|-
| ||
|-
|-
| app/views/join_team_requests/_list_received.html.erb ||33|| <%= form_tag :controller => 'invitation', :action => 'create' do %> ||<%= form_tag :controller => 'invitations', :action => 'create' do %>
|-
|-
| app/views/student_teams/view.html.erb ||151|| {:controller => 'invitation', :action => 'cancel', :inv_id => inv.id, :student_id => @student.id} %></td> ||{:controller => 'invitations', :action => 'cancel', :inv_id => inv.id, :student_id => @student.id} %></td>
|-
| app/views/student_teams/view.html.erb || 193 || {:controller => 'invitation', :action => 'accept', :inv_id => inv.id, :student_id => @student.id, :team_id => @team_id}, ||{:controller => 'invitations', :action => 'accept', :inv_id => inv.id, :student_id => @student.id, :team_id => @team_id},
|-
|app/views/student_teams/view.html.erb || 198 ||{:controller => 'invitation', :action => 'decline', :inv_id => inv.id, :student_id => @student.id} %> ||{:controller => 'invitations', :action => 'decline', :inv_id => inv.id, :student_id => @student.id} %>
|-
|app/views/student_teams/view.html.erb||217||<%= form_tag :controller => 'invitation', :action => 'create' do %>||<%= form_tag :controller => 'invitations', :action => 'create' do %>
|-
|app/controllers/invitations_controller.rb||1||class InvitationController < ApplicationController||class InvitationsController < ApplicationController
|}

==== InvitationController.rb create and accept methods refactored====
{| class = "wikitable"
|-
!Before!!After
|-
|def create
user = User.find_by_name(params[:user][:name].strip)
team = AssignmentTeam.find(params[:team_id])
student = AssignmentParticipant.find(params[:student_id])
return unless current_user_id?(student.user_id)

#check if the invited user is valid
if !user
flash[:note] = "\"#{params[:user][:name].strip}\" does not exist. Please make sure the name entered is correct."
else
participant= AssignmentParticipant.where('user_id =? and parent_id =?', user.id, student.parent_id).first
#check if the user is a participant of the assignment
if !participant
flash[:note] = "\"#{params[:user][:name].strip}\" is not a participant of this assignment."
elsif team.full?
flash[:error] = "Your team already has max members."
else
team_member = TeamsUser.where(['team_id =? and user_id =?', team.id, user.id])
#check if invited user is already in the team
if (team_member.size > 0)
flash[:note] = "\"#{user.name}\" is already a member of team."
else
#check if the invited user is already invited (i.e. awaiting reply)
if Invitation.is_invited?(student.user_id, user.id, student.parent_id)
@invitation = Invitation.new
@invitation.to_id = user.id
@invitation.from_id = student.user_id
@invitation.assignment_id = student.parent_id
@invitation.reply_status = 'W'
@invitation.save
else
flash[:note] = "You have already sent an invitation to \"#{user.name}\"."
end
end
end
end

def accept
@inv = Invitation.find(params[:inv_id])

student = Participant.find(params[:student_id])

assignment_id=@inv.assignment_id
inviter_user_id=@inv.from_id
inviter_participant = AssignmentParticipant.find_by_user_id_and_assignment_id(inviter_user_id,assignment_id)

ready_to_join=false
#check if the inviter's team is still existing, and have available slot to add the invitee
inviter_assignment_team = AssignmentTeam.team(inviter_participant)
if inviter_assignment_team.nil?
flash[:error]= "The team which invited you does not exist any more."
else
if inviter_assignment_team.full?
flash[:error]= "The team which invited you is full now."
else
ready_to_join=true
end
end
||
def create #adds the new invitation to the table
if Invitation.is_invited?(@student.user_id, @user.id, @student.parent_id)
set_invitation(@user.id,@student.user_id,@student.parent_id,'W') #'W states the invitation is waitlisted, still not accepted'
else
flash[:note] = @@messages[:already_invited]
end
update_join_team_request @user,@student
redirect_to view_student_teams_path student_id: @student.id
end

def update_join_team_request(user,student) #update the status in the join_team_request to A
if user && student
participant= AssignmentParticipant.where(['user_id =? and parent_id =?', user.id, student.parent_id]).first
if participant
old_entry = JoinTeamRequest.where(['participant_id =? and team_id =?', participant.id,params[:team_id]]).first
if old_entry
old_entry.update_attribute("status",'A') # 'A' states that the invitation has been accepted
end
end
end
end

def auto_complete_for_user_name # searches the user name in the user table for auto complete
search = params[:user][:name].to_s
User.where(User.arel_table[:name].matches("%#{search}%"))
#@users = User.find_by_sql("select * from users where LOWER(name) LIKE '%"+search+"%'") unless search.blank?
end

def accept # allows accepting of the invitation
@inv = Invitation.find(params[:inv_id])
student = Participant.find(params[:student_id])
assignment_id=@inv.assignment_id
inviter_user_id=@inv.from_id
inviter_participant = AssignmentParticipant.find_by_user_id_and_assignment_id(inviter_user_id,assignment_id)

#check if the inviter's team is still existing, and have available slot to add the invitee
inviter_assignment_team = AssignmentTeam.team(inviter_participant)
if inviter_assignment_team.nil?
flash[:error]= @@messages[:invitation_not_exist]
elsif inviter_assignment_team.full?
flash[:error]= @@messages[:full_team]
else
@inv.reply_status = 'A'
@inv.save

#Remove the users previous team since they are accepting an invite for possibly a new team.
TeamsUser.remove_team(student.user_id, params[:team_id])

#Accept the invite and return boolean on whether the add was successful
add_successful = Invitation.accept_invite(params[:team_id], @inv.from_id, @inv.to_id, student.parent_id)

unless add_successful
flash[:error] = @@messages[:fail_to_add]
end
end

redirect_to view_student_teams_path student_id: params[:student_id]

end

|-
|}

==== InvitationController.rb Change the find_by_sql call(s) to Rails (Active Record) statements.====
{| class="wikitable"
|-
!Before!! After
|-
| @users = User.find_by_sql("select * from users where LOWER(name) LIKE '%"+search+"%'") unless search.blank? ||User.where(User.arel_table[:name].matches("%#{search}%"))
|-
|}

==== InvitationController.rb changed to allow TA and instructor to be a part of a team ====
{|class="wikitable"
|-
!Before !! After
|-
|def action_allowed?
current_role_name.eql?("Student")
end
||
def action_allowed? # user specified only have access to the functionality of the controller
['Student', 'Instructor', 'Teaching Assistant'].include?(current_role_name)
end
|}

==== InvitationController.rb added method for messages and invitation====
{| class =="wikitable"
|-
|private def set_messages(name)
@@messages[:user_not_found] = "\"#{name}\" does not exist. Please make sure entered name is correct."
@@messages[:user_not_participant] = "\"#{name}\" is not a participant of this assignment."
@@messages[:max_members] = "Maximum team limit has been reached."
@@messages[:already_member] = "\"#{name}\" is already a team member."
@@messages[:already_invited] = "You have already sent an invitation to \"#{name}\"."
@@messages[:full_team] = "The team which invited you is full now."
@@messages[:invitation_not_exist]= "The team which invited you does not exist any more."
@@messages[:fail_to_add] = "Something went wrong in the system. Hence failed to add you to the team which invited you. Please try again."
end

private def set_invitation(to_id,from_id,assignment_id,reply_status)
@invitation = Invitation.new
@invitation.to_id = to_id
@invitation.from_id = from_id
@invitation.assignment_id = assignment_id
@invitation.reply_status = reply_status
@invitation.save
end
|}

==== JoinTeamRequestController.rb removed duplicate code====
{| class="wikitable"
|-
! Before !! After
|-
|def index
@join_team_requests = JoinTeamRequest.all
respond_to do |format|
format.html # index.html.erb
format.xml { render :xml => @join_team_requests }
end
||def index
@join_team_request = JoinTeamRequest.all
render_request # index.html.erb
end
|-
| ||
|-
| def show # searches the join team requests for a particular id
@join_team_request = JoinTeamRequest.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.xml { render :xml => @join_team_request }
end
end

def new # create a new join team request entry instance
@join_team_request = JoinTeamRequest.new
respond_to do |format|
format.html # new.html.erb
format.xml { render :xml => @join_team_request }
end
end
||private def render_request
respond_to do |format|
format.html
format.xml { render :xml => @join_team_request }
end
end

def show # searches the join team requests for a particular id
@join_team_request = JoinTeamRequest.find(params[:id])
render_request # show.html.erb
end

def new # create a new join team request entry instance
@join_team_request = JoinTeamRequest.new
render_request # new.html.erb
end
|-
|
|}

==== joinTeamRequestsController.rb - Decline and destroy method should check for successful operation before returning.====
{| class= "wikitable"
!Before!!After
|-
|def decline
@join_team_request = JoinTeamRequest.find(params[:id])
@join_team_request.status = 'D'
@join_team_request.save
redirect_to view_student_teams_path student_id: params[:teams_user_id]
end
||
def decline
@join_team_request = JoinTeamRequest.find(params[:id])
@join_team_request.status = 'D' #'D' stands for decline

if @join_team_request.save
redirect_to view_student_teams_path student_id: params[:teams_user_id], notice: "JoinTeamRequest was successfully declined."
else
redirect_to root_path, notice: "Decline request could not be performed."
end
end
|-
|def destroy
@join_team_request = JoinTeamRequest.find(params[:id])
@join_team_request.destroy

respond_to do |format|
format.html { redirect_to(join_team_requests_url) }
format.xml { head :ok }
end
end
||
def destroy # destroy a join_team_request entry of a particular id
@join_team_request = JoinTeamRequest.find(params[:id])
if @join_team_request.destroy
respond_to do |format|
format.html { redirect_to(join_team_requests_url) }
format.xml { head :ok }
end
else
redirect_to root_path, notice: "JoinTeamRequest could not deleted."
end
end
|}
== References ==
[https://github.com/mandgerohit/expertiza Our Repository]

[https://docs.google.com/document/d/1uWs3zyrupTmrOFuv5IbVWCF4NRvCXqJmg8dZ0wCqgus/edit Document for our project requirement]

[https://github.com/expertiza/expertiza Expertiza Repository]

[http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza wiki page]

[https://github.com/expertiza/expertiza/pull/589 Expertiza pull requests]

CSC/ECE 517 Fall 2015/oss E1559 rrz

2015-10-31T21:36:36Z

Zganatr:

CSC/ECE 517 Fall 2015/oss E1559 rrz

2015-10-31T21:27:06Z

Zganatr:

== E1559: Refactoring JoinTeamRequestsController and InvitationController classes ==
This page gives a breif description on the expertiza based oss project that aimed at refactoring join_team_request_controller.rb and invitation_controller.rb files so that they follow the DRY principle and Ruby on Rails coding practices.

== Code Refactoring ==
Code refactoring is process of changing the code to make it more maintainable, without changing the functionality of the code. Some of the reasons for performing refactoring are:
* To remove duplicate code.
* To make the code more maintainable.
*To divide functionality of the class

== Introduction to Expertiza ==
Expertiza is a web application where students can submit and review learning objects like code, writings, etc. It gives scope for creation of reusable learning objects. Students submit assignments, which can than graded through peer reviews. The Expertiza project is supported by the National Science Foundation.

== Problem Statement ==
==== Classes involved====
''JoinTeamRequestsController'' and ''InvitationController''

====What the controller does====
'''invitation_controller.rb''' is used by a user to invite other users to join his/her team. It performs validation before creating a request. Following chunk of code checks whether the user is allowed to get the invite or not.
def action_allowed? # user specified only have access to the functionality of the controller
['Student', 'Instructor', 'Teaching Assistant'].include?(current_role_name)
end
Now, invited user can accept or reject the request.
Once the user has accepted the request, he can be seen as a part of the team.

'''join_team_requests_controller.rb''' is used when user decides to join a team.
This is achieved by creating an advertisement for the team.
Once the advertisement is created, it is shown in the Topic Selection section.
The user who wants to join the team can send a "Request" to the members of the team.
The members can then decide whether to send him/her an invite or decline the request.

==== What's wrong with the code ====
The invitation_controller.rb is doing the required task but it is difficult to understand the code, hence it becomes difficult to maintain the code. And the functions in the ''accept'' and ''create'' method can be broken down into separate methods.

In join_team_request_controller.rb has duplicate code in various methods which can be removed by creating a separate method for this common code.

==== What needs to be done ====
'''invitation_controller.rb'''
*Rename to Invitations_Controller.rb, as is not in accordance with current naming convention.
*Add comments explaining what each method does, and comments on how important variables are used as currently there are no comments.
*Refactor create and accept methods. Shorten and clarify them by adding private methods, as create and accept methods currently have a lot of code.
*Change the find_by_sql call(s) to Rails (Active Record) statements.
*Make sure that it can be used by a user with a TA or instructor account, if they are participating in this assignment.
*Change grammatically wrong or awkward flash messages.

'''join_team_requests_controller.rb'''
*Add comments to the code.
*Remove duplicate code, from create and accept methods.
*Decline and destroy method should check for successful operation before returning.
*Change grammatically wrong or awkward flash messages.

== Implementation ==
==== Renamed invitation_controller.rb to invitations_controller.rb====
The controller renaming had to be incorporated in different files of the project. The table contain the file names along with the lines before and after the changes.

{| class="wikitable"
|-
! File Name !! Line no. !! Before !! After
|-
| config/routes.rb ||160 || resources :invitation do || resources :invitations do
|-
| config/routes.rb ||170

|| resources :join_team_requests do
collection do
get :edit
end
end
|| resources :join_team_requests do
collection do
post :decline
get :edit
end
end
|-
| ||
|-
|-
| app/views/join_team_requests/_list_received.html.erb ||33|| <%= form_tag :controller => 'invitation', :action => 'create' do %> ||<%= form_tag :controller => 'invitations', :action => 'create' do %>
|-
|-
| app/views/student_teams/view.html.erb ||151|| {:controller => 'invitation', :action => 'cancel', :inv_id => inv.id, :student_id => @student.id} %></td> ||{:controller => 'invitations', :action => 'cancel', :inv_id => inv.id, :student_id => @student.id} %></td>
|-
| app/views/student_teams/view.html.erb || 193 || {:controller => 'invitation', :action => 'accept', :inv_id => inv.id, :student_id => @student.id, :team_id => @team_id}, ||{:controller => 'invitations', :action => 'accept', :inv_id => inv.id, :student_id => @student.id, :team_id => @team_id},
|-
|app/views/student_teams/view.html.erb || 198 ||{:controller => 'invitation', :action => 'decline', :inv_id => inv.id, :student_id => @student.id} %> ||{:controller => 'invitations', :action => 'decline', :inv_id => inv.id, :student_id => @student.id} %>
|-
|app/views/student_teams/view.html.erb||217||<%= form_tag :controller => 'invitation', :action => 'create' do %>||<%= form_tag :controller => 'invitations', :action => 'create' do %>
|-
|app/controllers/invitations_controller.rb||1||class InvitationController < ApplicationController||class InvitationsController < ApplicationController
|}

==== InvitationController.rb create and accept methods refactored====
{| class = "wikitable"
|-
!Before!!After
|-
|def create
user = User.find_by_name(params[:user][:name].strip)
team = AssignmentTeam.find(params[:team_id])
student = AssignmentParticipant.find(params[:student_id])
return unless current_user_id?(student.user_id)

#check if the invited user is valid
if !user
flash[:note] = "\"#{params[:user][:name].strip}\" does not exist. Please make sure the name entered is correct."
else
participant= AssignmentParticipant.where('user_id =? and parent_id =?', user.id, student.parent_id).first
#check if the user is a participant of the assignment
if !participant
flash[:note] = "\"#{params[:user][:name].strip}\" is not a participant of this assignment."
elsif team.full?
flash[:error] = "Your team already has max members."
else
team_member = TeamsUser.where(['team_id =? and user_id =?', team.id, user.id])
#check if invited user is already in the team
if (team_member.size > 0)
flash[:note] = "\"#{user.name}\" is already a member of team."
else
#check if the invited user is already invited (i.e. awaiting reply)
if Invitation.is_invited?(student.user_id, user.id, student.parent_id)
@invitation = Invitation.new
@invitation.to_id = user.id
@invitation.from_id = student.user_id
@invitation.assignment_id = student.parent_id
@invitation.reply_status = 'W'
@invitation.save
else
flash[:note] = "You have already sent an invitation to \"#{user.name}\"."
end
end
end
end

def accept
@inv = Invitation.find(params[:inv_id])

student = Participant.find(params[:student_id])

assignment_id=@inv.assignment_id
inviter_user_id=@inv.from_id
inviter_participant = AssignmentParticipant.find_by_user_id_and_assignment_id(inviter_user_id,assignment_id)

ready_to_join=false
#check if the inviter's team is still existing, and have available slot to add the invitee
inviter_assignment_team = AssignmentTeam.team(inviter_participant)
if inviter_assignment_team.nil?
flash[:error]= "The team which invited you does not exist any more."
else
if inviter_assignment_team.full?
flash[:error]= "The team which invited you is full now."
else
ready_to_join=true
end
end
||
def create #adds the new invitation to the table
if Invitation.is_invited?(@student.user_id, @user.id, @student.parent_id)
set_invitation(@user.id,@student.user_id,@student.parent_id,'W') #'W states the invitation is waitlisted, still not accepted'
else
flash[:note] = @@messages[:already_invited]
end
update_join_team_request @user,@student
redirect_to view_student_teams_path student_id: @student.id
end

def update_join_team_request(user,student) #update the status in the join_team_request to A
if user && student
participant= AssignmentParticipant.where(['user_id =? and parent_id =?', user.id, student.parent_id]).first
if participant
old_entry = JoinTeamRequest.where(['participant_id =? and team_id =?', participant.id,params[:team_id]]).first
if old_entry
old_entry.update_attribute("status",'A') # 'A' states that the invitation has been accepted
end
end
end
end

def auto_complete_for_user_name # searches the user name in the user table for auto complete
search = params[:user][:name].to_s
User.where(User.arel_table[:name].matches("%#{search}%"))
#@users = User.find_by_sql("select * from users where LOWER(name) LIKE '%"+search+"%'") unless search.blank?
end

def accept # allows accepting of the invitation
@inv = Invitation.find(params[:inv_id])
student = Participant.find(params[:student_id])
assignment_id=@inv.assignment_id
inviter_user_id=@inv.from_id
inviter_participant = AssignmentParticipant.find_by_user_id_and_assignment_id(inviter_user_id,assignment_id)

#check if the inviter's team is still existing, and have available slot to add the invitee
inviter_assignment_team = AssignmentTeam.team(inviter_participant)
if inviter_assignment_team.nil?
flash[:error]= @@messages[:invitation_not_exist]
elsif inviter_assignment_team.full?
flash[:error]= @@messages[:full_team]
else
@inv.reply_status = 'A'
@inv.save

#Remove the users previous team since they are accepting an invite for possibly a new team.
TeamsUser.remove_team(student.user_id, params[:team_id])

#Accept the invite and return boolean on whether the add was successful
add_successful = Invitation.accept_invite(params[:team_id], @inv.from_id, @inv.to_id, student.parent_id)

unless add_successful
flash[:error] = @@messages[:fail_to_add]
end
end

redirect_to view_student_teams_path student_id: params[:student_id]

end

|-
|}

==== InvitationController.rb Change the find_by_sql call(s) to Rails (Active Record) statements.====
{| class="wikitable"
|-
!Before!! After
|-
| @users = User.find_by_sql("select * from users where LOWER(name) LIKE '%"+search+"%'") unless search.blank? ||User.where(User.arel_table[:name].matches("%#{search}%"))
|-
|}

==== InvitationController.rb changed to allow TA and instructor to be a part of a team ====
{|class="wikitable"
|-
!Before !! After
|-
|def action_allowed?
current_role_name.eql?("Student")
end
||
def action_allowed? # user specified only have access to the functionality of the controller
['Student', 'Instructor', 'Teaching Assistant'].include?(current_role_name)
end
|}

==== InvitationController.rb added method for messages and invitation====
{| class =="wikitable"
|-
|private def set_messages(name)
@@messages[:user_not_found] = "\"#{name}\" does not exist. Please make sure entered name is correct."
@@messages[:user_not_participant] = "\"#{name}\" is not a participant of this assignment."
@@messages[:max_members] = "Maximum team limit has been reached."
@@messages[:already_member] = "\"#{name}\" is already a team member."
@@messages[:already_invited] = "You have already sent an invitation to \"#{name}\"."
@@messages[:full_team] = "The team which invited you is full now."
@@messages[:invitation_not_exist]= "The team which invited you does not exist any more."
@@messages[:fail_to_add] = "Something went wrong in the system. Hence failed to add you to the team which invited you. Please try again."
end

private def set_invitation(to_id,from_id,assignment_id,reply_status)
@invitation = Invitation.new
@invitation.to_id = to_id
@invitation.from_id = from_id
@invitation.assignment_id = assignment_id
@invitation.reply_status = reply_status
@invitation.save
end
|}

==== JoinTeamRequestController.rb removed duplicate code====
{| class="wikitable"
|-
! Before !! After
|-
|def index
@join_team_requests = JoinTeamRequest.all
respond_to do |format|
format.html # index.html.erb
format.xml { render :xml => @join_team_requests }
end
||def index
@join_team_request = JoinTeamRequest.all
render_request # index.html.erb
end
|-
| ||
|-
| def show # searches the join team requests for a particular id
@join_team_request = JoinTeamRequest.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.xml { render :xml => @join_team_request }
end
end

def new # create a new join team request entry instance
@join_team_request = JoinTeamRequest.new
respond_to do |format|
format.html # new.html.erb
format.xml { render :xml => @join_team_request }
end
end
||private def render_request
respond_to do |format|
format.html
format.xml { render :xml => @join_team_request }
end
end

def show # searches the join team requests for a particular id
@join_team_request = JoinTeamRequest.find(params[:id])
render_request # show.html.erb
end

def new # create a new join team request entry instance
@join_team_request = JoinTeamRequest.new
render_request # new.html.erb
end
|-
|
|}

==== joinTeamRequestsController.rb - Decline and destroy method should check for successful operation before returning.====
{| class= "wikitable"
!Before!!After
|-
|def decline
@join_team_request = JoinTeamRequest.find(params[:id])
@join_team_request.status = 'D'
@join_team_request.save
redirect_to view_student_teams_path student_id: params[:teams_user_id]
end
||
def decline
@join_team_request = JoinTeamRequest.find(params[:id])
@join_team_request.status = 'D' #'D' stands for decline

if @join_team_request.save
redirect_to view_student_teams_path student_id: params[:teams_user_id], notice: "JoinTeamRequest was successfully declined."
else
redirect_to root_path, notice: "Decline request could not be performed."
end
end
|-
|def destroy
@join_team_request = JoinTeamRequest.find(params[:id])
@join_team_request.destroy

respond_to do |format|
format.html { redirect_to(join_team_requests_url) }
format.xml { head :ok }
end
end
||
def destroy # destroy a join_team_request entry of a particular id
@join_team_request = JoinTeamRequest.find(params[:id])
if @join_team_request.destroy
respond_to do |format|
format.html { redirect_to(join_team_requests_url) }
format.xml { head :ok }
end
else
redirect_to root_path, notice: "JoinTeamRequest could not deleted."
end
end
|}
== References ==
[https://github.com/mandgerohit/expertiza Our Repository]

[https://docs.google.com/document/d/1uWs3zyrupTmrOFuv5IbVWCF4NRvCXqJmg8dZ0wCqgus/edit Document for our project requirement]

[https://github.com/expertiza/expertiza Expertiza Repository]

[http://wikis.lib.ncsu.edu/index.php/Expertiza Expertiza wiki page]

[https://github.com/expertiza/expertiza/pulls Expertiza pull requests]

CSC/ECE 517 Fall 2015/oss E1559 rrz

2015-10-31T21:21:23Z

Zganatr:

== E1559: Refactoring JoinTeamRequestsController and InvitationController classes ==
This page gives a breif description on the expertiza based oss project that aimed at refactoring join_team_request_controller.rb and invitation_controller.rb files so that they follow the DRY principle and Ruby on Rails coding practices.

== Code Refactoring ==
Code refactoring is process of changing the code to make it more maintainable, without changing the functionality of the code. Some of the reasons for performing refactoring are:
* To remove duplicate code.
* To make the code more maintainable.
*To divide functionality of the class

== Introduction to Expertiza ==
Expertiza is a web application where students can submit and review learning objects like code, writings, etc. It gives scope for creation of reusable learning objects. Students submit assignments, which can than graded through peer reviews. The Expertiza project is supported by the National Science Foundation.

== Problem Statement ==
==== Classes involved====
''JoinTeamRequestsController'' and ''InvitationController''

====What the controller does====
'''invitation_controller.rb''' is used by a user to invite other users to join his/her team. It performs validation before creating a request. Following chunk of code checks whether the user is allowed to get the invite or not.
def action_allowed? # user specified only have access to the functionality of the controller
['Student', 'Instructor', 'Teaching Assistant'].include?(current_role_name)
end
Now, invited user can accept or reject the request.
Once the user has accepted the request, he can be seen as a part of the team.

'''join_team_requests_controller.rb''' is used when user decides to join a team.
This is achieved by creating an advertisement for the team.
Once the advertisement is created, it is shown in the Topic Selection section.
The user who wants to join the team can send a "Request" to the members of the team.
The members can then decide whether to send him/her an invite or decline the request.

==== What's wrong with the code ====
The invitation_controller.rb is doing the required task but it is difficult to understand the code, hence it becomes difficult to maintain the code. And the functions in the ''accept'' and ''create'' method can be broken down into separate methods.

In join_team_request_controller.rb has duplicate code in various methods which can be removed by creating a separate method for this common code.

==== What needs to be done ====
'''invitation_controller.rb'''
*Rename to Invitations_Controller.rb, as is not in accordance with current naming convention.
*Add comments explaining what each method does, and comments on how important variables are used as currently there are no comments.
*Refactor create and accept methods. Shorten and clarify them by adding private methods, as create and accept methods currently have a lot of code.
*Change the find_by_sql call(s) to Rails (Active Record) statements.
*Make sure that it can be used by a user with a TA or instructor account, if they are participating in this assignment.
*Change grammatically wrong or awkward flash messages.

'''join_team_requests_controller.rb'''
*Add comments to the code.
*Remove duplicate code, from create and accept methods.
*Decline and destroy method should check for successful operation before returning.
*Change grammatically wrong or awkward flash messages.

== Implementation ==
==== Renamed invitation_controller.rb to invitations_controller.rb====
The controller renaming had to be incorporated in different files of the project. The table contain the file names along with the lines before and after the changes.

{| class="wikitable"
|-
! File Name !! Line no. !! Before !! After
|-
| config/routes.rb ||160 || resources :invitation do || resources :invitations do
|-
| config/routes.rb ||170

|| resources :join_team_requests do
collection do
get :edit
end
end
|| resources :join_team_requests do
collection do
post :decline
get :edit
end
end
|-
| ||
|-
|-
| app/views/join_team_requests/_list_received.html.erb ||33|| <%= form_tag :controller => 'invitation', :action => 'create' do %> ||<%= form_tag :controller => 'invitations', :action => 'create' do %>
|-
|-
| app/views/student_teams/view.html.erb ||151|| {:controller => 'invitation', :action => 'cancel', :inv_id => inv.id, :student_id => @student.id} %></td> ||{:controller => 'invitations', :action => 'cancel', :inv_id => inv.id, :student_id => @student.id} %></td>
|-
| app/views/student_teams/view.html.erb || 193 || {:controller => 'invitation', :action => 'accept', :inv_id => inv.id, :student_id => @student.id, :team_id => @team_id}, ||{:controller => 'invitations', :action => 'accept', :inv_id => inv.id, :student_id => @student.id, :team_id => @team_id},
|-
|app/views/student_teams/view.html.erb || 198 ||{:controller => 'invitation', :action => 'decline', :inv_id => inv.id, :student_id => @student.id} %> ||{:controller => 'invitations', :action => 'decline', :inv_id => inv.id, :student_id => @student.id} %>
|-
|app/views/student_teams/view.html.erb||217||<%= form_tag :controller => 'invitation', :action => 'create' do %>||<%= form_tag :controller => 'invitations', :action => 'create' do %>
|-
|app/controllers/invitations_controller.rb||1||class InvitationController < ApplicationController||class InvitationsController < ApplicationController
|}

==== InvitationController.rb create and accept methods refactored====
{| class = "wikitable"
|-
!Before!!After
|-
|def create
user = User.find_by_name(params[:user][:name].strip)
team = AssignmentTeam.find(params[:team_id])
student = AssignmentParticipant.find(params[:student_id])
return unless current_user_id?(student.user_id)

#check if the invited user is valid
if !user
flash[:note] = "\"#{params[:user][:name].strip}\" does not exist. Please make sure the name entered is correct."
else
participant= AssignmentParticipant.where('user_id =? and parent_id =?', user.id, student.parent_id).first
#check if the user is a participant of the assignment
if !participant
flash[:note] = "\"#{params[:user][:name].strip}\" is not a participant of this assignment."
elsif team.full?
flash[:error] = "Your team already has max members."
else
team_member = TeamsUser.where(['team_id =? and user_id =?', team.id, user.id])
#check if invited user is already in the team
if (team_member.size > 0)
flash[:note] = "\"#{user.name}\" is already a member of team."
else
#check if the invited user is already invited (i.e. awaiting reply)
if Invitation.is_invited?(student.user_id, user.id, student.parent_id)
@invitation = Invitation.new
@invitation.to_id = user.id
@invitation.from_id = student.user_id
@invitation.assignment_id = student.parent_id
@invitation.reply_status = 'W'
@invitation.save
else
flash[:note] = "You have already sent an invitation to \"#{user.name}\"."
end
end
end
end

def accept
@inv = Invitation.find(params[:inv_id])

student = Participant.find(params[:student_id])

assignment_id=@inv.assignment_id
inviter_user_id=@inv.from_id
inviter_participant = AssignmentParticipant.find_by_user_id_and_assignment_id(inviter_user_id,assignment_id)

ready_to_join=false
#check if the inviter's team is still existing, and have available slot to add the invitee
inviter_assignment_team = AssignmentTeam.team(inviter_participant)
if inviter_assignment_team.nil?
flash[:error]= "The team which invited you does not exist any more."
else
if inviter_assignment_team.full?
flash[:error]= "The team which invited you is full now."
else
ready_to_join=true
end
end
||
def create #adds the new invitation to the table
if Invitation.is_invited?(@student.user_id, @user.id, @student.parent_id)
set_invitation(@user.id,@student.user_id,@student.parent_id,'W') #'W states the invitation is waitlisted, still not accepted'
else
flash[:note] = @@messages[:already_invited]
end
update_join_team_request @user,@student
redirect_to view_student_teams_path student_id: @student.id
end

def update_join_team_request(user,student) #update the status in the join_team_request to A
if user && student
participant= AssignmentParticipant.where(['user_id =? and parent_id =?', user.id, student.parent_id]).first
if participant
old_entry = JoinTeamRequest.where(['participant_id =? and team_id =?', participant.id,params[:team_id]]).first
if old_entry
old_entry.update_attribute("status",'A') # 'A' states that the invitation has been accepted
end
end
end
end

def auto_complete_for_user_name # searches the user name in the user table for auto complete
search = params[:user][:name].to_s
User.where(User.arel_table[:name].matches("%#{search}%"))
#@users = User.find_by_sql("select * from users where LOWER(name) LIKE '%"+search+"%'") unless search.blank?
end

def accept # allows accepting of the invitation
@inv = Invitation.find(params[:inv_id])
student = Participant.find(params[:student_id])
assignment_id=@inv.assignment_id
inviter_user_id=@inv.from_id
inviter_participant = AssignmentParticipant.find_by_user_id_and_assignment_id(inviter_user_id,assignment_id)

#check if the inviter's team is still existing, and have available slot to add the invitee
inviter_assignment_team = AssignmentTeam.team(inviter_participant)
if inviter_assignment_team.nil?
flash[:error]= @@messages[:invitation_not_exist]
elsif inviter_assignment_team.full?
flash[:error]= @@messages[:full_team]
else
@inv.reply_status = 'A'
@inv.save

#Remove the users previous team since they are accepting an invite for possibly a new team.
TeamsUser.remove_team(student.user_id, params[:team_id])

#Accept the invite and return boolean on whether the add was successful
add_successful = Invitation.accept_invite(params[:team_id], @inv.from_id, @inv.to_id, student.parent_id)

unless add_successful
flash[:error] = @@messages[:fail_to_add]
end
end

redirect_to view_student_teams_path student_id: params[:student_id]

end

|-
|}

==== InvitationController.rb Change the find_by_sql call(s) to Rails (Active Record) statements.====
{| class="wikitable"
|-
!Before!! After
|-
| @users = User.find_by_sql("select * from users where LOWER(name) LIKE '%"+search+"%'") unless search.blank? ||User.where(User.arel_table[:name].matches("%#{search}%"))
|-
|}

==== InvitationController.rb changed to allow TA and instructor to be a part of a team ====
{|class="wikitable"
|-
!Before !! After
|-
|def action_allowed?
current_role_name.eql?("Student")
end
||
def action_allowed? # user specified only have access to the functionality of the controller
['Student', 'Instructor', 'Teaching Assistant'].include?(current_role_name)
end
|}

==== InvitationController.rb added method for messages and invitation====
{| class =="wikitable"
|-
|private def set_messages(name)
@@messages[:user_not_found] = "\"#{name}\" does not exist. Please make sure entered name is correct."
@@messages[:user_not_participant] = "\"#{name}\" is not a participant of this assignment."
@@messages[:max_members] = "Maximum team limit has been reached."
@@messages[:already_member] = "\"#{name}\" is already a team member."
@@messages[:already_invited] = "You have already sent an invitation to \"#{name}\"."
@@messages[:full_team] = "The team which invited you is full now."
@@messages[:invitation_not_exist]= "The team which invited you does not exist any more."
@@messages[:fail_to_add] = "Something went wrong in the system. Hence failed to add you to the team which invited you. Please try again."
end

private def set_invitation(to_id,from_id,assignment_id,reply_status)
@invitation = Invitation.new
@invitation.to_id = to_id
@invitation.from_id = from_id
@invitation.assignment_id = assignment_id
@invitation.reply_status = reply_status
@invitation.save
end
|}

==== JoinTeamRequestController.rb removed duplicate code====
{| class="wikitable"
|-
! Before !! After
|-
|def index
@join_team_requests = JoinTeamRequest.all
respond_to do |format|
format.html # index.html.erb
format.xml { render :xml => @join_team_requests }
end
||def index
@join_team_request = JoinTeamRequest.all
render_request # index.html.erb
end
|-
| ||
|-
| def show # searches the join team requests for a particular id
@join_team_request = JoinTeamRequest.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.xml { render :xml => @join_team_request }
end
end

def new # create a new join team request entry instance
@join_team_request = JoinTeamRequest.new
respond_to do |format|
format.html # new.html.erb
format.xml { render :xml => @join_team_request }
end
end
||private def render_request
respond_to do |format|
format.html
format.xml { render :xml => @join_team_request }
end
end

def show # searches the join team requests for a particular id
@join_team_request = JoinTeamRequest.find(params[:id])
render_request # show.html.erb
end

def new # create a new join team request entry instance
@join_team_request = JoinTeamRequest.new
render_request # new.html.erb
end
|-
|
|}

==== joinTeamRequestsController.rb - Decline and destroy method should check for successful operation before returning.====
{| class= "wikitable"
!Before!!After
|-
|def decline
@join_team_request = JoinTeamRequest.find(params[:id])
@join_team_request.status = 'D'
@join_team_request.save
redirect_to view_student_teams_path student_id: params[:teams_user_id]
end
||
def decline
@join_team_request = JoinTeamRequest.find(params[:id])
@join_team_request.status = 'D' #'D' stands for decline

if @join_team_request.save
redirect_to view_student_teams_path student_id: params[:teams_user_id], notice: "JoinTeamRequest was successfully declined."
else
redirect_to root_path, notice: "Decline request could not be performed."
end
end
|-
|def destroy
@join_team_request = JoinTeamRequest.find(params[:id])
@join_team_request.destroy

respond_to do |format|
format.html { redirect_to(join_team_requests_url) }
format.xml { head :ok }
end
end
||
def destroy # destroy a join_team_request entry of a particular id
@join_team_request = JoinTeamRequest.find(params[:id])
if @join_team_request.destroy
respond_to do |format|
format.html { redirect_to(join_team_requests_url) }
format.xml { head :ok }
end
else
redirect_to root_path, notice: "JoinTeamRequest could not deleted."
end
end
|}
== References ==
[https://github.com/mandgerohit/expertiza Our Repository]

CSC/ECE 517 Fall 2015/oss E1559 rrz

2015-10-31T21:10:38Z

Zganatr:

== E1559: Refactoring JoinTeamRequestsController and InvitationController classes ==
This page gives a breif description on the expertiza based oss project that aimed at refactoring join_team_request_controller.rb and invitation_controller.rb files so that they follow the DRY principle and Ruby on Rails coding practices.

== Code Refactoring ==
Code refactoring is process of changing the code to make it more maintainable, without changing the functionality of the code. Some of the reasons for performing refactoring are:
* To remove duplicate code.
* To make the code more maintainable.
*To divide functionality of the class

== Introduction to Expertiza ==
Expertiza is a web application where students can submit and review learning objects like code, writings, etc. It gives scope for creation of reusable learning objects. Students submit assignments, which can than graded through peer reviews. The Expertiza project is supported by the National Science Foundation.

== Problem Statement ==
==== Classes involved====
''JoinTeamRequestsController'' and ''InvitationController''

====What the controller does====
'''invitation_controller.rb''' is used by a user to invite other users to join his/her team. It performs validation before creating a request. Following chunk of code checks whether the user is allowed to get the invite or not.
def action_allowed? # user specified only have access to the functionality of the controller
['Student', 'Instructor', 'Teaching Assistant'].include?(current_role_name)
end
Now, invited user can accept or reject the request.
Once the user has accepted the request, he can be seen as a part of the team.

'''join_team_requests_controller.rb''' is used when user decides to join a team.
This is achieved by creating an advertisement for the team.
Once the advertisement is created, it is shown in the Topic Selection section.
The user who wants to join the team can send a "Request" to the members of the team.
The members can then decide whether to send him/her an invite or decline the request.

==== What's wrong with the code ====
The invitation_controller.rb is doing the required task but it is difficult to understand the code, hence it becomes difficult to maintain the code. And the functions in the ''accept'' and ''create'' method can be broken down into separate methods.

In join_team_request_controller.rb has duplicate code in various methods which can be removed by creating a separate method for this common code.

==== What needs to be done ====
'''invitation_controller.rb'''
*Rename to Invitations_Controller.rb, as is not in accordance with current naming convention.
*Add comments explaining what each method does, and comments on how important variables are used as currently there are no comments.
*Refactor create and accept methods. Shorten and clarify them by adding private methods, as create and accept methods currently have a lot of code.
*Change the find_by_sql call(s) to Rails (Active Record) statements.
*Make sure that it can be used by a user with a TA or instructor account, if they are participating in this assignment.
*Change grammatically wrong or awkward flash messages.

'''join_team_requests_controller.rb'''
*Add comments to the code.
*Remove duplicate code, from create and accept methods.
*Decline and destroy method should check for successful operation before returning.
*Change grammatically wrong or awkward flash messages.

== Implementation ==
==== Renamed invitation_controller.rb to invitations_controller.rb====
The controller renaming had to be incorporated in different files of the project. The table contain the file names along with the lines before and after the changes.

{| class="wikitable"
|-
! File Name !! Line no. !! Before !! After
|-
| config/routes.rb ||160 || resources :invitation do || resources :invitations do
|-
| config/routes.rb ||170

|| resources :join_team_requests do
collection do
get :edit
end
end
|| resources :join_team_requests do
collection do
post :decline
get :edit
end
end
|-
| ||
|-
|-
| app/views/join_team_requests/_list_received.html.erb ||33|| <%= form_tag :controller => 'invitation', :action => 'create' do %> ||<%= form_tag :controller => 'invitations', :action => 'create' do %>
|-
|-
| app/views/student_teams/view.html.erb ||151|| {:controller => 'invitation', :action => 'cancel', :inv_id => inv.id, :student_id => @student.id} %></td> ||{:controller => 'invitations', :action => 'cancel', :inv_id => inv.id, :student_id => @student.id} %></td>
|-
| app/views/student_teams/view.html.erb || 193 || {:controller => 'invitation', :action => 'accept', :inv_id => inv.id, :student_id => @student.id, :team_id => @team_id}, ||{:controller => 'invitations', :action => 'accept', :inv_id => inv.id, :student_id => @student.id, :team_id => @team_id},
|-
|app/views/student_teams/view.html.erb || 198 ||{:controller => 'invitation', :action => 'decline', :inv_id => inv.id, :student_id => @student.id} %> ||{:controller => 'invitations', :action => 'decline', :inv_id => inv.id, :student_id => @student.id} %>
|-
|app/views/student_teams/view.html.erb||217||<%= form_tag :controller => 'invitation', :action => 'create' do %>||<%= form_tag :controller => 'invitations', :action => 'create' do %>
|-
|app/controllers/invitations_controller.rb||1||class InvitationController < ApplicationController||class InvitationsController < ApplicationController
|}

==== InvitationController.rb create and accept methods refactored====
{| class = "wikitable"
|-
!Before!!After
|-
|def create
user = User.find_by_name(params[:user][:name].strip)
team = AssignmentTeam.find(params[:team_id])
student = AssignmentParticipant.find(params[:student_id])
return unless current_user_id?(student.user_id)

#check if the invited user is valid
if !user
flash[:note] = "\"#{params[:user][:name].strip}\" does not exist. Please make sure the name entered is correct."
else
participant= AssignmentParticipant.where('user_id =? and parent_id =?', user.id, student.parent_id).first
#check if the user is a participant of the assignment
if !participant
flash[:note] = "\"#{params[:user][:name].strip}\" is not a participant of this assignment."
elsif team.full?
flash[:error] = "Your team already has max members."
else
team_member = TeamsUser.where(['team_id =? and user_id =?', team.id, user.id])
#check if invited user is already in the team
if (team_member.size > 0)
flash[:note] = "\"#{user.name}\" is already a member of team."
else
#check if the invited user is already invited (i.e. awaiting reply)
if Invitation.is_invited?(student.user_id, user.id, student.parent_id)
@invitation = Invitation.new
@invitation.to_id = user.id
@invitation.from_id = student.user_id
@invitation.assignment_id = student.parent_id
@invitation.reply_status = 'W'
@invitation.save
else
flash[:note] = "You have already sent an invitation to \"#{user.name}\"."
end
end
end
end

def accept
@inv = Invitation.find(params[:inv_id])

student = Participant.find(params[:student_id])

assignment_id=@inv.assignment_id
inviter_user_id=@inv.from_id
inviter_participant = AssignmentParticipant.find_by_user_id_and_assignment_id(inviter_user_id,assignment_id)

ready_to_join=false
#check if the inviter's team is still existing, and have available slot to add the invitee
inviter_assignment_team = AssignmentTeam.team(inviter_participant)
if inviter_assignment_team.nil?
flash[:error]= "The team which invited you does not exist any more."
else
if inviter_assignment_team.full?
flash[:error]= "The team which invited you is full now."
else
ready_to_join=true
end
end
||
def create #adds the new invitation to the table
if Invitation.is_invited?(@student.user_id, @user.id, @student.parent_id)
set_invitation(@user.id,@student.user_id,@student.parent_id,'W') #'W states the invitation is waitlisted, still not accepted'
else
flash[:note] = @@messages[:already_invited]
end
update_join_team_request @user,@student
redirect_to view_student_teams_path student_id: @student.id
end

def update_join_team_request(user,student) #update the status in the join_team_request to A
if user && student
participant= AssignmentParticipant.where(['user_id =? and parent_id =?', user.id, student.parent_id]).first
if participant
old_entry = JoinTeamRequest.where(['participant_id =? and team_id =?', participant.id,params[:team_id]]).first
if old_entry
old_entry.update_attribute("status",'A') # 'A' states that the invitation has been accepted
end
end
end
end

def auto_complete_for_user_name # searches the user name in the user table for auto complete
search = params[:user][:name].to_s
User.where(User.arel_table[:name].matches("%#{search}%"))
#@users = User.find_by_sql("select * from users where LOWER(name) LIKE '%"+search+"%'") unless search.blank?
end

def accept # allows accepting of the invitation
@inv = Invitation.find(params[:inv_id])
student = Participant.find(params[:student_id])
assignment_id=@inv.assignment_id
inviter_user_id=@inv.from_id
inviter_participant = AssignmentParticipant.find_by_user_id_and_assignment_id(inviter_user_id,assignment_id)

#check if the inviter's team is still existing, and have available slot to add the invitee
inviter_assignment_team = AssignmentTeam.team(inviter_participant)
if inviter_assignment_team.nil?
flash[:error]= @@messages[:invitation_not_exist]
elsif inviter_assignment_team.full?
flash[:error]= @@messages[:full_team]
else
@inv.reply_status = 'A'
@inv.save

#Remove the users previous team since they are accepting an invite for possibly a new team.
TeamsUser.remove_team(student.user_id, params[:team_id])

#Accept the invite and return boolean on whether the add was successful
add_successful = Invitation.accept_invite(params[:team_id], @inv.from_id, @inv.to_id, student.parent_id)

unless add_successful
flash[:error] = @@messages[:fail_to_add]
end
end

redirect_to view_student_teams_path student_id: params[:student_id]

end

|-
|}

==== InvitationController.rb Change the find_by_sql call(s) to Rails (Active Record) statements.====
{| class="wikitable"
|-
!Before!! After
|-
| @users = User.find_by_sql("select * from users where LOWER(name) LIKE '%"+search+"%'") unless search.blank? ||User.where(User.arel_table[:name].matches("%#{search}%"))
|-
|}

==== InvitationController.rb changed to allow TA and instructor to be a part of a team ====
{|class="wikitable"
|-
!Before !! After
|-
|def action_allowed?
current_role_name.eql?("Student")
end
||
def action_allowed? # user specified only have access to the functionality of the controller
['Student', 'Instructor', 'Teaching Assistant'].include?(current_role_name)
end
|}

==== InvitationController.rb added method for messages and invitation====
{| class =="wikitable"
|-
|private def set_messages(name)
@@messages[:user_not_found] = "\"#{name}\" does not exist. Please make sure entered name is correct."
@@messages[:user_not_participant] = "\"#{name}\" is not a participant of this assignment."
@@messages[:max_members] = "Maximum team limit has been reached."
@@messages[:already_member] = "\"#{name}\" is already a team member."
@@messages[:already_invited] = "You have already sent an invitation to \"#{name}\"."
@@messages[:full_team] = "The team which invited you is full now."
@@messages[:invitation_not_exist]= "The team which invited you does not exist any more."
@@messages[:fail_to_add] = "Something went wrong in the system. Hence failed to add you to the team which invited you. Please try again."
end

private def set_invitation(to_id,from_id,assignment_id,reply_status)
@invitation = Invitation.new
@invitation.to_id = to_id
@invitation.from_id = from_id
@invitation.assignment_id = assignment_id
@invitation.reply_status = reply_status
@invitation.save
end
|}

==== JoinTeamRequestController.rb removed duplicate code====
{| class="wikitable"
|-
! Before !! After
|-
|def index
@join_team_requests = JoinTeamRequest.all
respond_to do |format|
format.html # index.html.erb
format.xml { render :xml => @join_team_requests }
end
||def index
@join_team_request = JoinTeamRequest.all
render_request # index.html.erb
end
|-
| ||
|-
| def show # searches the join team requests for a particular id
@join_team_request = JoinTeamRequest.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.xml { render :xml => @join_team_request }
end
end

def new # create a new join team request entry instance
@join_team_request = JoinTeamRequest.new
respond_to do |format|
format.html # new.html.erb
format.xml { render :xml => @join_team_request }
end
end
||private def render_request
respond_to do |format|
format.html
format.xml { render :xml => @join_team_request }
end
end

def show # searches the join team requests for a particular id
@join_team_request = JoinTeamRequest.find(params[:id])
render_request # show.html.erb
end

def new # create a new join team request entry instance
@join_team_request = JoinTeamRequest.new
render_request # new.html.erb
end
|-
|
|}

==== joinTeamRequestsController.rb - Decline and destroy method should check for successful operation before returning.====
{| class= "wikitable"
!Before!!After
|-
|def decline
@join_team_request = JoinTeamRequest.find(params[:id])
@join_team_request.status = 'D'
@join_team_request.save
redirect_to view_student_teams_path student_id: params[:teams_user_id]
end
||
def decline
@join_team_request = JoinTeamRequest.find(params[:id])
@join_team_request.status = 'D' #'D' stands for decline

if @join_team_request.save
redirect_to view_student_teams_path student_id: params[:teams_user_id], notice: "JoinTeamRequest was successfully declined."
else
redirect_to root_path, notice: "Decline request could not be performed."
end
end
|-
|def destroy
@join_team_request = JoinTeamRequest.find(params[:id])
@join_team_request.destroy

respond_to do |format|
format.html { redirect_to(join_team_requests_url) }
format.xml { head :ok }
end
end
||
def destroy # destroy a join_team_request entry of a particular id
@join_team_request = JoinTeamRequest.find(params[:id])
if @join_team_request.destroy
respond_to do |format|
format.html { redirect_to(join_team_requests_url) }
format.xml { head :ok }
end
else
redirect_to root_path, notice: "JoinTeamRequest could not deleted."
end
end
|}

CSC/ECE 517 Fall 2015/oss E1559 rrz

2015-10-31T21:02:06Z

Zganatr:

== E1559: Refactoring JoinTeamRequestsController and InvitationController classes ==
This page gives a breif description on the expertiza based oss project that aimed at refactoring join_team_request_controller.rb and invitation_controller.rb files so that they follow the DRY principle and Ruby on Rails coding practices.

== Code Refactoring ==
Code refactoring is process of changing the code to make it more maintainable, without changing the functionality of the code. Some of the reasons for performing refactoring are:
* To remove duplicate code.
* To make the code more maintainable.
*To divide functionality of the class

== Introduction to Expertiza ==
Expertiza is a web application where students can submit and review learning objects like code, writings, etc. It gives scope for creation of reusable learning objects. Students submit assignments, which can than graded through peer reviews. The Expertiza project is supported by the National Science Foundation.

== Problem Statement ==
==== Classes involved====
''JoinTeamRequestsController'' and ''InvitationController''

====What the controller does====
'''invitation_controller.rb''' is used by a user to invite other users to join his/her team. It performs validation before creating a request. Following chunk of code checks whether the user is allowed to get the invite or not.
def action_allowed? # user specified only have access to the functionality of the controller
['Student', 'Instructor', 'Teaching Assistant'].include?(current_role_name)
end
Now, invited user can accept or reject the request.
Once the user has accepted the request, he can be seen as a part of the team.

'''join_team_requests_controller.rb''' is used when user decides to join a team.
This is achieved by creating an advertisement for the team.
Once the advertisement is created, it is shown in the Topic Selection section.
The user who wants to join the team can send a "Request" to the members of the team.
The members can then decide whether to send him/her an invite or decline the request.

==== What's wrong with the code ====
The invitation_controller.rb is doing the required task but it is difficult to understand the code, hence it becomes difficult to maintain the code. And the functions in the ''accept'' and ''create'' method can be broken down into separate methods.

In join_team_request_controller.rb has duplicate code in various methods which can be removed by creating a separate method for this common code.

==== What needs to be done ====
'''invitation_controller.rb'''
*Rename to Invitations_Controller.rb, as is not in accordance with current naming convention.
*Add comments explaining what each method does, and comments on how important variables are used as currently there are no comments.
*Refactor create and accept methods. Shorten and clarify them by adding private methods, as create and accept methods currently have a lot of code.
*Change the find_by_sql call(s) to Rails (Active Record) statements.
*Make sure that it can be used by a user with a TA or instructor account, if they are participating in this assignment.
*Change grammatically wrong or awkward flash messages.

'''join_team_requests_controller.rb'''
*Add comments to the code.
*Remove duplicate code.
*'''Update create and accept method to share code.'''
*'''Decline and destroy method should check for successful operation before returning.'''
*Change grammatically wrong or awkward flash messages.

== Implementation ==
==== Renamed invitation_controller.rb to invitations_controller.rb====
The controller renaming had to be incorporated in different files of the project. The table contain the file names along with the lines before and after the changes.

{| class="wikitable"
|-
! File Name !! Line no. !! Before !! After
|-
| config/routes.rb ||160 || resources :invitation do || resources :invitations do
|-
| config/routes.rb ||170

|| resources :join_team_requests do
collection do
get :edit
end
end
|| resources :join_team_requests do
collection do
post :decline
get :edit
end
end
|-
| ||
|-
|-
| app/views/join_team_requests/_list_received.html.erb ||33|| <%= form_tag :controller => 'invitation', :action => 'create' do %> ||<%= form_tag :controller => 'invitations', :action => 'create' do %>
|-
|-
| app/views/student_teams/view.html.erb ||151|| {:controller => 'invitation', :action => 'cancel', :inv_id => inv.id, :student_id => @student.id} %></td> ||{:controller => 'invitations', :action => 'cancel', :inv_id => inv.id, :student_id => @student.id} %></td>
|-
| app/views/student_teams/view.html.erb || 193 || {:controller => 'invitation', :action => 'accept', :inv_id => inv.id, :student_id => @student.id, :team_id => @team_id}, ||{:controller => 'invitations', :action => 'accept', :inv_id => inv.id, :student_id => @student.id, :team_id => @team_id},
|-
|app/views/student_teams/view.html.erb || 198 ||{:controller => 'invitation', :action => 'decline', :inv_id => inv.id, :student_id => @student.id} %> ||{:controller => 'invitations', :action => 'decline', :inv_id => inv.id, :student_id => @student.id} %>
|-
|app/views/student_teams/view.html.erb||217||<%= form_tag :controller => 'invitation', :action => 'create' do %>||<%= form_tag :controller => 'invitations', :action => 'create' do %>
|-
|app/controllers/invitations_controller.rb||1||class InvitationController < ApplicationController||class InvitationsController < ApplicationController
|}

==== InvitationController.rb create and accept methods refactored====
{| class = "wikitable"
|-
!Before!!After
|-
|def create
user = User.find_by_name(params[:user][:name].strip)
team = AssignmentTeam.find(params[:team_id])
student = AssignmentParticipant.find(params[:student_id])
return unless current_user_id?(student.user_id)

#check if the invited user is valid
if !user
flash[:note] = "\"#{params[:user][:name].strip}\" does not exist. Please make sure the name entered is correct."
else
participant= AssignmentParticipant.where('user_id =? and parent_id =?', user.id, student.parent_id).first
#check if the user is a participant of the assignment
if !participant
flash[:note] = "\"#{params[:user][:name].strip}\" is not a participant of this assignment."
elsif team.full?
flash[:error] = "Your team already has max members."
else
team_member = TeamsUser.where(['team_id =? and user_id =?', team.id, user.id])
#check if invited user is already in the team
if (team_member.size > 0)
flash[:note] = "\"#{user.name}\" is already a member of team."
else
#check if the invited user is already invited (i.e. awaiting reply)
if Invitation.is_invited?(student.user_id, user.id, student.parent_id)
@invitation = Invitation.new
@invitation.to_id = user.id
@invitation.from_id = student.user_id
@invitation.assignment_id = student.parent_id
@invitation.reply_status = 'W'
@invitation.save
else
flash[:note] = "You have already sent an invitation to \"#{user.name}\"."
end
end
end
end

def accept
@inv = Invitation.find(params[:inv_id])

student = Participant.find(params[:student_id])

assignment_id=@inv.assignment_id
inviter_user_id=@inv.from_id
inviter_participant = AssignmentParticipant.find_by_user_id_and_assignment_id(inviter_user_id,assignment_id)

ready_to_join=false
#check if the inviter's team is still existing, and have available slot to add the invitee
inviter_assignment_team = AssignmentTeam.team(inviter_participant)
if inviter_assignment_team.nil?
flash[:error]= "The team which invited you does not exist any more."
else
if inviter_assignment_team.full?
flash[:error]= "The team which invited you is full now."
else
ready_to_join=true
end
end
||
def create #adds the new invitation to the table
if Invitation.is_invited?(@student.user_id, @user.id, @student.parent_id)
set_invitation(@user.id,@student.user_id,@student.parent_id,'W') #'W states the invitation is waitlisted, still not accepted'
else
flash[:note] = @@messages[:already_invited]
end
update_join_team_request @user,@student
redirect_to view_student_teams_path student_id: @student.id
end

def update_join_team_request(user,student) #update the status in the join_team_request to A
if user && student
participant= AssignmentParticipant.where(['user_id =? and parent_id =?', user.id, student.parent_id]).first
if participant
old_entry = JoinTeamRequest.where(['participant_id =? and team_id =?', participant.id,params[:team_id]]).first
if old_entry
old_entry.update_attribute("status",'A') # 'A' states that the invitation has been accepted
end
end
end
end

def auto_complete_for_user_name # searches the user name in the user table for auto complete
search = params[:user][:name].to_s
User.where(User.arel_table[:name].matches("%#{search}%"))
#@users = User.find_by_sql("select * from users where LOWER(name) LIKE '%"+search+"%'") unless search.blank?
end

def accept # allows accepting of the invitation
@inv = Invitation.find(params[:inv_id])
student = Participant.find(params[:student_id])
assignment_id=@inv.assignment_id
inviter_user_id=@inv.from_id
inviter_participant = AssignmentParticipant.find_by_user_id_and_assignment_id(inviter_user_id,assignment_id)

#check if the inviter's team is still existing, and have available slot to add the invitee
inviter_assignment_team = AssignmentTeam.team(inviter_participant)
if inviter_assignment_team.nil?
flash[:error]= @@messages[:invitation_not_exist]
elsif inviter_assignment_team.full?
flash[:error]= @@messages[:full_team]
else
@inv.reply_status = 'A'
@inv.save

#Remove the users previous team since they are accepting an invite for possibly a new team.
TeamsUser.remove_team(student.user_id, params[:team_id])

#Accept the invite and return boolean on whether the add was successful
add_successful = Invitation.accept_invite(params[:team_id], @inv.from_id, @inv.to_id, student.parent_id)

unless add_successful
flash[:error] = @@messages[:fail_to_add]
end
end

redirect_to view_student_teams_path student_id: params[:student_id]

end

|-
|}

==== InvitationController.rb Change the find_by_sql call(s) to Rails (Active Record) statements.====
{| class="wikitable"
|-
!Before!! After
|-
| @users = User.find_by_sql("select * from users where LOWER(name) LIKE '%"+search+"%'") unless search.blank? ||User.where(User.arel_table[:name].matches("%#{search}%"))
|-
|}

==== InvitationController.rb changed to allow TA and instructor to be a part of a team ====
{|class="wikitable"
|-
!Before !! After
|-
|def action_allowed?
current_role_name.eql?("Student")
end
||
def action_allowed? # user specified only have access to the functionality of the controller
['Student', 'Instructor', 'Teaching Assistant'].include?(current_role_name)
end
|}

==== InvitationController.rb added method for messages and invitation====
{| class =="wikitable"
|-
|private def set_messages(name)
@@messages[:user_not_found] = "\"#{name}\" does not exist. Please make sure entered name is correct."
@@messages[:user_not_participant] = "\"#{name}\" is not a participant of this assignment."
@@messages[:max_members] = "Maximum team limit has been reached."
@@messages[:already_member] = "\"#{name}\" is already a team member."
@@messages[:already_invited] = "You have already sent an invitation to \"#{name}\"."
@@messages[:full_team] = "The team which invited you is full now."
@@messages[:invitation_not_exist]= "The team which invited you does not exist any more."
@@messages[:fail_to_add] = "Something went wrong in the system. Hence failed to add you to the team which invited you. Please try again."
end

private def set_invitation(to_id,from_id,assignment_id,reply_status)
@invitation = Invitation.new
@invitation.to_id = to_id
@invitation.from_id = from_id
@invitation.assignment_id = assignment_id
@invitation.reply_status = reply_status
@invitation.save
end
|}

==== JoinTeamRequestController.rb removed duplicate code====
{| class="wikitable"
|-
! Before !! After
|-
|def index
@join_team_requests = JoinTeamRequest.all
respond_to do |format|
format.html # index.html.erb
format.xml { render :xml => @join_team_requests }
end
||def index
@join_team_request = JoinTeamRequest.all
render_request # index.html.erb
end
|-
| ||
|-
| def show # searches the join team requests for a particular id
@join_team_request = JoinTeamRequest.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.xml { render :xml => @join_team_request }
end
end

def new # create a new join team request entry instance
@join_team_request = JoinTeamRequest.new
respond_to do |format|
format.html # new.html.erb
format.xml { render :xml => @join_team_request }
end
end
||private def render_request
respond_to do |format|
format.html
format.xml { render :xml => @join_team_request }
end
end

def show # searches the join team requests for a particular id
@join_team_request = JoinTeamRequest.find(params[:id])
render_request # show.html.erb
end

def new # create a new join team request entry instance
@join_team_request = JoinTeamRequest.new
render_request # new.html.erb
end
|-
|
|}

CSC/ECE 517 Fall 2015/oss E1559 rrz

2015-10-31T20:56:53Z

Zganatr:

== E1559: Refactoring JoinTeamRequestsController and InvitationController classes ==
This page gives a breif description on the expertiza based oss project that aimed at refactoring join_team_request_controller.rb and invitation_controller.rb files so that they follow the DRY principle and Ruby on Rails coding practices.

== Code Refactoring ==
Code refactoring is process of changing the code to make it more maintainable, without changing the functionality of the code. Some of the reasons for performing refactoring are:
* To remove duplicate code.
* To make the code more maintainable.
*To divide functionality of the class

== Introduction to Expertiza ==
Expertiza is a web application where students can submit and review learning objects like code, writings, etc. It gives scope for creation of reusable learning objects. Students submit assignments, which can than graded through peer reviews. The Expertiza project is supported by the National Science Foundation.

== Problem Statement ==
==== Classes involved====
''JoinTeamRequestsController'' and ''InvitationController''

====What the controller does====
'''invitation_controller.rb''' is used by a user to invite other users to join his/her team. It performs validation before creating a request. Following chunk of code checks whether the user is allowed to get the invite or not.
def action_allowed? # user specified only have access to the functionality of the controller
['Student', 'Instructor', 'Teaching Assistant'].include?(current_role_name)
end
Now, invited user can accept or reject the request.
Once the user has accepted the request, he can be seen as a part of the team.

'''join_team_requests_controller.rb''' is used when user decides to join a team.
This is achieved by creating an advertisement for the team.
Once the advertisement is created, it is shown in the Topic Selection section.
The user who wants to join the team can send a "Request" to the members of the team.
The members can then decide whether to send him/her an invite or decline the request.

==== What's wrong with the code ====
The invitation_controller.rb is doing the required task but it is difficult to understand the code, hence it becomes difficult to maintain the code. And the functions in the ''accept'' and ''create'' method can be broken down into separate methods.

In join_team_request_controller.rb has duplicate code in various methods which can be removed by creating a separate method for this common code.

==== What needs to be done ====
'''invitation_controller.rb'''
*Rename to Invitations_Controller.rb, as is not in accordance with current naming convention.
*Add comments explaining what each method does, and comments on how important variables are used as currently there are no comments.
*Refactor create and accept methods. Shorten and clarify them by adding private methods, as create and accept methods currently have a lot of code.
*Change the find_by_sql call(s) to Rails (Active Record) statements.
*Make sure that it can be used by a user with a TA or instructor account, if they are participating in this assignment.
*Change grammatically wrong or awkward flash messages.

'''join_team_requests_controller.rb'''
*Add comments to the code.
*Remove duplicate code.
*'''Update create and accept method to share code.'''
*'''Decline and destroy method should check for successful operation before returning.'''
*Change grammatically wrong or awkward flash messages.

== Implementation ==
==== Renamed invitation_controller.rb to invitations_controller.rb====
The controller renaming had to be incorporated in different files of the project. The table contain the file names along with the lines before and after the changes.

{| class="wikitable"
|-
! File Name !! Line no. !! Before !! After
|-
| config/routes.rb ||160 || resources :invitation do || resources :invitations do
|-
| config/routes.rb ||170

|| resources :join_team_requests do
collection do
get :edit
end
end
|| resources :join_team_requests do
collection do
post :decline
get :edit
end
end
|-
| ||
|-
|-
| app/views/join_team_requests/_list_received.html.erb ||33|| <%= form_tag :controller => 'invitation', :action => 'create' do %> ||<%= form_tag :controller => 'invitations', :action => 'create' do %>
|-
|-
| app/views/student_teams/view.html.erb ||151|| {:controller => 'invitation', :action => 'cancel', :inv_id => inv.id, :student_id => @student.id} %></td> ||{:controller => 'invitations', :action => 'cancel', :inv_id => inv.id, :student_id => @student.id} %></td>
|-
| app/views/student_teams/view.html.erb || 193 || {:controller => 'invitation', :action => 'accept', :inv_id => inv.id, :student_id => @student.id, :team_id => @team_id}, ||{:controller => 'invitations', :action => 'accept', :inv_id => inv.id, :student_id => @student.id, :team_id => @team_id},
|-
|app/views/student_teams/view.html.erb || 198 ||{:controller => 'invitation', :action => 'decline', :inv_id => inv.id, :student_id => @student.id} %> ||{:controller => 'invitations', :action => 'decline', :inv_id => inv.id, :student_id => @student.id} %>
|-
|app/views/student_teams/view.html.erb||217||<%= form_tag :controller => 'invitation', :action => 'create' do %>||<%= form_tag :controller => 'invitations', :action => 'create' do %>
|-
|app/controllers/invitations_controller.rb||1||class InvitationController < ApplicationController||class InvitationsController < ApplicationController
|}

==== InvitationController.rb create and accept methods refactored====
{| class = "wikitable"
|-
!Before!!After
|-
|def create
user = User.find_by_name(params[:user][:name].strip)
team = AssignmentTeam.find(params[:team_id])
student = AssignmentParticipant.find(params[:student_id])
return unless current_user_id?(student.user_id)

#check if the invited user is valid
if !user
flash[:note] = "\"#{params[:user][:name].strip}\" does not exist. Please make sure the name entered is correct."
else
participant= AssignmentParticipant.where('user_id =? and parent_id =?', user.id, student.parent_id).first
#check if the user is a participant of the assignment
if !participant
flash[:note] = "\"#{params[:user][:name].strip}\" is not a participant of this assignment."
elsif team.full?
flash[:error] = "Your team already has max members."
else
team_member = TeamsUser.where(['team_id =? and user_id =?', team.id, user.id])
#check if invited user is already in the team
if (team_member.size > 0)
flash[:note] = "\"#{user.name}\" is already a member of team."
else
#check if the invited user is already invited (i.e. awaiting reply)
if Invitation.is_invited?(student.user_id, user.id, student.parent_id)
@invitation = Invitation.new
@invitation.to_id = user.id
@invitation.from_id = student.user_id
@invitation.assignment_id = student.parent_id
@invitation.reply_status = 'W'
@invitation.save
else
flash[:note] = "You have already sent an invitation to \"#{user.name}\"."
end
end
end
end

def accept
@inv = Invitation.find(params[:inv_id])

student = Participant.find(params[:student_id])

assignment_id=@inv.assignment_id
inviter_user_id=@inv.from_id
inviter_participant = AssignmentParticipant.find_by_user_id_and_assignment_id(inviter_user_id,assignment_id)

ready_to_join=false
#check if the inviter's team is still existing, and have available slot to add the invitee
inviter_assignment_team = AssignmentTeam.team(inviter_participant)
if inviter_assignment_team.nil?
flash[:error]= "The team which invited you does not exist any more."
else
if inviter_assignment_team.full?
flash[:error]= "The team which invited you is full now."
else
ready_to_join=true
end
end
||
def create #adds the new invitation to the table
if Invitation.is_invited?(@student.user_id, @user.id, @student.parent_id)
set_invitation(@user.id,@student.user_id,@student.parent_id,'W') #'W states the invitation is waitlisted, still not accepted'
else
flash[:note] = @@messages[:already_invited]
end
update_join_team_request @user,@student
redirect_to view_student_teams_path student_id: @student.id
end

def update_join_team_request(user,student) #update the status in the join_team_request to A
if user && student
participant= AssignmentParticipant.where(['user_id =? and parent_id =?', user.id, student.parent_id]).first
if participant
old_entry = JoinTeamRequest.where(['participant_id =? and team_id =?', participant.id,params[:team_id]]).first
if old_entry
old_entry.update_attribute("status",'A') # 'A' states that the invitation has been accepted
end
end
end
end

def auto_complete_for_user_name # searches the user name in the user table for auto complete
search = params[:user][:name].to_s
User.where(User.arel_table[:name].matches("%#{search}%"))
#@users = User.find_by_sql("select * from users where LOWER(name) LIKE '%"+search+"%'") unless search.blank?
end

def accept # allows accepting of the invitation
@inv = Invitation.find(params[:inv_id])
student = Participant.find(params[:student_id])
assignment_id=@inv.assignment_id
inviter_user_id=@inv.from_id
inviter_participant = AssignmentParticipant.find_by_user_id_and_assignment_id(inviter_user_id,assignment_id)

#check if the inviter's team is still existing, and have available slot to add the invitee
inviter_assignment_team = AssignmentTeam.team(inviter_participant)
if inviter_assignment_team.nil?
flash[:error]= @@messages[:invitation_not_exist]
elsif inviter_assignment_team.full?
flash[:error]= @@messages[:full_team]
else
@inv.reply_status = 'A'
@inv.save

#Remove the users previous team since they are accepting an invite for possibly a new team.
TeamsUser.remove_team(student.user_id, params[:team_id])

#Accept the invite and return boolean on whether the add was successful
add_successful = Invitation.accept_invite(params[:team_id], @inv.from_id, @inv.to_id, student.parent_id)

unless add_successful
flash[:error] = @@messages[:fail_to_add]
end
end

redirect_to view_student_teams_path student_id: params[:student_id]

end

|-
|}

==== InvitationController.rb Change the find_by_sql call(s) to Rails (Active Record) statements.====
{| class="wikitable"
|-
!Before!! After
|-
| @users = User.find_by_sql("select * from users where LOWER(name) LIKE '%"+search+"%'") unless search.blank? ||User.where(User.arel_table[:name].matches("%#{search}%"))
|-
|}

==== InvitationController.rb changed to allow TA and instructor to be a part of a team ====
{|class="wikitable"
|-
!Before !! After
|-
|def action_allowed?
current_role_name.eql?("Student")
end
||
def action_allowed? # user specified only have access to the functionality of the controller
['Student', 'Instructor', 'Teaching Assistant'].include?(current_role_name)
end
|}

==== JoinTeamRequestController.rb removed duplicate code====
{| class="wikitable"
|-
! Before !! After
|-
|def index
@join_team_requests = JoinTeamRequest.all
respond_to do |format|
format.html # index.html.erb
format.xml { render :xml => @join_team_requests }
end
||def index
@join_team_request = JoinTeamRequest.all
render_request # index.html.erb
end
|-
| ||
|-
| def show # searches the join team requests for a particular id
@join_team_request = JoinTeamRequest.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.xml { render :xml => @join_team_request }
end
end

def new # create a new join team request entry instance
@join_team_request = JoinTeamRequest.new
respond_to do |format|
format.html # new.html.erb
format.xml { render :xml => @join_team_request }
end
end
||private def render_request
respond_to do |format|
format.html
format.xml { render :xml => @join_team_request }
end
end

def show # searches the join team requests for a particular id
@join_team_request = JoinTeamRequest.find(params[:id])
render_request # show.html.erb
end

def new # create a new join team request entry instance
@join_team_request = JoinTeamRequest.new
render_request # new.html.erb
end
|-
|
|}

CSC/ECE 517 Fall 2015/oss E1559 rrz

2015-10-31T20:56:10Z

Zganatr:

== E1559: Refactoring JoinTeamRequestsController and InvitationController classes ==
This page gives a breif description on the expertiza based oss project that aimed at refactoring join_team_request_controller.rb and invitation_controller.rb files so that they follow the DRY principle and Ruby on Rails coding practices.

== Code Refactoring ==
Code refactoring is process of changing the code to make it more maintainable, without changing the functionality of the code. Some of the reasons for performing refactoring are:
* To remove duplicate code.
* To make the code more maintainable.
*To divide functionality of the class

== Introduction to Expertiza ==
Expertiza is a web application where students can submit and review learning objects like code, writings, etc. It gives scope for creation of reusable learning objects. Students submit assignments, which can than graded through peer reviews. The Expertiza project is supported by the National Science Foundation.

== Problem Statement ==
==== Classes involved====
''JoinTeamRequestsController'' and ''InvitationController''

====What the controller does====
'''invitation_controller.rb''' is used by a user to invite other users to join his/her team. It performs validation before creating a request. Following chunk of code checks whether the user is allowed to get the invite or not.
def action_allowed? # user specified only have access to the functionality of the controller
['Student', 'Instructor', 'Teaching Assistant'].include?(current_role_name)
end
Now, invited user can accept or reject the request.
Once the user has accepted the request, he can be seen as a part of the team.

'''join_team_requests_controller.rb''' is used when user decides to join a team.
This is achieved by creating an advertisement for the team.
Once the advertisement is created, it is shown in the Topic Selection section.
The user who wants to join the team can send a "Request" to the members of the team.
The members can then decide whether to send him/her an invite or decline the request.

==== What's wrong with the code ====
The invitation_controller.rb is doing the required task but it is difficult to understand the code, hence it becomes difficult to maintain the code. And the functions in the ''accept'' and ''create'' method can be broken down into separate methods.

In join_team_request_controller.rb has duplicate code in various methods which can be removed by creating a separate method for this common code.

==== What needs to be done ====
'''invitation_controller.rb'''
*Rename to Invitations_Controller.rb, as is not in accordance with current naming convention.
*Add comments explaining what each method does, and comments on how important variables are used as currently there are no comments.
*Refactor create and accept methods. Shorten and clarify them by adding private methods, as create and accept methods currently have a lot of code.
*'''Change the find_by_sql call(s) to Rails (Active Record) statements.'''
*'''Make sure that it can be used by a user with a TA or instructor account, if they are participating in this assignment.'''
*Change grammatically wrong or awkward flash messages.

'''join_team_requests_controller.rb'''
*Add comments to the code.
*Remove duplicate code.
*'''Update create and accept method to share code.'''
*'''Decline and destroy method should check for successful operation before returning.'''
*Change grammatically wrong or awkward flash messages.

== Implementation ==
==== Renamed invitation_controller.rb to invitations_controller.rb====
The controller renaming had to be incorporated in different files of the project. The table contain the file names along with the lines before and after the changes.

{| class="wikitable"
|-
! File Name !! Line no. !! Before !! After
|-
| config/routes.rb ||160 || resources :invitation do || resources :invitations do
|-
| config/routes.rb ||170

|| resources :join_team_requests do
collection do
get :edit
end
end
|| resources :join_team_requests do
collection do
post :decline
get :edit
end
end
|-
| ||
|-
|-
| app/views/join_team_requests/_list_received.html.erb ||33|| <%= form_tag :controller => 'invitation', :action => 'create' do %> ||<%= form_tag :controller => 'invitations', :action => 'create' do %>
|-
|-
| app/views/student_teams/view.html.erb ||151|| {:controller => 'invitation', :action => 'cancel', :inv_id => inv.id, :student_id => @student.id} %></td> ||{:controller => 'invitations', :action => 'cancel', :inv_id => inv.id, :student_id => @student.id} %></td>
|-
| app/views/student_teams/view.html.erb || 193 || {:controller => 'invitation', :action => 'accept', :inv_id => inv.id, :student_id => @student.id, :team_id => @team_id}, ||{:controller => 'invitations', :action => 'accept', :inv_id => inv.id, :student_id => @student.id, :team_id => @team_id},
|-
|app/views/student_teams/view.html.erb || 198 ||{:controller => 'invitation', :action => 'decline', :inv_id => inv.id, :student_id => @student.id} %> ||{:controller => 'invitations', :action => 'decline', :inv_id => inv.id, :student_id => @student.id} %>
|-
|app/views/student_teams/view.html.erb||217||<%= form_tag :controller => 'invitation', :action => 'create' do %>||<%= form_tag :controller => 'invitations', :action => 'create' do %>
|-
|app/controllers/invitations_controller.rb||1||class InvitationController < ApplicationController||class InvitationsController < ApplicationController
|}

==== InvitationController.rb create and accept methods refactored====
{| class = "wikitable"
|-
!Before!!After
|-
|def create
user = User.find_by_name(params[:user][:name].strip)
team = AssignmentTeam.find(params[:team_id])
student = AssignmentParticipant.find(params[:student_id])
return unless current_user_id?(student.user_id)

#check if the invited user is valid
if !user
flash[:note] = "\"#{params[:user][:name].strip}\" does not exist. Please make sure the name entered is correct."
else
participant= AssignmentParticipant.where('user_id =? and parent_id =?', user.id, student.parent_id).first
#check if the user is a participant of the assignment
if !participant
flash[:note] = "\"#{params[:user][:name].strip}\" is not a participant of this assignment."
elsif team.full?
flash[:error] = "Your team already has max members."
else
team_member = TeamsUser.where(['team_id =? and user_id =?', team.id, user.id])
#check if invited user is already in the team
if (team_member.size > 0)
flash[:note] = "\"#{user.name}\" is already a member of team."
else
#check if the invited user is already invited (i.e. awaiting reply)
if Invitation.is_invited?(student.user_id, user.id, student.parent_id)
@invitation = Invitation.new
@invitation.to_id = user.id
@invitation.from_id = student.user_id
@invitation.assignment_id = student.parent_id
@invitation.reply_status = 'W'
@invitation.save
else
flash[:note] = "You have already sent an invitation to \"#{user.name}\"."
end
end
end
end

def accept
@inv = Invitation.find(params[:inv_id])

student = Participant.find(params[:student_id])

assignment_id=@inv.assignment_id
inviter_user_id=@inv.from_id
inviter_participant = AssignmentParticipant.find_by_user_id_and_assignment_id(inviter_user_id,assignment_id)

ready_to_join=false
#check if the inviter's team is still existing, and have available slot to add the invitee
inviter_assignment_team = AssignmentTeam.team(inviter_participant)
if inviter_assignment_team.nil?
flash[:error]= "The team which invited you does not exist any more."
else
if inviter_assignment_team.full?
flash[:error]= "The team which invited you is full now."
else
ready_to_join=true
end
end
||
def create #adds the new invitation to the table
if Invitation.is_invited?(@student.user_id, @user.id, @student.parent_id)
set_invitation(@user.id,@student.user_id,@student.parent_id,'W') #'W states the invitation is waitlisted, still not accepted'
else
flash[:note] = @@messages[:already_invited]
end
update_join_team_request @user,@student
redirect_to view_student_teams_path student_id: @student.id
end

def update_join_team_request(user,student) #update the status in the join_team_request to A
if user && student
participant= AssignmentParticipant.where(['user_id =? and parent_id =?', user.id, student.parent_id]).first
if participant
old_entry = JoinTeamRequest.where(['participant_id =? and team_id =?', participant.id,params[:team_id]]).first
if old_entry
old_entry.update_attribute("status",'A') # 'A' states that the invitation has been accepted
end
end
end
end

def auto_complete_for_user_name # searches the user name in the user table for auto complete
search = params[:user][:name].to_s
User.where(User.arel_table[:name].matches("%#{search}%"))
#@users = User.find_by_sql("select * from users where LOWER(name) LIKE '%"+search+"%'") unless search.blank?
end

def accept # allows accepting of the invitation
@inv = Invitation.find(params[:inv_id])
student = Participant.find(params[:student_id])
assignment_id=@inv.assignment_id
inviter_user_id=@inv.from_id
inviter_participant = AssignmentParticipant.find_by_user_id_and_assignment_id(inviter_user_id,assignment_id)

#check if the inviter's team is still existing, and have available slot to add the invitee
inviter_assignment_team = AssignmentTeam.team(inviter_participant)
if inviter_assignment_team.nil?
flash[:error]= @@messages[:invitation_not_exist]
elsif inviter_assignment_team.full?
flash[:error]= @@messages[:full_team]
else
@inv.reply_status = 'A'
@inv.save

#Remove the users previous team since they are accepting an invite for possibly a new team.
TeamsUser.remove_team(student.user_id, params[:team_id])

#Accept the invite and return boolean on whether the add was successful
add_successful = Invitation.accept_invite(params[:team_id], @inv.from_id, @inv.to_id, student.parent_id)

unless add_successful
flash[:error] = @@messages[:fail_to_add]
end
end

redirect_to view_student_teams_path student_id: params[:student_id]

end

|-
|}

==== InvitationController.rb Change the find_by_sql call(s) to Rails (Active Record) statements.====
{| class="wikitable"
|-
!Before!! After
|-
| @users = User.find_by_sql("select * from users where LOWER(name) LIKE '%"+search+"%'") unless search.blank? ||User.where(User.arel_table[:name].matches("%#{search}%"))
|-
|}

==== InvitationController.rb changed to allow TA and instructor to be a part of a team ====
{|class="wikitable"
|-
!Before !! After
|-
|def action_allowed?
current_role_name.eql?("Student")
end
||
def action_allowed? # user specified only have access to the functionality of the controller
['Student', 'Instructor', 'Teaching Assistant'].include?(current_role_name)
end
|}

==== JoinTeamRequestController.rb removed duplicate code====
{| class="wikitable"
|-
! Before !! After
|-
|def index
@join_team_requests = JoinTeamRequest.all
respond_to do |format|
format.html # index.html.erb
format.xml { render :xml => @join_team_requests }
end
||def index
@join_team_request = JoinTeamRequest.all
render_request # index.html.erb
end
|-
| ||
|-
| def show # searches the join team requests for a particular id
@join_team_request = JoinTeamRequest.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.xml { render :xml => @join_team_request }
end
end

def new # create a new join team request entry instance
@join_team_request = JoinTeamRequest.new
respond_to do |format|
format.html # new.html.erb
format.xml { render :xml => @join_team_request }
end
end
||private def render_request
respond_to do |format|
format.html
format.xml { render :xml => @join_team_request }
end
end

def show # searches the join team requests for a particular id
@join_team_request = JoinTeamRequest.find(params[:id])
render_request # show.html.erb
end

def new # create a new join team request entry instance
@join_team_request = JoinTeamRequest.new
render_request # new.html.erb
end
|-
|
|}

CSC/ECE 517 Fall 2015/oss E1559 rrz

2015-10-31T20:42:33Z

Zganatr:

== E1559: Refactoring JoinTeamRequestsController and InvitationController classes ==
This page gives a breif description on the expertiza based oss project that aimed at refactoring join_team_request_controller.rb and invitation_controller.rb files so that they follow the DRY principle and Ruby on Rails coding practices.

== Code Refactoring ==
Code refactoring is process of changing the code to make it more maintainable, without changing the functionality of the code. Some of the reasons for performing refactoring are:
* To remove duplicate code.
* To make the code more maintainable.
*To divide functionality of the class

== Introduction to Expertiza ==
Expertiza is a web application where students can submit and review learning objects like code, writings, etc. It gives scope for creation of reusable learning objects. Students submit assignments, which can than graded through peer reviews. The Expertiza project is supported by the National Science Foundation.

== Problem Statement ==
==== Classes involved====
''JoinTeamRequestsController'' and ''InvitationController''

====What the controller does====
'''invitation_controller.rb''' is used by a user to invite other users to join his/her team. It performs validation before creating a request. Following chunk of code checks whether the user is allowed to get the invite or not.
def action_allowed? # user specified only have access to the functionality of the controller
['Student', 'Instructor', 'Teaching Assistant'].include?(current_role_name)
end
Now, invited user can accept or reject the request.
Once the user has accepted the request, he can be seen as a part of the team.

'''join_team_requests_controller.rb''' is used when user decides to join a team.
This is achieved by creating an advertisement for the team.
Once the advertisement is created, it is shown in the Topic Selection section.
The user who wants to join the team can send a "Request" to the members of the team.
The members can then decide whether to send him/her an invite or decline the request.

==== What's wrong with the code ====
The invitation_controller.rb is doing the required task but it is difficult to understand the code, hence it becomes difficult to maintain the code. And the functions in the ''accept'' and ''create'' method can be broken down into separate methods.

In join_team_request_controller.rb has duplicate code in various methods which can be removed by creating a separate method for this common code.

==== What needs to be done ====
'''invitation_controller.rb'''
*Rename to Invitations_Controller.rb, as is not in accordance with current naming convention.
*Add comments explaining what each method does, and comments on how important variables are used as currently there are no comments.
*Refactor create and accept methods. Shorten and clarify them by adding private methods, as create and accept methods currently have a lot of code.
*'''Change the find_by_sql call(s) to Rails (Active Record) statements.'''
*'''Make sure that it can be used by a user with a TA or instructor account, if they are participating in this assignment.'''
*Change grammatically wrong or awkward flash messages.

'''join_team_requests_controller.rb'''
*Add comments to the code.
*Remove duplicate code.
*'''Update create and accept method to share code.'''
*'''Decline and destroy method should check for successful operation before returning.'''
*Change grammatically wrong or awkward flash messages.

== Implementation ==
==== Renamed invitation_controller.rb to invitations_controller.rb====
The controller renaming had to be incorporated in different files of the project. The table contain the file names along with the lines before and after the changes.

{| class="wikitable"
|-
! File Name !! Line no. !! Before !! After
|-
| config/routes.rb ||160 || resources :invitation do || resources :invitations do
|-
| config/routes.rb ||170

|| resources :join_team_requests do
collection do
get :edit
end
end
|| resources :join_team_requests do
collection do
post :decline
get :edit
end
end
|-
| ||
|-
|-
| app/views/join_team_requests/_list_received.html.erb ||33|| <%= form_tag :controller => 'invitation', :action => 'create' do %> ||<%= form_tag :controller => 'invitations', :action => 'create' do %>
|-
|-
| app/views/student_teams/view.html.erb ||151|| {:controller => 'invitation', :action => 'cancel', :inv_id => inv.id, :student_id => @student.id} %></td> ||{:controller => 'invitations', :action => 'cancel', :inv_id => inv.id, :student_id => @student.id} %></td>
|-
| app/views/student_teams/view.html.erb || 193 || {:controller => 'invitation', :action => 'accept', :inv_id => inv.id, :student_id => @student.id, :team_id => @team_id}, ||{:controller => 'invitations', :action => 'accept', :inv_id => inv.id, :student_id => @student.id, :team_id => @team_id},
|-
|app/views/student_teams/view.html.erb || 198 ||{:controller => 'invitation', :action => 'decline', :inv_id => inv.id, :student_id => @student.id} %> ||{:controller => 'invitations', :action => 'decline', :inv_id => inv.id, :student_id => @student.id} %>
|-
|app/views/student_teams/view.html.erb||217||<%= form_tag :controller => 'invitation', :action => 'create' do %>||<%= form_tag :controller => 'invitations', :action => 'create' do %>
|-
|app/controllers/invitations_controller.rb||1||class InvitationController < ApplicationController||class InvitationsController < ApplicationController
|}

==== InvitationController.rb====
{| class = "wikitable"
|-
!Before!!After
|-
|def create
user = User.find_by_name(params[:user][:name].strip)
team = AssignmentTeam.find(params[:team_id])
student = AssignmentParticipant.find(params[:student_id])
return unless current_user_id?(student.user_id)

#check if the invited user is valid
if !user
flash[:note] = "\"#{params[:user][:name].strip}\" does not exist. Please make sure the name entered is correct."
else
participant= AssignmentParticipant.where('user_id =? and parent_id =?', user.id, student.parent_id).first
#check if the user is a participant of the assignment
if !participant
flash[:note] = "\"#{params[:user][:name].strip}\" is not a participant of this assignment."
elsif team.full?
flash[:error] = "Your team already has max members."
else
team_member = TeamsUser.where(['team_id =? and user_id =?', team.id, user.id])
#check if invited user is already in the team
if (team_member.size > 0)
flash[:note] = "\"#{user.name}\" is already a member of team."
else
#check if the invited user is already invited (i.e. awaiting reply)
if Invitation.is_invited?(student.user_id, user.id, student.parent_id)
@invitation = Invitation.new
@invitation.to_id = user.id
@invitation.from_id = student.user_id
@invitation.assignment_id = student.parent_id
@invitation.reply_status = 'W'
@invitation.save
else
flash[:note] = "You have already sent an invitation to \"#{user.name}\"."
end
end
end
end

def accept
@inv = Invitation.find(params[:inv_id])

student = Participant.find(params[:student_id])

assignment_id=@inv.assignment_id
inviter_user_id=@inv.from_id
inviter_participant = AssignmentParticipant.find_by_user_id_and_assignment_id(inviter_user_id,assignment_id)

ready_to_join=false
#check if the inviter's team is still existing, and have available slot to add the invitee
inviter_assignment_team = AssignmentTeam.team(inviter_participant)
if inviter_assignment_team.nil?
flash[:error]= "The team which invited you does not exist any more."
else
if inviter_assignment_team.full?
flash[:error]= "The team which invited you is full now."
else
ready_to_join=true
end
end
||
def create #adds the new invitation to the table
if Invitation.is_invited?(@student.user_id, @user.id, @student.parent_id)
set_invitation(@user.id,@student.user_id,@student.parent_id,'W') #'W states the invitation is waitlisted, still not accepted'
else
flash[:note] = @@messages[:already_invited]
end
update_join_team_request @user,@student
redirect_to view_student_teams_path student_id: @student.id
end

def update_join_team_request(user,student) #update the status in the join_team_request to A
if user && student
participant= AssignmentParticipant.where(['user_id =? and parent_id =?', user.id, student.parent_id]).first
if participant
old_entry = JoinTeamRequest.where(['participant_id =? and team_id =?', participant.id,params[:team_id]]).first
if old_entry
old_entry.update_attribute("status",'A') # 'A' states that the invitation has been accepted
end
end
end
end

def auto_complete_for_user_name # searches the user name in the user table for auto complete
search = params[:user][:name].to_s
User.where(User.arel_table[:name].matches("%#{search}%"))
#@users = User.find_by_sql("select * from users where LOWER(name) LIKE '%"+search+"%'") unless search.blank?
end

def accept # allows accepting of the invitation
@inv = Invitation.find(params[:inv_id])
student = Participant.find(params[:student_id])
assignment_id=@inv.assignment_id
inviter_user_id=@inv.from_id
inviter_participant = AssignmentParticipant.find_by_user_id_and_assignment_id(inviter_user_id,assignment_id)

#check if the inviter's team is still existing, and have available slot to add the invitee
inviter_assignment_team = AssignmentTeam.team(inviter_participant)
if inviter_assignment_team.nil?
flash[:error]= @@messages[:invitation_not_exist]
elsif inviter_assignment_team.full?
flash[:error]= @@messages[:full_team]
else
@inv.reply_status = 'A'
@inv.save

#Remove the users previous team since they are accepting an invite for possibly a new team.
TeamsUser.remove_team(student.user_id, params[:team_id])

#Accept the invite and return boolean on whether the add was successful
add_successful = Invitation.accept_invite(params[:team_id], @inv.from_id, @inv.to_id, student.parent_id)

unless add_successful
flash[:error] = @@messages[:fail_to_add]
end
end

redirect_to view_student_teams_path student_id: params[:student_id]

end

|-
|}
==== JoinTeamRequestController.rb removed duplicate code====
{| class="wikitable"
|-
! Before !! After
|-
|def index
@join_team_requests = JoinTeamRequest.all
respond_to do |format|
format.html # index.html.erb
format.xml { render :xml => @join_team_requests }
end
||def index
@join_team_request = JoinTeamRequest.all
render_request # index.html.erb
end
|-
| ||
|-
| def show # searches the join team requests for a particular id
@join_team_request = JoinTeamRequest.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.xml { render :xml => @join_team_request }
end
end

def new # create a new join team request entry instance
@join_team_request = JoinTeamRequest.new
respond_to do |format|
format.html # new.html.erb
format.xml { render :xml => @join_team_request }
end
end
||private def render_request
respond_to do |format|
format.html
format.xml { render :xml => @join_team_request }
end
end

def show # searches the join team requests for a particular id
@join_team_request = JoinTeamRequest.find(params[:id])
render_request # show.html.erb
end

def new # create a new join team request entry instance
@join_team_request = JoinTeamRequest.new
render_request # new.html.erb
end
|-
|
|}

CSC/ECE 517 Fall 2015/oss E1559 rrz

2015-10-31T20:41:45Z

Zganatr:

== E1559: Refactoring JoinTeamRequestsController and InvitationController classes ==
This page gives a breif description on the expertiza based oss project that aimed at refactoring join_team_request_controller.rb and invitation_controller.rb files so that they follow the DRY principle and Ruby on Rails coding practices.

== Code Refactoring ==
Code refactoring is process of changing the code to make it more maintainable, without changing the functionality of the code. Some of the reasons for performing refactoring are:
* To remove duplicate code.
* To make the code more maintainable.
*To divide functionality of the class

== Introduction to Expertiza ==
Expertiza is a web application where students can submit and review learning objects like code, writings, etc. It gives scope for creation of reusable learning objects. Students submit assignments, which can than graded through peer reviews. The Expertiza project is supported by the National Science Foundation.

== Problem Statement ==
==== Classes involved====
''JoinTeamRequestsController'' and ''InvitationController''

====What the controller does====
'''invitation_controller.rb''' is used by a user to invite other users to join his/her team. It performs validation before creating a request. Following chunk of code checks whether the user is allowed to get the invite or not.
def action_allowed? # user specified only have access to the functionality of the controller
['Student', 'Instructor', 'Teaching Assistant'].include?(current_role_name)
end
Now, invited user can accept or reject the request.
Once the user has accepted the request, he can be seen as a part of the team.

'''join_team_requests_controller.rb''' is used when user decides to join a team.
This is achieved by creating an advertisement for the team.
Once the advertisement is created, it is shown in the Topic Selection section.
The user who wants to join the team can send a "Request" to the members of the team.
The members can then decide whether to send him/her an invite or decline the request.

==== What's wrong with the code ====
The invitation_controller.rb is doing the required task but it is difficult to understand the code, hence it becomes difficult to maintain the code. And the functions in the ''accept'' and ''create'' method can be broken down into separate methods.

In join_team_request_controller.rb has duplicate code in various methods which can be removed by creating a separate method for this common code.

==== What needs to be done ====
'''invitation_controller.rb'''
*Rename to Invitations_Controller.rb, as is not in accordance with current naming convention.
*Add comments explaining what each method does, and comments on how important variables are used as currently there are no comments.
*'''Refactor create and accept methods.''' Shorten and clarify them by adding private methods, as create and accept methods currently have a lot of code.
*'''Change the find_by_sql call(s) to Rails (Active Record) statements.'''
*'''Make sure that it can be used by a user with a TA or instructor account, if they are participating in this assignment.'''
*Change grammatically wrong or awkward flash messages.

'''join_team_requests_controller.rb'''
*Add comments to the code.
*Remove duplicate code.
*'''Update create and accept method to share code.'''
*'''Decline and destroy method should check for successful operation before returning.'''
*Change grammatically wrong or awkward flash messages.

== Implementation ==
==== Renamed invitation_controller.rb to invitations_controller.rb====
The controller renaming had to be incorporated in different files of the project. The table contain the file names along with the lines before and after the changes.

{| class="wikitable"
|-
! File Name !! Line no. !! Before !! After
|-
| config/routes.rb ||160 || resources :invitation do || resources :invitations do
|-
| config/routes.rb ||170

|| resources :join_team_requests do
collection do
get :edit
end
end
|| resources :join_team_requests do
collection do
post :decline
get :edit
end
end
|-
| ||
|-
|-
| app/views/join_team_requests/_list_received.html.erb ||33|| <%= form_tag :controller => 'invitation', :action => 'create' do %> ||<%= form_tag :controller => 'invitations', :action => 'create' do %>
|-
|-
| app/views/student_teams/view.html.erb ||151|| {:controller => 'invitation', :action => 'cancel', :inv_id => inv.id, :student_id => @student.id} %></td> ||{:controller => 'invitations', :action => 'cancel', :inv_id => inv.id, :student_id => @student.id} %></td>
|-
| app/views/student_teams/view.html.erb || 193 || {:controller => 'invitation', :action => 'accept', :inv_id => inv.id, :student_id => @student.id, :team_id => @team_id}, ||{:controller => 'invitations', :action => 'accept', :inv_id => inv.id, :student_id => @student.id, :team_id => @team_id},
|-
|app/views/student_teams/view.html.erb || 198 ||{:controller => 'invitation', :action => 'decline', :inv_id => inv.id, :student_id => @student.id} %> ||{:controller => 'invitations', :action => 'decline', :inv_id => inv.id, :student_id => @student.id} %>
|-
|app/views/student_teams/view.html.erb||217||<%= form_tag :controller => 'invitation', :action => 'create' do %>||<%= form_tag :controller => 'invitations', :action => 'create' do %>
|-
|app/controllers/invitations_controller.rb||1||class InvitationController < ApplicationController||class InvitationsController < ApplicationController
|}

==== InvitationController.rb====
{| class = "wikitable"
|-
!Before!!After
|-
|def create
user = User.find_by_name(params[:user][:name].strip)
team = AssignmentTeam.find(params[:team_id])
student = AssignmentParticipant.find(params[:student_id])
return unless current_user_id?(student.user_id)

#check if the invited user is valid
if !user
flash[:note] = "\"#{params[:user][:name].strip}\" does not exist. Please make sure the name entered is correct."
else
participant= AssignmentParticipant.where('user_id =? and parent_id =?', user.id, student.parent_id).first
#check if the user is a participant of the assignment
if !participant
flash[:note] = "\"#{params[:user][:name].strip}\" is not a participant of this assignment."
elsif team.full?
flash[:error] = "Your team already has max members."
else
team_member = TeamsUser.where(['team_id =? and user_id =?', team.id, user.id])
#check if invited user is already in the team
if (team_member.size > 0)
flash[:note] = "\"#{user.name}\" is already a member of team."
else
#check if the invited user is already invited (i.e. awaiting reply)
if Invitation.is_invited?(student.user_id, user.id, student.parent_id)
@invitation = Invitation.new
@invitation.to_id = user.id
@invitation.from_id = student.user_id
@invitation.assignment_id = student.parent_id
@invitation.reply_status = 'W'
@invitation.save
else
flash[:note] = "You have already sent an invitation to \"#{user.name}\"."
end
end
end
end

def accept
@inv = Invitation.find(params[:inv_id])

student = Participant.find(params[:student_id])

assignment_id=@inv.assignment_id
inviter_user_id=@inv.from_id
inviter_participant = AssignmentParticipant.find_by_user_id_and_assignment_id(inviter_user_id,assignment_id)

ready_to_join=false
#check if the inviter's team is still existing, and have available slot to add the invitee
inviter_assignment_team = AssignmentTeam.team(inviter_participant)
if inviter_assignment_team.nil?
flash[:error]= "The team which invited you does not exist any more."
else
if inviter_assignment_team.full?
flash[:error]= "The team which invited you is full now."
else
ready_to_join=true
end
end
||
def create #adds the new invitation to the table
if Invitation.is_invited?(@student.user_id, @user.id, @student.parent_id)
set_invitation(@user.id,@student.user_id,@student.parent_id,'W') #'W states the invitation is waitlisted, still not accepted'
else
flash[:note] = @@messages[:already_invited]
end
update_join_team_request @user,@student
redirect_to view_student_teams_path student_id: @student.id
end

def update_join_team_request(user,student) #update the status in the join_team_request to A
if user && student
participant= AssignmentParticipant.where(['user_id =? and parent_id =?', user.id, student.parent_id]).first
if participant
old_entry = JoinTeamRequest.where(['participant_id =? and team_id =?', participant.id,params[:team_id]]).first
if old_entry
old_entry.update_attribute("status",'A') # 'A' states that the invitation has been accepted
end
end
end
end

def auto_complete_for_user_name # searches the user name in the user table for auto complete
search = params[:user][:name].to_s
User.where(User.arel_table[:name].matches("%#{search}%"))
#@users = User.find_by_sql("select * from users where LOWER(name) LIKE '%"+search+"%'") unless search.blank?
end

def accept # allows accepting of the invitation
@inv = Invitation.find(params[:inv_id])
student = Participant.find(params[:student_id])
assignment_id=@inv.assignment_id
inviter_user_id=@inv.from_id
inviter_participant = AssignmentParticipant.find_by_user_id_and_assignment_id(inviter_user_id,assignment_id)

#check if the inviter's team is still existing, and have available slot to add the invitee
inviter_assignment_team = AssignmentTeam.team(inviter_participant)
if inviter_assignment_team.nil?
flash[:error]= @@messages[:invitation_not_exist]
elsif inviter_assignment_team.full?
flash[:error]= @@messages[:full_team]
else
@inv.reply_status = 'A'
@inv.save

#Remove the users previous team since they are accepting an invite for possibly a new team.
TeamsUser.remove_team(student.user_id, params[:team_id])

#Accept the invite and return boolean on whether the add was successful
add_successful = Invitation.accept_invite(params[:team_id], @inv.from_id, @inv.to_id, student.parent_id)

unless add_successful
flash[:error] = @@messages[:fail_to_add]
end
end

redirect_to view_student_teams_path student_id: params[:student_id]

end

|-
|}
==== JoinTeamRequestController.rb removed duplicate code====
{| class="wikitable"
|-
! Before !! After
|-
|def index
@join_team_requests = JoinTeamRequest.all
respond_to do |format|
format.html # index.html.erb
format.xml { render :xml => @join_team_requests }
end
||def index
@join_team_request = JoinTeamRequest.all
render_request # index.html.erb
end
|-
| ||
|-
| def show # searches the join team requests for a particular id
@join_team_request = JoinTeamRequest.find(params[:id])
respond_to do |format|
format.html # show.html.erb
format.xml { render :xml => @join_team_request }
end
end

def new # create a new join team request entry instance
@join_team_request = JoinTeamRequest.new
respond_to do |format|
format.html # new.html.erb
format.xml { render :xml => @join_team_request }
end
end
||private def render_request
respond_to do |format|
format.html
format.xml { render :xml => @join_team_request }
end
end

def show # searches the join team requests for a particular id
@join_team_request = JoinTeamRequest.find(params[:id])
render_request # show.html.erb
end

def new # create a new join team request entry instance
@join_team_request = JoinTeamRequest.new
render_request # new.html.erb
end
|-
|
|}

CSC/ECE 517 Fall 2015/oss E1559 rrz

2015-10-31T20:30:54Z

Zganatr:

CSC/ECE 517 Fall 2015/oss E1559 rrz

2015-10-31T06:29:50Z

Zganatr:

CSC/ECE 517 Fall 2015/oss E1559 rrz

2015-10-31T06:24:12Z

Zganatr:

CSC/ECE 517 Fall 2015/oss E1559 rrz

2015-10-31T06:22:07Z

Zganatr:

CSC/ECE 517 Fall 2015/oss E1559 rrz

2015-10-31T06:16:06Z

Zganatr:

CSC/ECE 517 Fall 2015/oss E1559 rrz

2015-10-31T05:58:42Z

Zganatr:

CSC/ECE 517 Fall 2015/oss E1559 rrz

2015-10-31T05:52:47Z

Zganatr:

CSC/ECE 517 Fall 2015/oss E1559 rrz

2015-10-31T05:18:44Z

Zganatr: /* What needs to be done */

CSC/ECE 517 Fall 2015/oss E1559 rrz

2015-10-31T05:12:05Z

Zganatr:

CSC/ECE 517 Fall 2015/oss E1559 rrz

2015-10-31T04:24:53Z

Zganatr: /* Code Refactoring */

==== E1559: Refactoring JoinTeamRequestsController and InvitationController classes ====
This page gives a breif description on the expertiza based oss project that aimed at refactoring JoinTeamRequestController.rb and InvitationController.rb classes so that they follow the DRY principle and Ruby on Rails coding practices.

==== Code Refactoring ====
Code refactoring is process of changing the code to make it more maintainable, without changing the functionality of the code. Some of the reasons for performing refactoring are:

-> To remove duplicate code.

-> To make the code more maintainable.

-> To divide functionality of the class

==== Introduction to Expertiza ====
Expertiza is a web application where students can submit and review learning objects like code, writings, etc. It gives scope for creation of reusable learning objects. Students submit assignments, which can than graded through peer reviews. The Expertiza project is supported by the National Science Foundation.

CSC/ECE 517 Fall 2015/oss E1559 rrz

2015-10-31T04:24:40Z

Zganatr: /* Code Refactoring */

==== E1559: Refactoring JoinTeamRequestsController and InvitationController classes ====
This page gives a breif description on the expertiza based oss project that aimed at refactoring JoinTeamRequestController.rb and InvitationController.rb classes so that they follow the DRY principle and Ruby on Rails coding practices.

==== Code Refactoring ====
Code refactoring is process of changing the code to make it more maintainable, without changing the functionality of the code. Some of the reasons for performing refactoring are:
-> To remove duplicate code.

-> To make the code more maintainable.

-> To divide functionality of the class

==== Introduction to Expertiza ====
Expertiza is a web application where students can submit and review learning objects like code, writings, etc. It gives scope for creation of reusable learning objects. Students submit assignments, which can than graded through peer reviews. The Expertiza project is supported by the National Science Foundation.

CSC/ECE 517 Fall 2015/oss E1559 rrz

2015-10-31T04:24:09Z

Zganatr: /* E1559: Refactoring JoinTeamRequestsController and InvitationController classes */

==== E1559: Refactoring JoinTeamRequestsController and InvitationController classes ====
This page gives a breif description on the expertiza based oss project that aimed at refactoring JoinTeamRequestController.rb and InvitationController.rb classes so that they follow the DRY principle and Ruby on Rails coding practices.

==== Code Refactoring ====
Code refactoring is process of changing the code to make it more maintainable, without changing the functionality of the code. Some of the reasons for performing refactoring are:
-> To remove duplicate code.
-> To make the code more maintainable.
-> To divide functionality of the class

==== Introduction to Expertiza ====
Expertiza is a web application where students can submit and review learning objects like code, writings, etc. It gives scope for creation of reusable learning objects. Students submit assignments, which can than graded through peer reviews. The Expertiza project is supported by the National Science Foundation.

CSC/ECE 517 Fall 2015/oss E1559 rrz

2015-10-28T19:13:49Z

Zganatr: /* E1559: Refactoring JoinTeamRequestsController and InvitationController classes */

CSC/ECE 517 Fall 2015/oss E1559 rrz

2015-10-28T19:13:14Z

Zganatr: Created page with "=== E1559: Refactoring JoinTeamRequestsController and InvitationController classes === This page gives a breif description on the expertiza based oss project that aimed at refac..."

=== E1559: Refactoring JoinTeamRequestsController and InvitationController classes ===
This page gives a breif description on the expertiza based oss project that aimed at refactoring JoinTeamRequestController.rb and InvitationController.rb classes so that they follow the DRY principle and Ruby on Rails coding practices.

CSC/ECE 517 Fall 2015

2015-10-28T19:06:24Z

Zganatr: