reflect moderated grading status in assignment needs grading count

test plan:
* enable moderated grading on a course assignment
* make some student submissions
* the "X needs grading" count on the course and user
 home dashboard sidebars should reflect the provisional
 grading status

i.e. it should decrement for a grader when they've made a
 provisional mark or when other users have made marks and
 no more are needed

closes #CNVS-23232

Change-Id: Iec5ecea8598a1f6e4e53b518f0fdae9273a6a4ee
Reviewed-on: https://gerrit.instructure.com/63442
Reviewed-by: Jeremy Stanley <jeremy@instructure.com>
Tested-by: Jenkins
QA-Review: Jahnavi Yetukuri <jyetukuri@instructure.com>
Product-Review: James Williams  <jamesw@instructure.com>

Author: maneframe

app/models/assignments/needs_grading_count_query.rb

@@ -41,18 +41,50 @@ def count
       assignment.shard.activate do
         # the needs_grading_count trigger should change assignment.updated_at, invalidating the cache
         Rails.cache.fetch(['assignment_user_grading_count', assignment, user].cache_key) do
-          case visibility_level
-          when :full, :limited
-            da_enabled? ? manual_count : assignment.needs_grading_count
-          when :sections
-            section_filtered_submissions.count(:id, distinct: true)
+          if assignment.moderated_grading? && !assignment.grades_published?
+            needs_moderated_grading_count
           else
-            0
+            case visibility_level
+            when :full, :limited
+              da_enabled? ? manual_count : assignment.needs_grading_count
+            when :sections
+              section_filtered_submissions.count(:id, distinct: true)
+            else
+              0
+            end
           end
         end
       end
     end
 
+    def needs_moderated_grading_count
+      level = visibility_level
+      return 0 unless [:full, :limited, :sections].include?(level)
+
+      # ignore submissions this user has graded
+      graded_sub_ids = assignment.submissions.joins(:provisional_grades).
+        where("moderated_grading_provisional_grades.final = ?", false).
+        where("moderated_grading_provisional_grades.scorer_id = ?", user.id).pluck(:id)
+
+      moderation_set_student_ids = assignment.moderated_grading_selections.pluck(:student_id)
+
+      # ignore submissions that are fully graded
+      pg_scope = assignment.submissions.joins(:provisional_grades).
+        where("moderated_grading_provisional_grades.final = ?", false).group("submissions.id", "submissions.user_id")
+      pg_scope = pg_scope.where("submissions.id NOT IN (?)", graded_sub_ids) if graded_sub_ids.any?
+      pg_scope.count.each do |key, count|
+        sub_id, user_id = key
+        graded_sub_ids << sub_id if count >= (moderation_set_student_ids.include?(user_id) ? 2 : 1)
+      end
+
+      scope = (level == :sections) ? section_filtered_submissions : all_submissions
+      if graded_sub_ids.any?
+        scope.where("submissions.id NOT IN (?)", graded_sub_ids).count(:id, distinct: true)
+      else
+        scope.count(:id, distinct: true)
+      end
+    end
+
     def count_by_section
       assignment.shard.activate do
         Rails.cache.fetch(['assignment_user_grading_count_by_section', assignment, user].cache_key) do

app/models/moderated_grading/provisional_grade.rb

@@ -15,10 +15,16 @@ class ModeratedGrading::ProvisionalGrade < ActiveRecord::Base
   validates :scorer, presence: true
   validates :submission, presence: true
 
+  after_create :touch_graders # to update grading counts
+
   scope :scored_by, ->(scorer) { where(scorer_id: scorer) }
   scope :final, -> { where(:final => true)}
   scope :not_final, -> { where(:final => false)}
 
+  def touch_graders
+    submission.touch_graders
+  end
+
   def valid?(*)
     infer_grade
     set_graded_at if @force_save || grade_changed? || score_changed?

spec/models/assignments/needs_grading_count_query_spec.rb

@@ -109,6 +109,49 @@ module Assignments
           expect(count[:needs_grading_count]).to eql(1)
         end
       end
+
+      context "moderated grading count" do
+        before do
+          @assignment = @course.assignments.create(:title => "some assignment",
+            :submission_types => ['online_text_entry'], :moderated_grading => true)
+          @students = []
+          3.times do
+            student = student_in_course(:course => @course, :active_all => true).user
+            @assignment.submit_homework(student, :submission_type => "online_text_entry", :body => "o hai")
+            @students << student
+          end
+
+          @ta1 = ta_in_course(:course => course, :active_all => true).user
+          @ta2 = ta_in_course(:course => course, :active_all => true).user
+        end
+
+        it "should only include students with no marks when unmoderated" do
+          querier = NeedsGradingCountQuery.new(@assignment, @teacher)
+          expect(querier.count).to eq 3
+
+          @students[0].submissions.first.find_or_create_provisional_grade!(scorer: @teacher)
+          expect(querier.count).to eq 2
+
+          @students[1].submissions.first.find_or_create_provisional_grade!(scorer: @ta1)
+          expect(querier.count).to eq 1
+        end
+
+        it "should only include students without two marks when moderated" do
+          @students.each{|s| @assignment.moderated_grading_selections.create!(:student => s)}
+
+          querier = NeedsGradingCountQuery.new(@assignment, @teacher)
+          expect(querier.count).to eq 3
+
+          @students[0].submissions.first.find_or_create_provisional_grade!(scorer: @teacher)
+          expect(querier.count).to eq 2 # should not show because @teacher graded it
+
+          @students[1].submissions.first.find_or_create_provisional_grade!(scorer: @ta1)
+          expect(querier.count).to eq 2 # should still count because it needs another mark
+
+          @students[1].submissions.first.find_or_create_provisional_grade!(scorer: @ta2)
+          expect(querier.count).to eq 1 # should not count because it has two marks now
+        end
+      end
     end
   end
 end