From 1b30a332308959d403c1f791f56f64b803b6a581 Mon Sep 17 00:00:00 2001
From: Muhammad Anas <88967643+Anas12091101@users.noreply.github.com>
Date: Wed, 22 Oct 2025 19:15:42 +0500
Subject: [PATCH] feat: shift progress calculation to backend, add
never_but_include_grade (#37399)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
This commit migrates the data calculation logic for the GradeSummary
table, which was previously in the frontend-app-learning.
This commit also introduces a new visibility option for assignment
scores: “Never show individual assessment results, but show overall
assessment results after the due date.”
With this option, learners cannot see question-level correctness or
scores at any time. However, once the due date has passed, they can
view their overall score in the total grades section on the Progress
page.
These two changes are coupled with each other because it compromises
the integrity of this data to do the score hiding logic on the front
end.
The corresponding frontend PR is: openedx/frontend-app-learning#1797
---
.../js/show-correctness-editor.underscore | 7 +
.../course_home_api/progress/api.py | 212 ++++++++++++++++++
.../course_home_api/progress/serializers.py | 17 ++
.../progress/tests/test_api.py | 109 ++++++++-
.../progress/tests/test_views.py | 10 +-
.../course_home_api/progress/views.py | 30 ++-
lms/djangoapps/courseware/tests/test_views.py | 27 ++-
lms/djangoapps/grades/subsection_grade.py | 9 +-
lms/templates/courseware/progress.html | 9 +-
xmodule/graders.py | 3 +-
xmodule/tests/test_graders.py | 8 +
11 files changed, 429 insertions(+), 12 deletions(-)
diff --git a/cms/templates/js/show-correctness-editor.underscore b/cms/templates/js/show-correctness-editor.underscore
index 3db6c3c27a5c..1b0dd896747a 100644
--- a/cms/templates/js/show-correctness-editor.underscore
+++ b/cms/templates/js/show-correctness-editor.underscore
@@ -35,6 +35,13 @@
<% } %>
<%- gettext('If the subsection does not have a due date, learners always see their scores when they submit answers to assessments.') %>
+
+
+ <%- gettext('Learners do not see question-level correctness or scores before or after the due date. However, once the due date passes, they can see their overall score for the subsection on the Progress page.') %>
+
diff --git a/lms/djangoapps/course_home_api/progress/api.py b/lms/djangoapps/course_home_api/progress/api.py
index b2a8634c59f4..f89ecd3d2596 100644
--- a/lms/djangoapps/course_home_api/progress/api.py
+++ b/lms/djangoapps/course_home_api/progress/api.py
@@ -2,14 +2,226 @@
Python APIs exposed for the progress tracking functionality of the course home API.
"""
+from __future__ import annotations
+
from django.contrib.auth import get_user_model
from opaque_keys.edx.keys import CourseKey
+from openedx.core.lib.grade_utils import round_away_from_zero
+from xmodule.graders import ShowCorrectness
+from datetime import datetime, timezone
from lms.djangoapps.courseware.courses import get_course_blocks_completion_summary
+from dataclasses import dataclass, field
User = get_user_model()
+@dataclass
+class _AssignmentBucket:
+ """Holds scores and visibility info for one assignment type.
+
+ Attributes:
+ assignment_type: Full assignment type name from the grading policy (for example, "Homework").
+ num_total: The total number of assignments expected to contribute to the grade before any
+ drop-lowest rules are applied.
+ last_grade_publish_date: The most recent date when grades for all assignments of assignment_type
+ are released and included in the final grade.
+ scores: Per-subsection fractional scores (each value is ``earned / possible`` and falls in
+ the range 0–1). While awaiting published content we pad the list with zero placeholders
+ so that its length always matches ``num_total`` until real scores replace them.
+ visibilities: Mirrors ``scores`` index-for-index and records whether each subsection's
+ correctness feedback is visible to the learner (``True``), hidden (``False``), or not
+ yet populated (``None`` when the entry is a placeholder).
+ included: Tracks whether each subsection currently counts toward the learner's grade as
+ determined by ``SubsectionGrade.show_grades``. Values follow the same convention as
+ ``visibilities`` (``True`` / ``False`` / ``None`` placeholders).
+ assignments_created: Count of real subsections inserted into the bucket so far. Once this
+ reaches ``num_total``, all placeholder entries have been replaced with actual data.
+ """
+ assignment_type: str
+ num_total: int
+ last_grade_publish_date: datetime
+ scores: list[float] = field(default_factory=list)
+ visibilities: list[bool | None] = field(default_factory=list)
+ included: list[bool | None] = field(default_factory=list)
+ assignments_created: int = 0
+
+ @classmethod
+ def with_placeholders(cls, assignment_type: str, num_total: int, now: datetime):
+ """Create a bucket prefilled with placeholder (empty) entries."""
+ return cls(
+ assignment_type=assignment_type,
+ num_total=num_total,
+ last_grade_publish_date=now,
+ scores=[0] * num_total,
+ visibilities=[None] * num_total,
+ included=[None] * num_total,
+ )
+
+ def add_subsection(self, score: float, is_visible: bool, is_included: bool):
+ """Add a subsection’s score and visibility, replacing a placeholder if space remains."""
+ if self.assignments_created < self.num_total:
+ if self.scores:
+ self.scores.pop(0)
+ if self.visibilities:
+ self.visibilities.pop(0)
+ if self.included:
+ self.included.pop(0)
+ self.scores.append(score)
+ self.visibilities.append(is_visible)
+ self.included.append(is_included)
+ self.assignments_created += 1
+
+ def drop_lowest(self, num_droppable: int):
+ """Remove the lowest scoring subsections, up to the provided num_droppable."""
+ while num_droppable > 0 and self.scores:
+ idx = self.scores.index(min(self.scores))
+ self.scores.pop(idx)
+ self.visibilities.pop(idx)
+ self.included.pop(idx)
+ num_droppable -= 1
+
+ def hidden_state(self) -> str:
+ """Return whether kept scores are all, some, or none hidden."""
+ if not self.visibilities:
+ return 'none'
+ all_hidden = all(v is False for v in self.visibilities)
+ some_hidden = any(v is False for v in self.visibilities)
+ if all_hidden:
+ return 'all'
+ if some_hidden:
+ return 'some'
+ return 'none'
+
+ def averages(self) -> tuple[float, float]:
+ """Compute visible and included averages over kept scores.
+
+ Visible average uses only grades with visibility flag True in numerator; denominator is total
+ number of kept scores (mirrors legacy behavior). Included average uses only scores that are
+ marked included (show_grades True) in numerator with same denominator.
+
+ Returns:
+ (earned_visible, earned_all) tuple of floats (0-1 each).
+ """
+ if not self.scores:
+ return 0.0, 0.0
+ visible_scores = [s for i, s in enumerate(self.scores) if self.visibilities[i]]
+ included_scores = [s for i, s in enumerate(self.scores) if self.included[i]]
+ earned_visible = (sum(visible_scores) / len(self.scores)) if self.scores else 0.0
+ earned_all = (sum(included_scores) / len(self.scores)) if self.scores else 0.0
+ return earned_visible, earned_all
+
+
+class _AssignmentTypeGradeAggregator:
+ """Collects and aggregates subsection grades by assignment type."""
+
+ def __init__(self, course_grade, grading_policy: dict, has_staff_access: bool):
+ """Initialize with course grades, grading policy, and staff access flag."""
+ self.course_grade = course_grade
+ self.grading_policy = grading_policy
+ self.has_staff_access = has_staff_access
+ self.now = datetime.now(timezone.utc)
+ self.policy_map = self._build_policy_map()
+ self.buckets: dict[str, _AssignmentBucket] = {}
+
+ def _build_policy_map(self) -> dict:
+ """Convert grading policy into a lookup of assignment type → policy info."""
+ policy_map = {}
+ for policy in self.grading_policy.get('GRADER', []):
+ policy_map[policy.get('type')] = {
+ 'weight': policy.get('weight', 0.0),
+ 'short_label': policy.get('short_label', ''),
+ 'num_droppable': policy.get('drop_count', 0),
+ 'num_total': policy.get('min_count', 0),
+ }
+ return policy_map
+
+ def _bucket_for(self, assignment_type: str) -> _AssignmentBucket:
+ """Get or create a score bucket for the given assignment type."""
+ bucket = self.buckets.get(assignment_type)
+ if bucket is None:
+ num_total = self.policy_map.get(assignment_type, {}).get('num_total', 0) or 0
+ bucket = _AssignmentBucket.with_placeholders(assignment_type, num_total, self.now)
+ self.buckets[assignment_type] = bucket
+ return bucket
+
+ def collect(self):
+ """Gather subsection grades into their respective assignment buckets."""
+ for chapter in self.course_grade.chapter_grades.values():
+ for subsection_grade in chapter.get('sections', []):
+ if not getattr(subsection_grade, 'graded', False):
+ continue
+ assignment_type = getattr(subsection_grade, 'format', '') or ''
+ if not assignment_type:
+ continue
+ graded_total = getattr(subsection_grade, 'graded_total', None)
+ earned = getattr(graded_total, 'earned', 0.0) if graded_total else 0.0
+ possible = getattr(graded_total, 'possible', 0.0) if graded_total else 0.0
+ earned = 0.0 if earned is None else earned
+ possible = 0.0 if possible is None else possible
+ score = (earned / possible) if possible else 0.0
+ is_visible = ShowCorrectness.correctness_available(
+ subsection_grade.show_correctness, subsection_grade.due, self.has_staff_access
+ )
+ is_included = subsection_grade.show_grades(self.has_staff_access)
+ bucket = self._bucket_for(assignment_type)
+ bucket.add_subsection(score, is_visible, is_included)
+ visibilities_with_due_dates = [ShowCorrectness.PAST_DUE, ShowCorrectness.NEVER_BUT_INCLUDE_GRADE]
+ if subsection_grade.show_correctness in visibilities_with_due_dates:
+ if subsection_grade.due and subsection_grade.due > bucket.last_grade_publish_date:
+ bucket.last_grade_publish_date = subsection_grade.due
+
+ def build_results(self) -> dict:
+ """Apply drops, compute averages, and return aggregated results and total grade."""
+ final_grades = 0.0
+ rows = []
+ for assignment_type, bucket in self.buckets.items():
+ policy = self.policy_map.get(assignment_type, {})
+ bucket.drop_lowest(policy.get('num_droppable', 0))
+ earned_visible, earned_all = bucket.averages()
+ weight = policy.get('weight', 0.0)
+ short_label = policy.get('short_label', '')
+ row = {
+ 'type': assignment_type,
+ 'weight': weight,
+ 'average_grade': round_away_from_zero(earned_visible, 4),
+ 'weighted_grade': round_away_from_zero(earned_visible * weight, 4),
+ 'short_label': short_label,
+ 'num_droppable': policy.get('num_droppable', 0),
+ 'last_grade_publish_date': bucket.last_grade_publish_date,
+ 'has_hidden_contribution': bucket.hidden_state(),
+ }
+ final_grades += earned_all * weight
+ rows.append(row)
+ rows.sort(key=lambda r: r['weight'])
+ return {'results': rows, 'final_grades': round_away_from_zero(final_grades, 4)}
+
+ def run(self) -> dict:
+ """Execute full pipeline (collect + aggregate) returning final payload."""
+ self.collect()
+ return self.build_results()
+
+
+def aggregate_assignment_type_grade_summary(
+ course_grade,
+ grading_policy: dict,
+ has_staff_access: bool = False,
+) -> dict:
+ """
+ Aggregate subsection grades by assignment type and return summary data.
+ Args:
+ course_grade: CourseGrade object containing chapter and subsection grades.
+ grading_policy: Dictionary representing the course's grading policy.
+ has_staff_access: Boolean indicating if the user has staff access to view all grades.
+ Returns:
+ Dictionary with keys:
+ results: list of per-assignment-type summary dicts
+ final_grades: overall weighted contribution (float, 4 decimal rounding)
+ """
+ aggregator = _AssignmentTypeGradeAggregator(course_grade, grading_policy, has_staff_access)
+ return aggregator.run()
+
+
def calculate_progress_for_learner_in_course(course_key: CourseKey, user: User) -> dict:
"""
Calculate a given learner's progress in the specified course run.
diff --git a/lms/djangoapps/course_home_api/progress/serializers.py b/lms/djangoapps/course_home_api/progress/serializers.py
index 6bdc204434af..c48660a41c6a 100644
--- a/lms/djangoapps/course_home_api/progress/serializers.py
+++ b/lms/djangoapps/course_home_api/progress/serializers.py
@@ -26,6 +26,7 @@ class SubsectionScoresSerializer(ReadOnlySerializer):
assignment_type = serializers.CharField(source='format')
block_key = serializers.SerializerMethodField()
display_name = serializers.CharField()
+ due = serializers.DateTimeField(allow_null=True)
has_graded_assignment = serializers.BooleanField(source='graded')
override = serializers.SerializerMethodField()
learner_has_access = serializers.SerializerMethodField()
@@ -127,6 +128,20 @@ class VerificationDataSerializer(ReadOnlySerializer):
status_date = serializers.DateTimeField()
+class AssignmentTypeScoresSerializer(ReadOnlySerializer):
+ """
+ Serializer for aggregated scores per assignment type.
+ """
+ type = serializers.CharField()
+ weight = serializers.FloatField()
+ average_grade = serializers.FloatField()
+ weighted_grade = serializers.FloatField()
+ last_grade_publish_date = serializers.DateTimeField()
+ has_hidden_contribution = serializers.CharField()
+ short_label = serializers.CharField()
+ num_droppable = serializers.IntegerField()
+
+
class ProgressTabSerializer(VerifiedModeSerializer):
"""
Serializer for progress tab
@@ -146,3 +161,5 @@ class ProgressTabSerializer(VerifiedModeSerializer):
user_has_passing_grade = serializers.BooleanField()
verification_data = VerificationDataSerializer()
disable_progress_graph = serializers.BooleanField()
+ assignment_type_grade_summary = AssignmentTypeScoresSerializer(many=True)
+ final_grades = serializers.FloatField()
diff --git a/lms/djangoapps/course_home_api/progress/tests/test_api.py b/lms/djangoapps/course_home_api/progress/tests/test_api.py
index 30d8d9059eaa..51e7dd68286e 100644
--- a/lms/djangoapps/course_home_api/progress/tests/test_api.py
+++ b/lms/djangoapps/course_home_api/progress/tests/test_api.py
@@ -6,7 +6,80 @@
from django.test import TestCase
-from lms.djangoapps.course_home_api.progress.api import calculate_progress_for_learner_in_course
+from lms.djangoapps.course_home_api.progress.api import (
+ calculate_progress_for_learner_in_course,
+ aggregate_assignment_type_grade_summary,
+)
+from xmodule.graders import ShowCorrectness
+from datetime import datetime, timedelta, timezone
+from types import SimpleNamespace
+
+
+def _make_subsection(fmt, earned, possible, show_corr, *, due_delta_days=None):
+ """Build a lightweight subsection object for testing aggregation scenarios."""
+ graded_total = SimpleNamespace(earned=earned, possible=possible)
+ due = None
+ if due_delta_days is not None:
+ due = datetime.now(timezone.utc) + timedelta(days=due_delta_days)
+ return SimpleNamespace(
+ graded=True,
+ format=fmt,
+ graded_total=graded_total,
+ show_correctness=show_corr,
+ due=due,
+ show_grades=lambda staff: True,
+ )
+
+
+_AGGREGATION_SCENARIOS = [
+ (
+ 'all_visible_always',
+ {'type': 'Homework', 'weight': 1.0, 'drop_count': 0, 'min_count': 2, 'short_label': 'HW'},
+ [
+ _make_subsection('Homework', 1, 1, ShowCorrectness.ALWAYS),
+ _make_subsection('Homework', 0.5, 1, ShowCorrectness.ALWAYS),
+ ],
+ {'avg': 0.75, 'weighted': 0.75, 'hidden': 'none', 'final': 0.75},
+ ),
+ (
+ 'some_hidden_never_but_include',
+ {'type': 'Exam', 'weight': 1.0, 'drop_count': 0, 'min_count': 2, 'short_label': 'EX'},
+ [
+ _make_subsection('Exam', 1, 1, ShowCorrectness.ALWAYS),
+ _make_subsection('Exam', 0.5, 1, ShowCorrectness.NEVER_BUT_INCLUDE_GRADE),
+ ],
+ {'avg': 0.5, 'weighted': 0.5, 'hidden': 'some', 'final': 0.75},
+ ),
+ (
+ 'all_hidden_never_but_include',
+ {'type': 'Quiz', 'weight': 1.0, 'drop_count': 0, 'min_count': 2, 'short_label': 'QZ'},
+ [
+ _make_subsection('Quiz', 0.4, 1, ShowCorrectness.NEVER_BUT_INCLUDE_GRADE),
+ _make_subsection('Quiz', 0.6, 1, ShowCorrectness.NEVER_BUT_INCLUDE_GRADE),
+ ],
+ {'avg': 0.0, 'weighted': 0.0, 'hidden': 'all', 'final': 0.5},
+ ),
+ (
+ 'past_due_mixed_visibility',
+ {'type': 'Lab', 'weight': 1.0, 'drop_count': 0, 'min_count': 2, 'short_label': 'LB'},
+ [
+ _make_subsection('Lab', 0.8, 1, ShowCorrectness.PAST_DUE, due_delta_days=-1),
+ _make_subsection('Lab', 0.2, 1, ShowCorrectness.PAST_DUE, due_delta_days=+3),
+ ],
+ {'avg': 0.4, 'weighted': 0.4, 'hidden': 'some', 'final': 0.5},
+ ),
+ (
+ 'drop_lowest_keeps_high_scores',
+ {'type': 'Project', 'weight': 1.0, 'drop_count': 2, 'min_count': 4, 'short_label': 'PR'},
+ [
+ _make_subsection('Project', 1, 1, ShowCorrectness.ALWAYS),
+ _make_subsection('Project', 1, 1, ShowCorrectness.ALWAYS),
+ _make_subsection('Project', 0, 1, ShowCorrectness.ALWAYS),
+ _make_subsection('Project', 0, 1, ShowCorrectness.ALWAYS),
+ ],
+ {'avg': 1.0, 'weighted': 1.0, 'hidden': 'none', 'final': 1.0},
+ ),
+]
class ProgressApiTests(TestCase):
@@ -73,3 +146,37 @@ def test_calculate_progress_for_learner_in_course_summary_empty(self, mock_get_s
results = calculate_progress_for_learner_in_course("some_course", "some_user")
assert not results
+
+ def test_aggregate_assignment_type_grade_summary_scenarios(self):
+ """
+ A test to verify functionality of aggregate_assignment_type_grade_summary.
+ 1. Test visibility modes (always, never but include grade, past due)
+ 2. Test drop-lowest behavior
+ 3. Test weighting behavior
+ 4. Test final grade calculation
+ 5. Test average grade calculation
+ 6. Test weighted grade calculation
+ 7. Test has_hidden_contribution calculation
+ """
+
+ for case_name, policy, subsections, expected in _AGGREGATION_SCENARIOS:
+ with self.subTest(case_name=case_name):
+ course_grade = SimpleNamespace(chapter_grades={'chapter': {'sections': subsections}})
+ grading_policy = {'GRADER': [policy]}
+
+ result = aggregate_assignment_type_grade_summary(
+ course_grade,
+ grading_policy,
+ has_staff_access=False,
+ )
+
+ assert 'results' in result and 'final_grades' in result
+ assert result['final_grades'] == expected['final']
+ assert len(result['results']) == 1
+
+ row = result['results'][0]
+ assert row['type'] == policy['type'], case_name
+ assert row['average_grade'] == expected['avg']
+ assert row['weighted_grade'] == expected['weighted']
+ assert row['has_hidden_contribution'] == expected['hidden']
+ assert row['num_droppable'] == policy['drop_count']
diff --git a/lms/djangoapps/course_home_api/progress/tests/test_views.py b/lms/djangoapps/course_home_api/progress/tests/test_views.py
index d13ebec29c21..8012e11675f1 100644
--- a/lms/djangoapps/course_home_api/progress/tests/test_views.py
+++ b/lms/djangoapps/course_home_api/progress/tests/test_views.py
@@ -282,8 +282,8 @@ def test_url_hidden_if_subsection_hide_after_due(self):
assert hide_after_due_subsection['url'] is None
@ddt.data(
- (True, 0.7), # midterm and final are visible to staff
- (False, 0.3), # just the midterm is visible to learners
+ (True, 0.72), # lab, midterm and final are visible to staff
+ (False, 0.32), # Only lab and midterm is visible to learners
)
@ddt.unpack
def test_course_grade_considers_subsection_grade_visibility(self, is_staff, expected_percent):
@@ -301,14 +301,18 @@ def test_course_grade_considers_subsection_grade_visibility(self, is_staff, expe
never = self.add_subsection_with_problem(format='Homework', show_correctness='never')
always = self.add_subsection_with_problem(format='Midterm Exam', show_correctness='always')
past_due = self.add_subsection_with_problem(format='Final Exam', show_correctness='past_due', due=tomorrow)
+ never_but_show_grade = self.add_subsection_with_problem(
+ format='Lab', show_correctness='never_but_include_grade'
+ )
answer_problem(self.course, get_mock_request(self.user), never)
answer_problem(self.course, get_mock_request(self.user), always)
answer_problem(self.course, get_mock_request(self.user), past_due)
+ answer_problem(self.course, get_mock_request(self.user), never_but_show_grade)
# First, confirm the grade in the database - it should never change based on user state.
# This is midterm and final and a single problem added together.
- assert CourseGradeFactory().read(self.user, self.course).percent == 0.72
+ assert CourseGradeFactory().read(self.user, self.course).percent == 0.73
response = self.client.get(self.url)
assert response.status_code == 200
diff --git a/lms/djangoapps/course_home_api/progress/views.py b/lms/djangoapps/course_home_api/progress/views.py
index 3783c19061dc..54e71df48cc5 100644
--- a/lms/djangoapps/course_home_api/progress/views.py
+++ b/lms/djangoapps/course_home_api/progress/views.py
@@ -13,8 +13,11 @@
from rest_framework.response import Response
from xmodule.modulestore.django import modulestore
+from xmodule.graders import ShowCorrectness
from common.djangoapps.student.models import CourseEnrollment
from lms.djangoapps.course_home_api.progress.serializers import ProgressTabSerializer
+from lms.djangoapps.course_home_api.progress.api import aggregate_assignment_type_grade_summary
+
from lms.djangoapps.course_home_api.toggles import course_home_mfe_progress_tab_is_active
from lms.djangoapps.courseware.access import has_access, has_ccx_coach_role
from lms.djangoapps.course_blocks.api import get_course_blocks
@@ -99,6 +102,7 @@ class ProgressTabView(RetrieveAPIView):
assignment_type: (str) the format, if any, of the Subsection (Homework, Exam, etc)
block_key: (str) the key of the given subsection block
display_name: (str) a str of what the name of the Subsection is for displaying on the site
+ due: (str or None) the due date of the subsection in ISO 8601 format, or None if no due date is set
has_graded_assignment: (bool) whether or not the Subsection is a graded assignment
learner_has_access: (bool) whether the learner has access to the subsection (could be FBE gated)
num_points_earned: (int) the amount of points the user has earned for the given subsection
@@ -175,6 +179,18 @@ def _get_student_user(self, request, course_key, student_id, is_staff):
except User.DoesNotExist as exc:
raise Http404 from exc
+ def _visible_section_scores(self, course_grade):
+ """Return only those chapter/section scores that are visible to the learner."""
+ visible_chapters = []
+ for chapter in course_grade.chapter_grades.values():
+ filtered_sections = [
+ subsection
+ for subsection in chapter["sections"]
+ if getattr(subsection, "show_correctness", None) != ShowCorrectness.NEVER_BUT_INCLUDE_GRADE
+ ]
+ visible_chapters.append({**chapter, "sections": filtered_sections})
+ return visible_chapters
+
def get(self, request, *args, **kwargs):
course_key_string = kwargs.get('course_key_string')
course_key = CourseKey.from_string(course_key_string)
@@ -245,6 +261,16 @@ def get(self, request, *args, **kwargs):
access_expiration = get_access_expiration_data(request.user, course_overview)
+ # Aggregations delegated to helper functions for reuse and testability
+ assignment_type_grade_summary = aggregate_assignment_type_grade_summary(
+ course_grade,
+ grading_policy,
+ has_staff_access=is_staff,
+ )
+
+ # Filter out section scores to only have those that are visible to the user
+ section_scores = self._visible_section_scores(course_grade)
+
data = {
'access_expiration': access_expiration,
'certificate_data': get_cert_data(student, course, enrollment_mode, course_grade),
@@ -255,12 +281,14 @@ def get(self, request, *args, **kwargs):
'enrollment_mode': enrollment_mode,
'grading_policy': grading_policy,
'has_scheduled_content': has_scheduled_content,
- 'section_scores': list(course_grade.chapter_grades.values()),
+ 'section_scores': section_scores,
'studio_url': get_studio_url(course, 'settings/grading'),
'username': username,
'user_has_passing_grade': user_has_passing_grade,
'verification_data': verification_data,
'disable_progress_graph': disable_progress_graph,
+ 'assignment_type_grade_summary': assignment_type_grade_summary["results"],
+ 'final_grades': assignment_type_grade_summary["final_grades"],
}
context = self.get_serializer_context()
context['staff_access'] = is_staff
diff --git a/lms/djangoapps/courseware/tests/test_views.py b/lms/djangoapps/courseware/tests/test_views.py
index 4e3d1be9bddc..2c3ece3133a5 100644
--- a/lms/djangoapps/courseware/tests/test_views.py
+++ b/lms/djangoapps/courseware/tests/test_views.py
@@ -1781,6 +1781,14 @@ def assert_progress_page_show_grades(self, response, show_correctness, due_date,
(ShowCorrectness.PAST_DUE, TODAY, True),
(ShowCorrectness.PAST_DUE, TOMORROW, False),
(ShowCorrectness.PAST_DUE, TOMORROW, True),
+ (ShowCorrectness.NEVER_BUT_INCLUDE_GRADE, None, False),
+ (ShowCorrectness.NEVER_BUT_INCLUDE_GRADE, None, True),
+ (ShowCorrectness.NEVER_BUT_INCLUDE_GRADE, YESTERDAY, False),
+ (ShowCorrectness.NEVER_BUT_INCLUDE_GRADE, YESTERDAY, True),
+ (ShowCorrectness.NEVER_BUT_INCLUDE_GRADE, TODAY, False),
+ (ShowCorrectness.NEVER_BUT_INCLUDE_GRADE, TODAY, True),
+ (ShowCorrectness.NEVER_BUT_INCLUDE_GRADE, TOMORROW, False),
+ (ShowCorrectness.NEVER_BUT_INCLUDE_GRADE, TOMORROW, True),
)
@ddt.unpack
def test_progress_page_no_problem_scores(self, show_correctness, due_date_name, graded):
@@ -1821,6 +1829,14 @@ def test_progress_page_no_problem_scores(self, show_correctness, due_date_name,
(ShowCorrectness.PAST_DUE, TODAY, True, True),
(ShowCorrectness.PAST_DUE, TOMORROW, False, False),
(ShowCorrectness.PAST_DUE, TOMORROW, True, False),
+ (ShowCorrectness.NEVER_BUT_INCLUDE_GRADE, None, False, False),
+ (ShowCorrectness.NEVER_BUT_INCLUDE_GRADE, None, True, False),
+ (ShowCorrectness.NEVER_BUT_INCLUDE_GRADE, YESTERDAY, False, False),
+ (ShowCorrectness.NEVER_BUT_INCLUDE_GRADE, YESTERDAY, True, False),
+ (ShowCorrectness.NEVER_BUT_INCLUDE_GRADE, TODAY, False, False),
+ (ShowCorrectness.NEVER_BUT_INCLUDE_GRADE, TODAY, True, False),
+ (ShowCorrectness.NEVER_BUT_INCLUDE_GRADE, TOMORROW, False, False),
+ (ShowCorrectness.NEVER_BUT_INCLUDE_GRADE, TOMORROW, True, False),
)
@ddt.unpack
def test_progress_page_hide_scores_from_learner(self, show_correctness, due_date_name, graded, show_grades):
@@ -1873,11 +1889,20 @@ def test_progress_page_hide_scores_from_learner(self, show_correctness, due_date
(ShowCorrectness.PAST_DUE, TODAY, True, True),
(ShowCorrectness.PAST_DUE, TOMORROW, False, True),
(ShowCorrectness.PAST_DUE, TOMORROW, True, True),
+ (ShowCorrectness.NEVER_BUT_INCLUDE_GRADE, None, False, False),
+ (ShowCorrectness.NEVER_BUT_INCLUDE_GRADE, None, True, False),
+ (ShowCorrectness.NEVER_BUT_INCLUDE_GRADE, YESTERDAY, False, False),
+ (ShowCorrectness.NEVER_BUT_INCLUDE_GRADE, YESTERDAY, True, False),
+ (ShowCorrectness.NEVER_BUT_INCLUDE_GRADE, TODAY, False, False),
+ (ShowCorrectness.NEVER_BUT_INCLUDE_GRADE, TODAY, True, False),
+ (ShowCorrectness.NEVER_BUT_INCLUDE_GRADE, TOMORROW, False, False),
+ (ShowCorrectness.NEVER_BUT_INCLUDE_GRADE, TOMORROW, True, False),
)
@ddt.unpack
def test_progress_page_hide_scores_from_staff(self, show_correctness, due_date_name, graded, show_grades):
"""
- Test that problem scores are hidden from staff viewing a learner's progress page only if show_correctness=never.
+ Test that problem scores are hidden from staff viewing a learner's progress page only if show_correctness is
+ never or never_but_include_grade.
"""
due_date = self.DATES[due_date_name]
self.setup_course(show_correctness=show_correctness, due_date=due_date, graded=graded)
diff --git a/lms/djangoapps/grades/subsection_grade.py b/lms/djangoapps/grades/subsection_grade.py
index 4ce0a1f3a463..b0c98497b823 100644
--- a/lms/djangoapps/grades/subsection_grade.py
+++ b/lms/djangoapps/grades/subsection_grade.py
@@ -5,8 +5,8 @@
from abc import ABCMeta
from collections import OrderedDict
+from datetime import datetime, timezone
from logging import getLogger
-
from lazy import lazy
from lms.djangoapps.grades.models import BlockRecord, PersistentSubsectionGrade
@@ -59,6 +59,13 @@ def show_grades(self, has_staff_access):
"""
Returns whether subsection scores are currently available to users with or without staff access.
"""
+ if self.show_correctness == ShowCorrectness.NEVER_BUT_INCLUDE_GRADE:
+ # show_grades fn is used to determine if the grade should be included in final calculation.
+ # For NEVER_BUT_INCLUDE_GRADE, show_grades returns True if the due date has passed,
+ # but correctness_available always returns False as we do not want to show correctness
+ # of problems to the users.
+ return (self.due is None or
+ self.due < datetime.now(timezone.utc))
return ShowCorrectness.correctness_available(self.show_correctness, self.due, has_staff_access)
@property
diff --git a/lms/templates/courseware/progress.html b/lms/templates/courseware/progress.html
index 711fad895427..3ee4044fcbbf 100644
--- a/lms/templates/courseware/progress.html
+++ b/lms/templates/courseware/progress.html
@@ -16,6 +16,7 @@
from lms.djangoapps.grades.api import constants as grades_constants
from openedx.core.djangolib.markup import HTML, Text
from openedx.features.enterprise_support.utils import get_enterprise_learner_generic_name
+from xmodule.graders import ShowCorrectness
%>
<%
@@ -180,7 +181,7 @@
${ chapter['display_name']}
%if hide_url:
${section.display_name}
- %if (total > 0 or earned > 0) and section.show_grades(staff_access):
+ %if (total > 0 or earned > 0) and ShowCorrectness.correctness_available(section.show_correctness, section.due, staff_access):
${_("{earned} of {total} possible points").format(earned='{:.3n}'.format(float(earned)), total='{:.3n}'.format(float(total)))}
@@ -189,14 +190,14 @@