Rcov C0 Coverage Information - RCov

 require 'fastercsv'

 class AssignmentsController < ApplicationController

   before_filter      :authorize_only_for_admin, 

   before_filter      :authorize_for_student, 

   before_filter      :authorize_for_user, 

   auto_complete_for  :assignment, 

   def student_interface

     @assignment = Assignment.find(params[:id])

     @student = current_user

     @grouping = @student.accepted_grouping_for(@assignment.id)

     if @student.has_pending_groupings_for?(@assignment.id)

     end

     if @grouping.nil?

       if @assignment.group_max == 1

         @student.create_group_for_working_alone_student(@assignment.id)

       else

         render :action => 'student_interface', :layout => 'no_menu_header'

       # The members

       # The group name

       # The inviter   

       # Look up submission information

       repo = @grouping.group.repo

       @revision  = repo.get_latest_revision

       # For running tests

       else

       #submission = @grouping.submissions.find_by_submission_version_used(true)

       if @result

       else

       end

       @last_modified_date = @grouping.assignment_folder_last_modified_date

       @num_submitted_files = @grouping.number_of_submitted_files

       @num_missing_assignment_files = @grouping.missing_assignment_files.length

   # assignment information

   def index

     @assignments = Assignment.all(:order => :id)

     @grade_entry_forms = GradeEntryForm.all(:order => :id)

       # get results for assignments for the current user

       @a_id_results = Hash.new()

       @assignments.each do |a|

         if current_user.has_accepted_grouping_for?(a)

           grouping = current_user.accepted_grouping_for(a)

           if grouping.has_submission?

             submission = grouping.current_submission_used

             if submission.has_result? && submission.result.released_to_students

       # Get the grades for grade entry forms for the current user

       @g_id_entries = Hash.new()

       @grade_entry_forms.each do |g|

         grade_entry_student = g.grade_entry_students.find_by_user_id( 

         if !grade_entry_student.nil? && 

       render :action => "student_assignment_list"

       return

     elsif current_user.ta?

     else

   def edit

     @assignment = Assignment.find_by_id(params[:id])

     if !params[:assignment].nil?

       @oldcriteria = @assignment.marking_scheme_type

       @newcriteria = params[:assignment][:marking_scheme_type]

         # criteria structure finished

         @assignment.get_criteria.each do |criterion|

     end

     @assignments = Assignment.all

     if !request.post?

     begin

     rescue Exception, RuntimeError => e

                                             :message => e.message))

     if @assignment.save

       flash[:success] = I18n.t("assignment.update_success")

       redirect_to :action => 'edit', :id => params[:id]

     else

   # Called when form for creating a new assignment is submitted

   def new

     @assignments = Assignment.all

     @assignment = Assignment.new

       # set default value if web submits are allowed

       @assignment.allow_web_submits = 

          !MarkusConfigurator.markus_config_repository_external_submits_only?

       render :action => 'new'

     @assignment.transaction do

       begin

       rescue Exception, RuntimeError => e

       end

       if !@assignment.save

         render :action => :new

   def update_group_properties_on_persist

   def download_csv_grades_report

     assignments = Assignment.all(:order => 'id')

     students = Student.all

     csv_string = FasterCSV.generate do |csv|

       students.each do |student|

         row = []

         row.push(student.user_name)

         assignments.each do |assignment|

           out_of = assignment.total_mark

           grouping = student.accepted_grouping_for(assignment.id)

           if grouping.nil?

           else

             submission = grouping.current_submission_used

             if submission.nil?

             else

               total_mark_percentage = submission.result.total_mark / out_of * 100

               if total_mark_percentage.nan?

               else

         end

     end

   def join_group

     @assignment = Assignment.find(params[:id]) 

     @grouping = Grouping.find(params[:grouping_id])

     @user = Student.find(session[:uid])

     @user.join(@grouping.id)

     m_logger = MarkusLogger.instance

     m_logger.log(I18n.t("markus_logger.student_accepted_invitation", 

                          :user_name => @user.user_name, 

                          :group => @grouping.group.group_name))

   def decline_invitation

     @assignment = Assignment.find(params[:id])

     @grouping = Grouping.find(params[:grouping_id])

     @user = Student.find(session[:uid])

     @grouping.decline_invitation(@user)

     m_logger = MarkusLogger.instance

     m_logger.log(I18n.t("markus_logger.student_declined_invitation", 

                          :user_name => @user.user_name, 

                          :group => @grouping.group.group_name))

   def creategroup

     @assignment = Assignment.find(params[:id])

     @student = @current_user

       # and the grace period for an assignment

       end

       if !@assignment.student_form_groups || 

            @assignment.instructor_form_groups

       end

       if @student.has_accepted_grouping_for?(@assignment.id)

       end

       if params[:workalone]

         if @assignment.group_min != 1

           raise I18n.t('create_group.fail.can_not_work_alone', 

         end

       else

       end

       m_logger.log(I18n.t("markus_logger.student_created_group", 

     rescue RuntimeError => e

       flash[:fail_notice] = e.message

       m_logger.log(I18n.t("markus_logger.student_create_group_fail", 

     end

   def deletegroup

     @assignment = Assignment.find(params[:id])

     @grouping = @current_user.accepted_grouping_for(@assignment.id)

     m_logger = MarkusLogger.instance

     begin

       if @grouping.nil?

       # If grouping is not deletable for @current_user for whatever reason, fail.

       if !@grouping.deletable_by?(@current_user)

       end

       if @grouping.has_submission?

       end

       @grouping.student_memberships.all(:include => :user).each do |member|

       # update repository permissions

       @grouping.update_repository_permissions

       @grouping.destroy

       flash[:edit_notice] = I18n.t('assignment.group.deleted')

       m_logger.log(I18n.t("markus_logger.student_deleted_group", 

                            :user_name => current_user.user_name, 

     rescue RuntimeError => e

       flash[:fail_notice] = e.message

       if @grouping.nil?

         m_logger.log(

            I18n.t("markus_logger.student_delete_group_fail_no_grouping",

       else

         m_logger.log(I18n.t("markus_logger.student_delete_group_fail", 

                              :user_name => current_user.user_name, 

     end

   def invite_member

     return unless request.post?

     # if instructor formed group return

     @student = @current_user

     @grouping = @student.accepted_grouping_for(@assignment.id)

     if @grouping.nil?

     to_invite = params[:invite_member].split(',')

     flash[:fail_notice] = []

     flash[:success] = []

     m_logger = MarkusLogger.instance

     @grouping.invite(to_invite)

     flash[:fail_notice] = @grouping.errors["base"]

     if flash[:fail_notice].blank?

     end

   # i.e. cancels invitations

   def disinvite_member

     @assignment = Assignment.find(params[:id])

     membership = StudentMembership.find(params[:membership])

     disinvited_student = membership.user

     membership.delete

     # update repository permissions

     grouping = current_user.accepted_grouping_for(@assignment.id)

     grouping.update_repository_permissions

     m_logger = MarkusLogger.instance

     m_logger.log(I18n.t('markus_logger.student_cancelled_invitation', 

                          :inviter => current_user.user_name, 

                          :invitee => disinvited_student.user_name))

   # Deletes memberships which have been declined by students

   def delete_rejected

     @assignment = Assignment.find(params[:id])

     membership = StudentMembership.find(params[:membership])

     grouping = membership.grouping

     if current_user != grouping.inviter

     end

     membership.delete

     membership.save

   def update_collected_submissions

   private 

   def process_assignment_form(assignment, params)

     # accepts_nested_attributes_for is a little...dumb.

     if assignment.submission_rule.attributes['type'] != 

       # Some protective measures here to make sure we haven't been duped...

       potential_rule = 

          Module.const_get(params[:assignment][:submission_rule_attributes][:type])

       if !potential_rule.ancestors.include?(SubmissionRule)

         raise I18n.t("assignment.not_valid_submission_rule", 

       assignment.submission_rule.destroy

       # attribute

       submission_rule.type = 

          params[:assignment][:submission_rule_attributes][:type]

       # to create any new periods manually, like this:

       if !params[:assignment][:submission_rule_attributes][:periods_attributes].nil?

         assignment.submission_rule.periods_attributes = 

       # Is the instructor forming groups?

       if params[:assignment][:student_form_groups] == "0"

       else

         assignment.student_form_groups = true

         assignment.instructor_form_groups = false

     else

       assignment.student_form_groups = false;

       assignment.instructor_form_groups = false;

       assignment.group_min = 1;

     end

   def find_submission_for_test(grouping_id, revision_number)

   # collect the last submission revision

   def automatically_collect_and_prepare_test(grouping, revision_number)

     # must run collec_and_test manually first

     # Once it is time to collect files, student should'nt start to do tests

     if !grouping.assignment.submission_rule.can_collect_now?

       current_submission_used = grouping.submissions.find_by_submission_version_used(true)

       else

     end

   # to do test on his code

   def manually_collect_and_prepare_test(grouping, revision_number)