Merge 73e5962 into 47c4a87

app/helpers/due_date_helper.rb

@@ -10,84 +10,89 @@ def self.deadline_sort(due_dates)
 	def self.default_permission(deadline_type, permission_type)
     	DeadlineRight::DEFAULT_PERMISSION[deadline_type][permission_type]
     end
-
-	def self.calculate_done_in_assignment_round(assignment_id, response)
-	  return 0 if ResponseMap.find(response.map_id).type != 'ReviewResponseMap'
-
-	  due_dates = DueDate.where(parent_id: assignment_id)
-	  sorted_deadlines = deadline_sort(due_dates)
-	  due_dates.reject { |due_date| due_date.deadline_type_id != 1 && due_date.deadline_type_id != 2 }
-	  round = 1
-	  sorted_deadlines.each do |due_date|
-		break if response.created_at < due_date.due_at
-
-		round += 1 if due_date.deadline_type_id == 2
+
+	def self.calculate_assignment_round(assignment_id, response)
+		return 0 unless ResponseMap.find(response.map_id).type == 'ReviewResponseMap'
+
+		due_dates = DueDate.where(parent_id: assignment_id)
+		sorted_deadlines = deadline_sort(due_dates)
+		determine_assignment_round(response, sorted_deadlines)
 	  end
-	  round
-	end
+
+	  def self.determine_assignment_round(response, sorted_due_dates)
+		round = 1
+		sorted_due_dates.each do |due_date|
+		  break if response.created_at < due_date.due_at
+		  round += 1 if due_date.deadline_type_id == 2
+		end
+		round
+	  end
+
 
 	def self.find_current_due_date(due_dates)
     	due_dates.find { |due_date| due_date.due_at > Time.now }
   	end
 
-    def self.is_teammate_review_allowed(student)
-		# time when teammate review is allowed
+	def self.is_teammate_review_allowed(student)
 		due_date = find_current_due_date(student.assignment.due_dates)
-		student.assignment.find_current_stage == 'Finished' ||
-		due_date &&
-			(due_date.teammate_review_allowed_id == 3 ||
-			due_date.teammate_review_allowed_id == 2) # late(2) or yes(3)
-    end
+		return true if student.assignment.find_current_stage == 'Finished'
+		return true if teammate_review_allowed?(due_date)
+
+		false
+	end
+
+	def self.teammate_review_allowed?(due_date)
+		return false unless due_date
 
+		[2, 3].include?(due_date.teammate_review_allowed_id)
+	end
 
-    def self.copy(old_assignment_id, new_assignment_id)
+	def self.copy(old_assignment_id, new_assignment_id)
 		duedates = DueDate.where(parent_id: old_assignment_id)
-		ActiveRecord::Base.transaction do
-			duedates.each do |orig_due_date|
-				new_due_date = orig_due_date.dup
-				new_due_date.parent_id = new_assignment_id
-				new_due_date.save
-      		end
-    	end
-  	end
+
+			ActiveRecord::Base.transaction do
+				duedates.each do |orig_due_date|
+					duplicate_due_date(orig_due_date, new_assignment_id)
+				end
+			end
+		end
+
+	def self.duplicate_due_date(orig_due_date, new_assignment_id)
+		new_due_date = orig_due_date.dup
+		new_due_date.parent_id = new_assignment_id
+		new_due_date.save
+	end
 
-   def self.set_due_date(duedate, deadline, assign_id, max_round)
-		ActiveRecord::Base.transaction do
-		submit_duedate = DueDate.new(duedate)
-		submit_duedate.deadline_type_id = deadline
-		submit_duedate.parent_id = assign_id
-		submit_duedate.round = max_round
-		submit_duedate.save
+	def self.get_next_due_date(assignment_id, topic_id = nil)
+		if Assignment.find(assignment_id).staggered_deadline?
+		  next_due_date = find_next_topic_due_date(assignment_id, topic_id)
+		else
+		  next_due_date = AssignmentDueDate.find_by(['parent_id = ? && due_at >= ?', assignment_id, Time.zone.now])
 		end
