CSC/ECE 517 Fall 2018/E1834 Improve email notifications

From Expertiza_Wiki
Revision as of 07:07, 2 November 2018 by Ahshah4 (talk | contribs)
Jump to navigation Jump to search

This page provides a description of the Expertiza based OSS project.

About Expertiza

Expertiza is an open source project developed using Ruby on Rails framework.Expertiza allows the instructor to create new assignments and customize new or existing assignments.The application allows students to submit and peer-review learning objects (articles, code, web sites, etc)[1].Expertiza supports submission across various document types, including the URLs and wiki pages.

Problem Statement

  • When students' accounts are created by importing a CSV file on the Users page, they receive e-mails with their user-ID and password. But if an account is created by adding them as participants to an assignment when they don't already have an account, e-mail is not sent. Students should receive e-mails upon account creation, regardless of how their account is created. So this involves adding a call to the e-mailer … or, perhaps, moving an email call from the Users controller to the point where an account is actually created.
  • Second, evidently if a submission is revised after review, the system e-mails the reviewer saying to revise the review. This is just fine ... except if the last round of review is in progress.The message telling reviewers to revise their reviews should not be sent after the last review deadline has passed. It would also be nice to fix the message so it tells which review (Review 1, Review 2, etc.) has been revised, and gives the reviewer a link directly to it.
  • Deadline reminders should include a link on where to go to perform the needed function.

    Approach Taken To Implement Changes

    NOTE: All the mails except the ones for the reviewer which are sent to mailinator are sent to expertiza.development@gmail.com ,as this is already set in the development environment.

    1) Mail sent when participant added to assignment :

    When students' accounts are created by importing a CSV file on the Users page,they receive e-mails but not when user was added as a participant to the assignment.We added a method in the assignment_participant.rb model to send mails when a participant is added to an assignment on the assignment page through a CSV file.This functionality is implemented with using the MailerHelper class.

      # provide import functionality for Assignment Participants
      # if user does not exist, it will be created and added to this assignment
     def self.import(row_hash, _row_header = nil, session, id)
       raise ArgumentError, "No user id has been specified." if row_hash.empty?
       user = User.find_by(name: row_hash[:name])
       if user.nil?
         raise ArgumentError, "The record containing #{row_hash[:name]} does not have enough items." if row_hash.length < 4
         attributes = ImportFileHelper.define_attributes(row_hash)
         user = ImportFileHelper.create_new_user(attributes, session)
       end
       raise ImportError, "The assignment with id \"#{id.to_s}\" was not found." if Assignment.find(id).nil?
       unless AssignmentParticipant.exists?(user_id: user.id, parent_id: id)
         new_part = AssignmentParticipant.create(user_id: user.id, parent_id: id)
         new_part.set_handle
       end
       prepared_mail = MailerHelper.send_mail_to_user(user, "Your Expertiza account and password have been created.", "user_welcome", "password")
       prepared_mail.deliver
     end
    


    We have in a similar fashion added a method in the course_participant model.

     # provide import functionality for Course Participants
     # if user does not exist, it will be created and added to this assignment
     def self.import(row_hash, _row_header = nil, session, id)
       raise ArgumentError, "No user id has been specified." if row_hash.empty?
       user = User.find_by(name: row_hash[:name])
       if user.nil?
         raise ArgumentError, "The record containing #{row_hash[:name]} does not have enough items." if row_hash.length < 4
         attributes = ImportFileHelper.define_attributes(row_hash)
         user = ImportFileHelper.create_new_user(attributes, session)
       end
       course = Course.find_by(id)
       raise ImportError, "The course with the id \"" + id.to_s + "\" was not found." if course.nil?
       unless CourseParticipant.exists?(user_id: user.id, parent_id: id)
         CourseParticipant.create(user_id: user.id, parent_id: id)
       end
       password = "password"#user.password
       prepared_mail = MailerHelper.send_mail_to_user(user, "Your Expertiza account and password have been created.", "user_welcome", password)
       prepared_mail.deliver
     end
    


    2) Sending email to reviewer when new submission is availble:

    Added functionality to send email to the reviewer when new submission is available by making changes in the submitted_content_controller and assignment_participant model. The method handled boundary constraints like checking whether the round was valid and disabling email notification after the last round of review.

     #assignment_participant.rb
     def is_in_final_round?
       topic_id = SignedUpTeam.topic_id(self.parent_id, self.user_id)
       return false if topic_id.nil? and self.staggered_deadline?
       next_due_date = DueDate.get_next_due_date(self.parent_id, topic_id)
       return !!(next_due_date.round == assignment.num_review_rounds && next_due_date.deadline_type_id == 2)
     end
    

    Extra functionality of specifying the current review round and providing the direct link to reviewer in the mail itself also implemented in the submitted_content controller using the ReviewResponseMap and Response class.

      #submitted_content_controller.
      # Send email to reviewers to review new submission, if review_round is valid and not last.
         @participant = AssignmentParticipant.find(params[:id])
         # Send email to reviewers to review new submission, if the participant is not in the last round.
         if !@participant.is_in_final_round?
           @participant.reviewers.each do |reviewer|
             map = ReviewResponseMap.where(['reviewer_id = ? and reviewee_id = ?', reviewer.id, @participant.team.id]).first
             responses = Response.where(:map_id => map.id)
             responses = responses.sort_by { |obj| obj.updated_at }
    
             # the latest response will be the last
             latest_response = responses.last
    
             # we need to pass the id of lastest_response in the URL mentioned in the mail.
             # this will open the correct /response/edit?id=#{latest_response.id} page for the reviewer when (s)he clicks on it.
             Mailer.delayed_message(bcc: [User.find(reviewer.user_id).email],
                                    subject: "You have a new submission to review",
                                    body: "Please visit https://expertiza.ncsu.edu/response/edit?id=#{latest_response.id} and proceed to peer 
                                    reviews.").deliver_now
           end
         end
    

    3) Including a specific link for the deadline reminders email functionality :

    Added a review_reminder_email method and mail_reviewers method in the delayed_mailer.rb file which implemented the functionality for sending deadline reminder mails which includes a link on where to gon to perform the specific task.

     #delayed_mailer.rb
     def mail_reviewers
       email_list = []
       reviews = ReviewResponseMap.where(reviewed_object_id: self.assignment_id)
       reviews.each do |review|
         participant = Participant.where(parent_id: self.assignment_id, id: review.reviewer_id).first
         email_list << {'email' => participant.user.email, 'participant_id' => participant.id}
       end
       review_reminder_email(email_list, self.deadline_type) unless email_list.empty?
     end
    
     def review_reminder_email(email_list, deadline_type)
       assignment = Assignment.find(self.assignment_id)
       subject = "Message regarding #{deadline_type} for assignment #{assignment.name}"
       for item in email_list
         body = "This is a reminder to complete #{deadline_type} for assignment #{assignment.name}. \
                 Deadline is #{self.due_at}. Please visit https://expertiza.ncsu.edu/student_review/list?id=#{item.participant_id}\
                 If you have already done the  #{deadline_type}, please ignore this mail."
         Rails.logger.info item.email
         @mail = Mailer.delayed_message(bcc: [item.email], subject: subject, body: body)
         @mail.deliver_now
       end
    
       @count += 1
       if @count % 3 == 0
         if assignment.instructor.copy_of_emails
           # if email is sent to instructor, notice that the link in that email will contain the '?id=' field of the last participant
           @mail = Mailer.delayed_message(bcc: [assignment.instructor.email], subject: subject, body: body)
           @mail.deliver_now
         end
       end
     end
    

    Corresponding changes in the background_email_reminder.rake file implemented. A method named send_reminder_mails implemented.

     def send_reminder_emails(email_list, assign_name, due_date, assign_type)
       due_date_string = due_date.due_at.to_s
       subject = "Message regarding #{assign_type} for #{assign_name}"
       for item in email_list
         body = "This is a reminder to complete #{assign_type} for assignment #{assign_name}. " +
             "Deadline is #{due_date_string}. " +
             "Please visit https://expertiza.ncsu.edu/response/edit?id=#{item.response_id}"
         Mailer.deliver_message({ :bcc => [item.email], :subject => subject, :body => body })
       end
     end
    

    Testing

    We have used Rspec for testing the email functionalities.Using the test driven development(TDD) approach, we have added an Rspec test which checks whether the mail is delivered to the expected receiver upon creation of the account for the student. We have created a new assignment_particpant_ spec file for the above purpose.The spec uses double and stub features of rspec gem to fake user login.

    Since the smtp setting are set to test mode all mails go to expertiza.development@gmail.com and not the actual user.Hence when an email is sent the ActionMailer::Base.deliveries list gets updated.


         context "when participant is added to assignment using csv" do
           let(:row) do
             {name: 'no one', fullname: 'no one', email: 'name@email.com', role:'user_role_name', parent: 'user_parent_name'}
           end
           let(:attributes) do
             {role_id: 1, name: 'no one', fullname: 'no one', email: 'name@email.com', email_on_submission: 'name@email.com',
              email_on_review: 'name@email.com', email_on_review_of_review: 'name@email.com'}
           end
            it "should send an email to the participant", :mailer => true do
             allow(ImportFileHelper).to receive(:define_attributes).with(row).and_return(attributes)
             allow(ImportFileHelper).to receive(:create_new_user).with(attributes, {}).and_return(double('User', id: 1, email: 'name@email.com', first_name: 'no 
              name', last_name: 'no name', name: 'no name'))
             allow(Assignment).to receive(:find).with(1).and_return(assignment)
             allow(AssignmentParticipant).to receive(:exists?).with(user_id: 1, parent_id: 1).and_return(false)
             allow(AssignmentParticipant).to receive(:create).with(user_id: 1, parent_id: 1).and_return(participant)
             allow(participant).to receive(:set_handle).and_return('handle')
              # Check that ActionMailer::Base.deliveries list is updated when email is set by import method.
             # The last element in the deliveries list will be the email that was just sent when import method was invoked
             # We need to verify the email was correct by checking its subject, from and to.
             # In development/test mode, all mails go to expertiza.development@gmail.com and not actual user.to
             expect { AssignmentParticipant.import(row, nil, {}, 1) }.to change { ActionMailer::Base.deliveries.count }.by(1)
             email = ActionMailer::Base.deliveries.last
             expect(email.from[0]).to eq('expertiza.development@gmail.com')
             expect(email.to[0]).to eq('expertiza.development@gmail.com')
             expect(email.subject).to eq('Your Expertiza account and password have been created.')
           end
         end