Rcov C0 Coverage Information - RCov

 class Student < User

   has_many :accepted_groupings, :class_name => 'Grouping', :through => :memberships, :conditions => {'memberships.membership_status' => [StudentMembership::STATUSES[:accepted], StudentMembership::STATUSES[:inviter]]}, :source => :grouping

   has_many :pending_groupings, :class_name => 'Grouping', :through => :memberships, :conditions => {'memberships.membership_status' => StudentMembership::STATUSES[:pending]}, :source => :grouping

   has_many :rejected_groupings, :class_name => 'Grouping', :through => :memberships, :conditions => {'memberships.membership_status' => StudentMembership::STATUSES[:rejected]}, :source => :grouping

   has_many :student_memberships, :foreign_key => 'user_id'

   has_many :grace_period_deductions, :through => :memberships

   belongs_to :section

   accepts_nested_attributes_for :section

   validates_numericality_of :grace_credits, :only_integer => true,

   CSV_UPLOAD_ORDER = USER_STUDENT_CSV_UPLOAD_ORDER

   SESSION_TIMEOUT = USER_STUDENT_SESSION_TIMEOUT

   # 'accepted' or 'inviter'

   def has_accepted_grouping_for?(aid)

     return !accepted_grouping_for(aid).nil?

   # or 'inviter'

   def accepted_grouping_for(aid)

     return accepted_groupings.find_by_assignment_id(aid)

   def has_pending_groupings_for?(aid)

     return (pending_groupings_for(aid).size > 0)

   def pending_groupings_for(aid)

     return pending_groupings.find_all_by_assignment_id(aid)

   def remaining_grace_credits

     return @remaining_grace_credits if !@remaining_grace_credits.nil?

     total_deductions = 0

     grace_period_deductions.each do |grace_period_deduction|

       total_deductions += grace_period_deduction.deduction

     end

     @remaining_grace_credits = grace_credits - total_deductions

   def display_for_note

     return  user_name + ": " + last_name+", " + first_name

   # return pending memberships for a specific assignment

   def pending_memberships_for(aid)

     groupings = self.pending_groupings_for(aid)

     if !groupings.nil?

       pending_memberships = []

       groupings.each do |grouping|

          pending_memberships.push(StudentMembership.find_by_grouping_id_and_user_id(grouping.id, self.id))

       end

       return pending_memberships

     end

     return nil

   def memberships_for(aid)

      @student = self

      @memberships = StudentMembership.find(:all, :conditions => {:user_id => @student.id})

      @memberships.each do |m|

      end

      return @memberships

   # invites a student

   def invite(gid)

     if !self.hidden

       membership = StudentMembership.new

       membership.grouping_id = gid;

       membership.membership_status = StudentMembership::STATUSES[:pending]

       membership.user_id = self.id

       membership.save

       # if grouping is valid

       grouping = Grouping.find(gid)

       grouping.update_repository_permissions

   def destroy_all_pending_memberships(aid)

     self.pending_groupings_for(aid).each do |grouping|

       membership = grouping.student_memberships.find_by_user_id(self.id)

       membership.destroy

   # assignment aid

   def create_group_for_working_alone_student(aid)

     ActiveRecord::Base.transaction do

       @assignment = Assignment.find(aid)

       @grouping = Grouping.new

       @grouping.assignment_id = @assignment.id

       if !Group.find(:first, :conditions => {:group_name => self.user_name}).nil?

         @group = Group.find(:first, :conditions => {:group_name => self.user_name})

       else

         @group = Group.new(:group_name => self.user_name)

         # We do that only if the assignment is set up to be a

         # non-web-submit assignment.

         if @assignment.allow_web_submits == false

           @group.repo_name = self.user_name

         end

         if !@group.save

           m_logger = MarkusLogger.instance

         end

       @grouping.group = @group

       if !@grouping.save

         m_logger = MarkusLogger.instance

         m_logger.log("Could not create a grouping for Student '#{self.user_name}'. The grouping was:  #{@grouping.inspect} - errors: #{@grouping.errors.inspect}", MarkusLogger::ERROR)

       # We give students the tokens for the test framework

       @grouping.give_tokens

       # Create the membership

       @member = StudentMembership.new(:grouping_id => @grouping.id,

               :membership_status => StudentMembership::STATUSES[:inviter],

               :user_id => self.id)

       @member.save

       # Destroy all the other memebrships for this assignment

       self.destroy_all_pending_memberships(@assignment.id)

       # after memberships have been established.

       @grouping.update_repository_permissions

     end

     return true

   def create_autogenerated_name_group(aid)

     assignment = Assignment.find(aid)

     if !assignment.group_name_autogenerated

       raise "Assignment does not allow for groups with autogenerated names"

     group = Group.new

     group.save(:validate => false)

     group.group_name = group.get_autogenerated_group_name

     group.save

     grouping = Grouping.new

     grouping.assignment_id = aid

     grouping.group_id = group.id

     grouping.save

     # write repo permissions if need be

     grouping.update_repository_permissions

     member = StudentMembership.new(:grouping_id => grouping.id, :membership_status => StudentMembership::STATUSES[:inviter], :user_id => self.id)

     member.save

     self.destroy_all_pending_memberships(aid)

   end

   # This method is called, when a student joins a group(ing)

   def join(gid)

     membership = StudentMembership.find_by_grouping_id_and_user_id(gid, self.id)

     membership.membership_status = 'accepted'

     membership.save

     grouping = Grouping.find(gid)

     # write repo permissions if need be

     grouping.update_repository_permissions

     if grouping.is_valid?

       # We give students the tokens for the test framework

       grouping.give_tokens

     end

     other_memberships = self.pending_memberships_for(grouping.assignment_id)

     other_memberships.each do |m|

       m.membership_status = 'rejected'

       m.save

     end

   end

   # Hides a list of students and revokes repository

   # permissions (when exposed externally)

   def self.hide_students(student_id_list)

     update_list = {}

     student_id_list.each do |student_id|

       update_list[student_id] = {:hidden => true}

       # update repo permissions appropriately

       memberships = StudentMembership.find_by_user_id(student_id)

       if !memberships.nil?

         if !memberships.instance_of?(Array)

           memberships = [memberships]

         end

         student = Student.find(student_id)

         memberships.each do |membership|

           group = membership.grouping.group

           group.access_repo do |repo|

             if membership.grouping.repository_external_commits_only? && membership.grouping.is_valid?

               begin

                 repo.remove_user(student.user_name) # revoke repo permissions

                 # ignore case when user isn't there any more

               end

             end

           end

       end

     end

     Student.update(update_list.keys, update_list.values)

   end

   # "Unhides" students not visible and grants repository

   # permissions (when exposed externally)

   def self.unhide_students(student_id_list)

     update_list = {}

     student_id_list.each do |student_id|

       update_list[student_id] = {:hidden => false}

       # update repo permissions appropriately

       memberships = StudentMembership.find_by_user_id(student_id)

       if !memberships.nil?

         if !memberships.instance_of?(Array)

           memberships = [memberships]

         end

         student = Student.find(student_id)

         memberships.each do |membership|

           group = membership.grouping.group

           group.access_repo do |repo|

             if membership.grouping.repository_external_commits_only? && membership.grouping.is_valid?

               begin

                 repo.add_user(student.user_name, Repository::Permission::READ_WRITE) # grant repo permissions

               rescue Repository::UserAlreadyExistent

                 # ignore case if user has permissions already

               end

             end

           end

       end

     end

     Student.update(update_list.keys, update_list.values)

   def self.give_grace_credits(student_ids, number_of_grace_credits)

     students = Student.find(student_ids)

     students.each do |student|

       student.grace_credits += number_of_grace_credits.to_i

       if student.grace_credits < 0

         student.grace_credits = 0

       end

       student.save

   # Returns true when the student has a section

   def has_section?

     return !self.section.nil?

   # Updates the section of a list of students

   def self.update_section(students_ids, nsection)

     students_ids.each do |sid|

       Student.update(sid, {:section_id => nsection})