-   end
+		next_due_date
+	  end
+
+	  def self.find_next_topic_due_date(assignment_id, topic_id)
+		next_due_date = TopicDueDate.find_by(['parent_id = ? and due_at >= ?', topic_id, Time.zone.now])
+		# if certion TopicDueDate is not exist, we should query next corresponding AssignmentDueDate.
+		# eg. Time.now is 08/28/2016
+		# One topic uses following deadlines:
+		# TopicDueDate      08/01/2016
+		# TopicDueDate      08/02/2016
+		# TopicDueDate      08/03/2016
+		# AssignmentDueDate 09/04/2016
+		# In this case, we cannot find due_at later than Time.now in TopicDueDate.
+		# So we should find next corresponding AssignmentDueDate, starting with the 4th one, not the 1st one!
+		if next_due_date.nil?
+		  topic_due_date_size = TopicDueDate.where(parent_id: topic_id).size
+		  following_assignment_due_dates = AssignmentDueDate.where(parent_id: assignment_id)[topic_due_date_size..-1]
+
+		  if following_assignment_due_dates
+			next_due_date = following_assignment_due_dates.find { |due_date| due_date.due_at >= Time.zone.now }
+		  end
+		end
+
+		next_due_date
+	  end
 
-   def self.get_next_due_date(assignment_id, topic_id = nil)
-    if Assignment.find(assignment_id).staggered_deadline?
-      next_due_date = TopicDueDate.find_by(['parent_id = ? and due_at >= ?', topic_id, Time.zone.now])
-      # if certion TopicDueDate is not exist, we should query next corresponding AssignmentDueDate.
-      # eg. Time.now is 08/28/2016
-      # One topic uses following deadlines:
-      # TopicDueDate      08/01/2016
-      # TopicDueDate      08/02/2016
-      # TopicDueDate      08/03/2016
-      # AssignmentDueDate 09/04/2016
-      # In this case, we cannot find due_at later than Time.now in TopicDueDate.
-      # So we should find next corresponding AssignmentDueDate, starting with the 4th one, not the 1st one!
-      if next_due_date.nil?
-        topic_due_date_size = TopicDueDate.where(parent_id: topic_id).size
-        following_assignment_due_dates = AssignmentDueDate.where(parent_id: assignment_id)[topic_due_date_size..-1]
-        unless following_assignment_due_dates.nil?
-          following_assignment_due_dates.each do |assignment_due_date|
-            if assignment_due_date.due_at >= Time.zone.now
-              next_due_date = assignment_due_date
-              break
-            end
-          end
-        end
-      end
-    else
-      next_due_date = AssignmentDueDate.find_by(['parent_id = ? && due_at >= ?', assignment_id, Time.zone.now])
-    end
-    next_due_date
-    end
 end

app/models/due_date.rb

@@ -2,11 +2,6 @@ class DueDate < ApplicationRecord
   validate :due_at_is_valid_datetime
   # has_paper_trail
 
-  def set_flag
-    self.flag = true
-    save
-  end
-
   # Validates if 'due_at' is a valid datetime, and raises an error if not.
   def due_at_is_valid_datetime
     if due_at.present?

app/views/shared/responses/_response_actions.html.erb

@@ -10,7 +10,7 @@
     <% @latest_response = @sorted_responses.last %>
 
     <% if @latest_response.round.nil? %>
-      <% last_response_round = DueDateHelper.calculate_done_in_assignment_round(@assignment.id, @latest_response) %>
+      <% last_response_round = DueDateHelper.calculate_assignment_round(@assignment.id, @latest_response) %>
     <% else %>
       <% last_response_round = @latest_response.round %>
     <% end %>

app/views/sign_up_sheet/review_bids_others_work.html.erb

