Anjing Webshells

Website : rimsha.abasa.com
: / var / canvas / lib /
Filename : effective_due_dates.rb
back
# frozen_string_literal: true

#
# Copyright (C) 2016 - present Instructure, Inc.
#
# This file is part of Canvas.
#
# Canvas is free software: you can redistribute it and/or modify it under
# the terms of the GNU Affero General Public License as published by the Free
# Software Foundation, version 3 of the License.
#
# Canvas is distributed in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
# A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
# details.
#
# You should have received a copy of the GNU Affero General Public License along
# with this program. If not, see <http://www.gnu.org/licenses/>.

class EffectiveDueDates
  attr_reader :context, :filtered_students

  # This class will find the effective due dates for all students
  # and assignments in a course. You can pass it a list of assignments,
  # assignment id's, or a relation, but they MUST be from the same course.
  # Also cross-shard id's won't work.

  # This class does NOT find the effective due dates for ungraded quizzes
  # which can still have due date overrides.  If the logic in this file
  # needs to be changed, please consider updating the logic in the
  # "ungraded_with_user_due_date" quiz scope

  def initialize(context, *assignment_collection)
    raise "Context must be a course" unless context.is_a?(Course)
    raise "Context must have an id" unless context.id

    @context = context
    @assignments = assignment_collection
  end

  # EffectiveDueDates.for_course(...) just reads more
  # like Canvas code than EffectiveDueDates.new(...)
  singleton_class.send :alias_method, :for_course, :new

  def filter_students_to(*students)
    if students.present?
      students.flatten!
      students.map! { |s| Shard.relative_id_for(s.try(:id) || s, Shard.current, @context.shard) }
      students.compact!
      @filtered_students = students
    end

    self # allows us to chain this method
  end

  def to_hash(included = [])
    return @hash if @hash && included.empty?

    hash = query.each_with_object({}) do |row, hsh|
      assignment_id = row.delete("assignment_id").to_i
      student_id = row.delete("student_id").to_i
      hsh[assignment_id] ||= {}
      attributes = {}
      if include?(included, :due_at)
        attributes[:due_at] = row["due_at"]
      end
      if include?(included, :grading_period_id)
        attributes[:grading_period_id] = row["grading_period_id"] && row["grading_period_id"].to_i
      end
      if include?(included, :in_closed_grading_period)
        attributes[:in_closed_grading_period] = row["closed"]
      end
      if include?(included, :override_id)
        attributes[:override_id] = row["override_id"] && row["override_id"].to_i
      end
      attributes[:override_source] = row["override_type"] if include?(included, :override_source)
      hsh[assignment_id][student_id] = attributes
    end

    @hash = hash if included.empty?
    hash
  end

  # This iterates through a course's EffectiveDueDate hash with multiple
  # assignments to see if any of them are in a closed grading period.
  def any_in_closed_grading_period?
    return @any_in_closed_grading_period unless @any_in_closed_grading_period.nil?

    @any_in_closed_grading_period = @context.grading_periods? &&
                                    to_hash.any? do |_, assignment_due_dates|
                                      any_student_in_closed_grading_period?(assignment_due_dates)
                                    end
  end

  # This iterates through a single assignment's EffectiveDueDate hash to see
  # if any students in them are in a closed grading period.
  def in_closed_grading_period?(assignment_id, student_or_student_id = nil)
    assignment_id = assignment_id.id if assignment_id.is_a?(AbstractAssignment)
    return false if assignment_id.nil?

    # false if there aren't even grading periods set up
    return false unless @context.grading_periods?
    # if we've already checked all assignments and it was false,
    # no need to check this one specifically
    return false if @any_in_closed_grading_period == false

    student_id = student_or_student_id.try(:id) || student_or_student_id
    if student_id.to_i > 0
      find_effective_due_date(student_id, assignment_id).fetch(:in_closed_grading_period, false)
    else
      assignment_due_dates = find_effective_due_dates_for_assignment(assignment_id)
      any_student_in_closed_grading_period?(assignment_due_dates)
    end
  end

  def grading_period_id_for(student_id:, assignment_id:)
    find_effective_due_date(student_id, assignment_id)[:grading_period_id]
  end

  def find_effective_due_date(student_id, assignment_id)
    student_id = Shard.relative_id_for(student_id, Shard.current, @context.shard)
    unless include?(@filtered_students, student_id)
      raise "Student #{student_id} was not included in this query"
    end

    find_effective_due_dates_for_assignment(assignment_id).fetch(student_id, {})
  end

  def find_effective_due_dates_for_assignment(assignment_id)
    to_hash.fetch(Shard.relative_id_for(assignment_id, Shard.current, @context.shard), {})
  end

  private

  def any_student_in_closed_grading_period?(assignment_due_dates)
    return false unless assignment_due_dates

    assignment_due_dates.any? { |_, student| student[:in_closed_grading_period] }
  end

  def include?(included, attribute)
    included.blank? || included.include?(attribute)
  end

  def filter_students_sql(table)
    if @filtered_students.present?
      "AND #{table}.user_id IN (#{filtered_students.join(",")})"
    else
      ""
    end
  end

  def active_in_section_sql
    if Account.site_admin.feature_enabled?(:deprioritize_section_overrides_for_nonactive_enrollments)
      "e.workflow_state = 'active'"
    else
      "TRUE"
    end
  end

  def context_module_overrides
    if Account.site_admin.feature_enabled?(:selective_release_backend)
      "/* fetch all module overrides for this assignment */
      tags AS (
        SELECT
          t.id,
          t.context_module_id,
          t.content_id,
          qt.context_module_id as quiz_context_module_id,
          q.assignment_id as quiz_assignment_id,
          dt.context_module_id as discussion_context_module_id,
          d.assignment_id as discussion_assignment_id
        FROM
          models a
        LEFT JOIN #{ContentTag.quoted_table_name} t ON t.content_id = a.id AND t.content_type = 'Assignment'
        LEFT JOIN #{Quizzes::Quiz.quoted_table_name} q ON q.assignment_id = a.id
        LEFT JOIN #{ContentTag.quoted_table_name} qt ON qt.content_id = q.id AND qt.content_type = 'Quizzes::Quiz'
        LEFT JOIN #{DiscussionTopic.quoted_table_name} d ON d.assignment_id = a.id
        LEFT JOIN #{ContentTag.quoted_table_name} dt ON dt.content_id = d.id AND dt.content_type = 'DiscussionTopic'
        WHERE
          COALESCE(t.tag_type, qt.tag_type, dt.tag_type) = 'context_module'
          AND COALESCE(t.workflow_state, qt.workflow_state, dt.workflow_state) <> 'deleted'
      ),

      modules AS (
        SELECT
          a.id AS item_assignment_id,
          m.id
        FROM
          models a,
          tags t
        INNER JOIN #{ContextModule.quoted_table_name} m ON m.id = COALESCE(t.context_module_id, t.quiz_context_module_id, t.discussion_context_module_id)
        WHERE m.workflow_state <>'deleted'
          AND a.id = COALESCE(t.content_id, t.quiz_assignment_id, t.discussion_assignment_id)
      ),

      module_overrides AS (
        SELECT
          o.id,
          a.id,
          o.set_type,
          o.set_id,
          FALSE,
          a.due_at,
          o.unassign_item
        FROM
          models a,
          tags t,
          modules m
            INNER JOIN #{AssignmentOverride.quoted_table_name} o on o.context_module_id = m.id
        WHERE
           o.workflow_state = 'active' AND m.id = COALESCE(t.context_module_id, t.quiz_context_module_id, t.discussion_context_module_id) AND
           a.id = COALESCE(t.content_id, t.quiz_assignment_id, t.discussion_assignment_id)
      ),"
    else
      ""
    end
  end

  def visible_to_everyone
    if Account.site_admin.feature_enabled?(:selective_release_backend)
      "a.only_visible_to_overrides IS NOT TRUE AND (NOT EXISTS (
        SELECT 1 FROM modules m WHERE m.item_assignment_id = a.id AND m.id IS NOT NULL
        ) OR EXISTS (
        SELECT
          *
        FROM
          tags t,
          modules m
        LEFT JOIN #{AssignmentOverride.quoted_table_name} o on o.context_module_id = m.id AND o.workflow_state = 'active'
        WHERE
          o.context_module_id IS NULL
          AND a.id = COALESCE(t.content_id, t.quiz_assignment_id, t.discussion_assignment_id)
          AND m.id = COALESCE(t.context_module_id, t.quiz_context_module_id, t.discussion_context_module_id)
        )
      )"
    else
      "a.only_visible_to_overrides IS NOT TRUE"
    end
  end

  def union_all_overrides
    if Account.site_admin.feature_enabled?(:selective_release_backend)
      "overrides AS (
        SELECT * FROM assignment_overrides
        UNION ALL
        SELECT * FROM module_overrides
      ),"
    else
      "overrides AS (
        SELECT * FROM assignment_overrides
      ),"
    end
  end

  def course_overrides
    if Account.site_admin.feature_enabled?(:selective_release_backend)
      "/* fetch all students affected by course overrides */
      override_course_students AS (
        SELECT
          e.user_id AS student_id,
          TRUE as active_in_section,
          o.assignment_id,
          o.id AS override_id,
          date_trunc('minute', o.due_at) AS trunc_due_at,
          o.due_at,
          o.set_type AS override_type,
          o.due_at_overridden,
          o.unassign_item,
          2 AS priority
        FROM
          overrides o
        INNER JOIN #{Enrollment.quoted_table_name} e ON e.course_id = o.set_id
        WHERE
          o.set_type = 'Course' AND
          e.workflow_state NOT IN ('rejected', 'deleted') AND
          e.type IN ('StudentEnrollment', 'StudentViewEnrollment')
          #{filter_students_sql("e")}
          ),"
    else
      ""
    end
  end

  def union_course_overrides
    if Account.site_admin.feature_enabled?(:selective_release_backend)
      "SELECT * FROM override_course_students
        UNION ALL"
    else
      ""
    end
  end

  def unassign_item
    if Account.site_admin.feature_enabled?(:selective_release_backend)
      "WHERE
        overrides.unassign_item = FALSE"
    else
      ""
    end
  end

  # This beauty of a method brings together assignment overrides,
  # due dates, grading periods, course/group enrollments, etc
  # to calculate each student's effective due date and whether or
  # not that due date is in a closed grading period. If a student
  # is not included in this hash, that student cannot see this
  # assignment. The format of the returned hash is:
  # {
  #   assignment_id => {
  #     student_id => {
  #       due_at: some date or nil (if assigned but no explicit due date),
  #       grading_period_id: id or nil,
  #       in_closed_grading_period: true or false
  #     }, ...
  #   }, ...
  # }
  def query
    @query ||= @context.shard.activate do
      # default to all active assignments on this course if nothing is passed
      assignment_collection = @assignments.empty? ? [@context.active_assignments] : @assignments

      if assignment_collection.length == 1 &&
         assignment_collection.first.respond_to?(:to_sql) &&
         !assignment_collection.first.loaded?
        # it's a relation, let's not load it unnecessarily out here
        assignment_collection = assignment_collection.first.except(:order).select(:id).to_sql
      else
        # otherwise, map through the array as necessary to get id's
        assignment_collection.flatten!
        assignment_collection.map! { |assignment| assignment.try(:id) } if assignment_collection.first.is_a?(AbstractAssignment)
        assignment_collection.compact!
        if assignment_collection.any? { |id| AbstractAssignment.global_id?(id) }
          assignment_collection = AbstractAssignment.where(id: assignment_collection).pluck(:id)
        end
        assignment_collection = assignment_collection.join(",")
      end

      if assignment_collection.empty?
        {}
      else
        ActiveRecord::Base.connection.select_all(<<~SQL.squish)
          /* fetch the assignment itself */
          WITH models AS (
            SELECT *
            FROM #{AbstractAssignment.quoted_table_name}
            WHERE
              id IN (#{assignment_collection}) AND
              workflow_state <> 'deleted' AND
              context_id = #{@context.id} AND context_type = 'Course'
          ),

          /* fetch all overrides for this assignment */
          assignment_overrides AS (
            SELECT
              o.id,
              o.assignment_id,
              o.set_type,
              o.set_id,
              o.due_at_overridden,
              CASE WHEN o.due_at_overridden IS TRUE THEN o.due_at ELSE a.due_at END AS due_at,
              o.unassign_item
            FROM
              models a
            INNER JOIN #{AssignmentOverride.quoted_table_name} o ON o.assignment_id = a.id
            WHERE
              o.workflow_state = 'active'
          ),

          #{context_module_overrides}

          #{union_all_overrides}

          /* fetch all students affected by adhoc overrides */
          override_adhoc_students AS (
            SELECT
              os.user_id AS student_id,
              TRUE as active_in_section,
              o.assignment_id,
              o.id AS override_id,
              date_trunc('minute', o.due_at) AS trunc_due_at,
              o.due_at,
              o.set_type AS override_type,
              o.due_at_overridden,
              o.unassign_item,
              1 AS priority
            FROM
              overrides o
            INNER JOIN #{AssignmentOverrideStudent.quoted_table_name} os ON os.assignment_override_id = o.id AND
              os.workflow_state = 'active'
            WHERE
              o.set_type = 'ADHOC'
              #{filter_students_sql("os")}
          ),

          /* fetch all students affected by group overrides */
          override_groups_students AS (
            SELECT
              gm.user_id AS student_id,
              TRUE as active_in_section,
              o.assignment_id,
              o.id AS override_id,
              date_trunc('minute', o.due_at) AS trunc_due_at,
              o.due_at,
              o.set_type AS override_type,
              o.due_at_overridden,
              o.unassign_item,
              2 AS priority
            FROM
              overrides o
            INNER JOIN #{Group.quoted_table_name} g ON g.id = o.set_id
            INNER JOIN #{GroupMembership.quoted_table_name} gm ON gm.group_id = g.id
            WHERE
              o.set_type = 'Group' AND
              g.workflow_state <> 'deleted' AND
              gm.workflow_state = 'accepted'
              #{filter_students_sql("gm")}
          ),

          /* fetch all students affected by section overrides */
          override_sections_students AS (
            SELECT
              e.user_id AS student_id,
              #{active_in_section_sql} AS active_in_section,
              o.assignment_id,
              o.id AS override_id,
              date_trunc('minute', o.due_at) AS trunc_due_at,
              o.due_at,
              o.set_type AS override_type,
              o.due_at_overridden,
              o.unassign_item,
              2 AS priority
            FROM
              overrides o
            INNER JOIN #{CourseSection.quoted_table_name} s ON s.id = o.set_id
            INNER JOIN #{Enrollment.quoted_table_name} e ON e.course_section_id = s.id
            WHERE
              o.set_type = 'CourseSection' AND
              s.workflow_state <> 'deleted' AND
              e.workflow_state NOT IN ('rejected', 'deleted') AND
              e.type IN ('StudentEnrollment', 'StudentViewEnrollment')
              #{filter_students_sql("e")}
          ),

          #{course_overrides}

          /* fetch all students who have an 'Everyone Else'
            due date applied to them from the assignment */
          override_everyonelse_students AS (
            SELECT
              e.user_id AS student_id,
              TRUE as active_in_section,
              a.id as assignment_id,
              NULL::integer AS override_id,
              date_trunc('minute', a.due_at) AS trunc_due_at,
              a.due_at,
              'Everyone Else'::varchar AS override_type,
              FALSE AS due_at_overridden,
              FALSE AS unassign_item,
              3 AS priority
            FROM
              models a
            INNER JOIN #{Enrollment.quoted_table_name} e ON e.course_id = a.context_id
            WHERE
              e.workflow_state NOT IN ('rejected', 'deleted') AND
              e.type IN ('StudentEnrollment', 'StudentViewEnrollment') AND
              #{visible_to_everyone}
              #{filter_students_sql("e")}
          ),

          /* join all these students together into a single table */
          override_all_students AS (
            SELECT * FROM override_adhoc_students
            UNION ALL
            SELECT * FROM override_groups_students
            UNION ALL
            SELECT * FROM override_sections_students
            UNION ALL
            #{union_course_overrides}
            SELECT * FROM override_everyonelse_students
          ),

          /* and pick the latest override date as the effective due date */
          calculated_overrides AS (
            SELECT DISTINCT ON (student_id, assignment_id)
              *
            FROM override_all_students
            ORDER BY student_id ASC, assignment_id ASC, active_in_section DESC, due_at_overridden DESC, priority ASC, due_at DESC NULLS FIRST
          ),

          /* now find all grading periods, including both
             legacy course periods and newer account-level periods */
          course_and_account_grading_periods AS (
              SELECT DISTINCT ON (gp.id)
                gp.id,
                date_trunc('minute', gp.start_date) AS start_date,
                date_trunc('minute', gp.end_date) AS end_date,
                date_trunc('minute', gp.close_date) AS close_date,
                gpg.course_id,
                gpg.account_id
              FROM
                models a
              INNER JOIN #{Course.quoted_table_name} c ON c.id = a.context_id
              INNER JOIN #{EnrollmentTerm.quoted_table_name} term ON c.enrollment_term_id = term.id
              LEFT OUTER JOIN #{GradingPeriodGroup.quoted_table_name} gpg ON
                  gpg.course_id = c.id OR gpg.id = term.grading_period_group_id
              LEFT OUTER JOIN #{GradingPeriod.quoted_table_name} gp ON gp.grading_period_group_id = gpg.id
              WHERE
                gpg.workflow_state = 'active' AND
                gp.workflow_state = 'active'
          ),

          /* then filter down to the grading periods we care about:
             if legacy periods exist, only return those. Otherwise,
             return the account-level periods. */
          applied_grading_periods AS (
            SELECT *
            FROM course_and_account_grading_periods
            WHERE
              EXISTS (
                SELECT 1 FROM course_and_account_grading_periods WHERE course_id IS NOT NULL
              ) AND course_id IS NOT NULL
            UNION ALL
            SELECT *
            FROM course_and_account_grading_periods
            WHERE
              NOT EXISTS (
                SELECT 1 FROM course_and_account_grading_periods WHERE course_id IS NOT NULL
              ) AND account_id IS NOT NULL
          ),

          /* infinite due dates are put in the last grading period.
             better to fetch it once since we'll likely reference it multiple times below */
          last_period AS (
            SELECT id, close_date FROM applied_grading_periods ORDER BY end_date DESC LIMIT 1
          )

          /* finally bring it all together! */
          SELECT
            overrides.assignment_id,
            overrides.student_id,
            overrides.due_at,
            overrides.override_type,
            overrides.override_id,
            CASE
              /* check whether or not this due date falls in a closed grading period */
              WHEN overrides.due_at IS NOT NULL AND '#{Time.zone.now.iso8601}'::timestamptz >= periods.close_date THEN TRUE
              /* when no explicit due date is provided, we treat it as if it's in the latest grading period */
              WHEN overrides.due_at IS NULL AND
                  overrides.override_type <> 'Submission' AND
                  '#{Time.zone.now.iso8601}'::timestamptz >= (SELECT close_date FROM last_period) THEN TRUE
              ELSE FALSE
            END AS closed,
            CASE
              /* if infinite due date, put it in the last grading period */
              WHEN overrides.due_at IS NULL AND
                  overrides.override_type <> 'Submission' THEN (SELECT id FROM last_period)
              /* otherwise, put it in whatever grading period id we found for it */
              ELSE periods.id
            END AS grading_period_id
          FROM calculated_overrides overrides
          /* match the effective due date with its grading period */
          LEFT OUTER JOIN applied_grading_periods periods ON
              periods.start_date < overrides.trunc_due_at AND overrides.trunc_due_at <= periods.end_date
          #{unassign_item}
        SQL
      end
    end
  end
end