@@ -62,7 +62,7 @@
                     <% @latest_response = @sorted_responses.last %>
 
                     <%if @latest_response.round.nil?%>
-                      <% last_response_round = DueDateHelper.calculate_done_in_assignment_round(@assignment.id, @latest_response) %>
+                      <% last_response_round = DueDateHelper.calculate_assignment_round(@assignment.id, @latest_response) %>
                     <%else%>
                       <% last_response_round = @latest_response.round %>
                     <%end%>

app/views/submitted_content/_self_review.html.erb

@@ -31,7 +31,7 @@
                 <% @latest_response = @sorted_responses.last %>
 
                 <% if @latest_response.round.nil? %>
-                    <% last_response_round = DueDateHelper.calculate_done_in_assignment_round(@assignment.id, @latest_response) %>
+                    <% last_response_round = DueDateHelper.calculate_assignment_round(@assignment.id, @latest_response) %>
                 <% else %>
                     <% last_response_round = @latest_response.round %>
                 <% end %>

spec/helpers/due_date_helper_spec.rb

@@ -1,4 +1,14 @@
 describe DueDateHelper do
+	def set_due_date(duedate, deadline, assign_id, max_round)
+		ActiveRecord::Base.transaction do
+		  submit_duedate = DueDate.new(duedate)
+		  submit_duedate.deadline_type_id = deadline
+		  submit_duedate.parent_id = assign_id
+		  submit_duedate.round = max_round
+		  submit_duedate.save
+		end
+	  end
+
 	before(:each) do
 	  @deadline_type = build(:deadline_type)
 	  @deadline_right = build(:deadline_right)
@@ -25,18 +35,90 @@
 		expect(sorted_due_dates.each_cons(2).all? { |m1, m2| (m1.due_at <=> m2.due_at) != 1 }).to eql true
 	end
 
-	describe '#calculate_done_in_assignment_round' do
+	describe '#calculate_assignment_round' do
 		it 'return 0 when no response map' do
 			response = ReviewResponseMap.create
 			response.type = 'ResponseMap'
 			response.save
-			expect(DueDateHelper.calculate_done_in_assignment_round(1, response)).to eql 0
+			expect(DueDateHelper.calculate_assignment_round(1, response)).to eql 0
 		end
 
 		it 'return round 1 for single round' do
 			response = ReviewResponseMap.create
-			expect(DueDateHelper.calculate_done_in_assignment_round(@assignment_due_date.parent_id, response)).to eql 1
+			expect(DueDateHelper.calculate_assignment_round(@assignment_due_date.parent_id, response)).to eql 1
 		end
 	end
-  end
-
+
+	it 'copy due dates to new assignment' do
+		new_assignment_id = build(:assignment, id: 999).id
+		old_assignment_id = @assignment_due_date.assignment.id
+		DueDateHelper.copy(old_assignment_id, new_assignment_id)
+		expect(DueDate.where(parent_id: new_assignment_id).count).to eql DueDate.where(parent_id: old_assignment_id).count
+	  end
+
+	  it 'create new duedate record with values' do
+		set_due_date({ id: 999 }, @assignment_due_date.deadline_type_id,
+						@assignment_due_date.parent_id, @assignment_due_date.round)
+		new_due_date = DueDate.find_by(id: 999)
+		expect(new_due_date).to be_valid
+		expect(new_due_date.deadline_type_id).to eql @assignment_due_date.deadline_type_id
+		expect(new_due_date.parent_id).to eql @assignment_due_date.parent_id
+		expect(new_due_date.round).to eql @assignment_due_date.round
+	  end
+
+	  describe '#get_next_due_date' do
+		it 'no subsequent due date' do
+		  expect(DueDateHelper.get_next_due_date(@assignment_due_date.parent_id)).to be nil
+		end
+
+		it 'nil value throws exception' do
+		  expect { DueDateHelper.get_next_due_date(nil) }.to raise_exception(ActiveRecord::RecordNotFound)
+		end
+
+		it 'get next assignment due date' do
+		  due_date = create(:assignment_due_date, deadline_type: @deadline_type,
+												  submission_allowed_id: @deadline_right.id, review_allowed_id: @deadline_right.id,
+												  review_of_review_allowed_id: @deadline_right.id, due_at: Time.zone.now + 5000)
+		  expect(DueDateHelper.get_next_due_date(due_date.parent_id)).to be_valid
+		end
+
+		it 'get next due date from topic for staggered deadline' do
+		  assignment_id = create(:assignment, staggered_deadline: true, name: 'TestAssignment1', directory_path: 'TestAssignment1').id
+		  due_date = create(:topic_due_date, deadline_type: @deadline_type,
+											 submission_allowed_id: @deadline_right.id, review_allowed_id: @deadline_right.id,
+											 review_of_review_allowed_id: @deadline_right.id, due_at: Time.zone.now + 5000, parent_id: assignment_id)
+		  expect(DueDateHelper.get_next_due_date(assignment_id, due_date.parent_id)).to be_valid
+		end
+
+		it 'next due date does not exist for staggered deadline' do
+		  assignment_id = create(:assignment, staggered_deadline: true, name: 'TestAssignment2', directory_path: 'TestAssignment2').id
+		  expect(DueDateHelper.get_next_due_date(assignment_id)).to be nil
+		end
+
+		it 'next due date is before Time.now for staggered deadline' do
+		  assignment_id = create(:assignment, staggered_deadline: true, name: 'TestAssignment3', directory_path: 'TestAssignment3').id
+		  due_date = create(:topic_due_date, deadline_type: @deadline_type,
+											 submission_allowed_id: @deadline_right, review_allowed_id: @deadline_right,
+											 review_of_review_allowed_id: @deadline_right, due_at: Time.zone.now - 5000, parent_id: assignment_id)
+		  expect(DueDateHelper.get_next_due_date(assignment_id, due_date.parent_id)).to be nil
+		end
+
+		it 'get next due date from assignment for staggered deadline' do
+		  assignment_id = create(:assignment, staggered_deadline: true, name: 'TestAssignment4', directory_path: 'TestAssignment4').id
+		  due_date = create(:assignment_due_date, deadline_type: @deadline_type,
+												  submission_allowed_id: @deadline_right, review_allowed_id: @deadline_right,
+												  review_of_review_allowed_id: @deadline_right, due_at: Time.zone.now + 5000, parent_id: assignment_id)
+		  expect(DueDateHelper.get_next_due_date(assignment_id)).to be_valid
+		end
+	  end
+
+	  it 'metareview review_of_review_allowed default permission OK' do
+		expect(DueDateHelper.default_permission('metareview', 'review_of_review_allowed')).to be == DeadlineRight::OK
+	  end
+
+	  it 'review submission_allowed default permission NO' do
+		expect(DueDateHelper.default_permission('review', 'submission_allowed')).to be == DeadlineRight::NO
+	  end
+
+end
+

spec/models/due_date_spec.rb

@@ -27,82 +27,12 @@
 
   it 'due date flag is set' do
     expect(@assignment_due_date.flag).to be false
-    @assignment_due_date.set_flag
+    @assignment_due_date.flag = true
+    @assignment_due_date.save
     expect(@assignment_due_date.flag).to be true
   end
 
   it 'due at is valid datetime' do
     expect(@assignment_due_date.due_at_is_valid_datetime).to be nil
   end
-
-  it 'copy due dates to new assignment' do
-    new_assignment_id = build(:assignment, id: 999).id
-    old_assignment_id = @assignment_due_date.assignment.id
-    DueDateHelper.copy(old_assignment_id, new_assignment_id)
-    expect(DueDate.where(parent_id: new_assignment_id).count).to eql DueDate.where(parent_id: old_assignment_id).count
-  end
-
-  it 'create new duedate record with values' do
-    DueDateHelper.set_due_date({ id: 999 }, @assignment_due_date.deadline_type_id,
-                        @assignment_due_date.parent_id, @assignment_due_date.round)
-    new_due_date = DueDate.find_by(id: 999)
-    expect(new_due_date).to be_valid
-    expect(new_due_date.deadline_type_id).to eql @assignment_due_date.deadline_type_id
-    expect(new_due_date.parent_id).to eql @assignment_due_date.parent_id
-    expect(new_due_date.round).to eql @assignment_due_date.round
-  end
-
-  describe '#get_next_due_date' do
-    it 'no subsequent due date' do
-      expect(DueDateHelper.get_next_due_date(@assignment_due_date.parent_id)).to be nil
-    end
-
-    it 'nil value throws exception' do
-      expect { DueDateHelper.get_next_due_date(nil) }.to raise_exception(ActiveRecord::RecordNotFound)
-    end
-
-    it 'get next assignment due date' do
-      due_date = create(:assignment_due_date, deadline_type: @deadline_type,
-                                              submission_allowed_id: @deadline_right.id, review_allowed_id: @deadline_right.id,
-                                              review_of_review_allowed_id: @deadline_right.id, due_at: Time.zone.now + 5000)
-      expect(DueDateHelper.get_next_due_date(due_date.parent_id)).to be_valid
-    end
-
-    it 'get next due date from topic for staggered deadline' do
-      assignment_id = create(:assignment, staggered_deadline: true, name: 'TestAssignment1', directory_path: 'TestAssignment1').id
-      due_date = create(:topic_due_date, deadline_type: @deadline_type,
-                                         submission_allowed_id: @deadline_right.id, review_allowed_id: @deadline_right.id,
-                                         review_of_review_allowed_id: @deadline_right.id, due_at: Time.zone.now + 5000, parent_id: assignment_id)
-      expect(DueDateHelper.get_next_due_date(assignment_id, due_date.parent_id)).to be_valid
-    end
-
-    it 'next due date does not exist for staggered deadline' do
-      assignment_id = create(:assignment, staggered_deadline: true, name: 'TestAssignment2', directory_path: 'TestAssignment2').id
-      expect(DueDateHelper.get_next_due_date(assignment_id)).to be nil
-    end
-
-    it 'next due date is before Time.now for staggered deadline' do
-      assignment_id = create(:assignment, staggered_deadline: true, name: 'TestAssignment3', directory_path: 'TestAssignment3').id
-      due_date = create(:topic_due_date, deadline_type: @deadline_type,
-                                         submission_allowed_id: @deadline_right, review_allowed_id: @deadline_right,
-                                         review_of_review_allowed_id: @deadline_right, due_at: Time.zone.now - 5000, parent_id: assignment_id)
-      expect(DueDateHelper.get_next_due_date(assignment_id, due_date.parent_id)).to be nil
-    end
-
-    it 'get next due date from assignment for staggered deadline' do
-      assignment_id = create(:assignment, staggered_deadline: true, name: 'TestAssignment4', directory_path: 'TestAssignment4').id
-      due_date = create(:assignment_due_date, deadline_type: @deadline_type,
-                                              submission_allowed_id: @deadline_right, review_allowed_id: @deadline_right,
-                                              review_of_review_allowed_id: @deadline_right, due_at: Time.zone.now + 5000, parent_id: assignment_id)
-      expect(DueDateHelper.get_next_due_date(assignment_id)).to be_valid
-    end
-  end
-
-  it 'metareview review_of_review_allowed default permission OK' do
-    expect(DueDateHelper.default_permission('metareview', 'review_of_review_allowed')).to be == DeadlineRight::OK
-  end
-
-  it 'review submission_allowed default permission NO' do
-    expect(DueDateHelper.default_permission('review', 'submission_allowed')).to be == DeadlineRight::NO
-  end
 end