chore(deps): bump actions/setup-node from 4 to 6

Bumps [actions/setup-node](https://github.com/actions/setup-node) from 4 to 6.
- [Release notes](https://github.com/actions/setup-node/releases)
- [Commits](https://github.com/actions/setup-node/compare/v4...v6)

---
updated-dependencies:
- dependency-name: actions/setup-node
  dependency-version: '6'
  dependency-type: direct:production
  update-type: version-update:semver-major
...

Signed-off-by: dependabot[bot] <support@github.com>

.github/workflows/validate.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v5
-    - uses: actions/setup-node@v4
+    - uses: actions/setup-node@v6
       with:
         node-version-file: '.nvmrc'
     - run: make validate.ci

src/course-home/data/__factories__/progressTabData.factory.js

@@ -17,21 +17,7 @@ Factory.define('progressTabData')
       percent: 1,
       is_passing: true,
     },
-    final_grades: 0.5,
     credit_course_requirements: null,
-    assignment_type_grade_summary: [
-      {
-        type: 'Homework',
-        short_label: 'HW',
-        weight: 1,
-        average_grade: 1,
-        weighted_grade: 1,
-        num_droppable: 1,
-        num_total: 2,
-        has_hidden_contribution: 'none',
-        last_grade_publish_date: null,
-      },
-    ],
     section_scores: [
       {
         display_name: 'First section',

src/course-home/data/api.js

@@ -3,6 +3,93 @@ import { getAuthenticatedHttpClient } from '@edx/frontend-platform/auth';
 import { logInfo } from '@edx/frontend-platform/logging';
 import { appendBrowserTimezoneToUrl } from '../../utils';
 
+const calculateAssignmentTypeGrades = (points, assignmentWeight, numDroppable) => {
+  let dropCount = numDroppable;
+  // Drop the lowest grades
+  while (dropCount && points.length >= dropCount) {
+    const lowestScore = Math.min(...points);
+    const lowestScoreIndex = points.indexOf(lowestScore);
+    points.splice(lowestScoreIndex, 1);
+    dropCount--;
+  }
+  let averageGrade = 0;
+  let weightedGrade = 0;
+  if (points.length) {
+    // Calculate the average grade for the assignment and round it. This rounding is not ideal and does not accurately
+    // reflect what a learner's grade would be, however, we must have parity with the current grading behavior that
+    // exists in edx-platform.
+    averageGrade = (points.reduce((a, b) => a + b, 0) / points.length).toFixed(4);
+    weightedGrade = averageGrade * assignmentWeight;
+  }
+  return { averageGrade, weightedGrade };
+};
+
+function normalizeAssignmentPolicies(assignmentPolicies, sectionScores) {
+  const gradeByAssignmentType = {};
+  assignmentPolicies.forEach(assignment => {
+    // Create an array with the number of total assignments and set the scores to 0
+    // as placeholders for assignments that have not yet been released
+    gradeByAssignmentType[assignment.type] = {
+      grades: Array(assignment.numTotal).fill(0),
+      numAssignmentsCreated: 0,
+      numTotalExpectedAssignments: assignment.numTotal,
+    };
+  });
+
+  sectionScores.forEach((chapter) => {
+    chapter.subsections.forEach((subsection) => {
+      if (!(subsection.hasGradedAssignment && subsection.showGrades && subsection.numPointsPossible)) {
+        return;
+      }
+      const {
+        assignmentType,
+        numPointsEarned,
+        numPointsPossible,
+      } = subsection;
+
+      // If a subsection's assignment type does not match an assignment policy in Studio,
+      // we won't be able to include it in this accumulation of grades by assignment type.
+      // This may happen if a course author has removed/renamed an assignment policy in Studio and
+      // neglected to update the subsection's of that assignment type
+      if (!gradeByAssignmentType[assignmentType]) {
+        return;
+      }
+
+      let {
+        numAssignmentsCreated,
+      } = gradeByAssignmentType[assignmentType];
+
+      numAssignmentsCreated++;
+      if (numAssignmentsCreated <= gradeByAssignmentType[assignmentType].numTotalExpectedAssignments) {
+        // Remove a placeholder grade so long as the number of recorded created assignments is less than the number
+        // of expected assignments
+        gradeByAssignmentType[assignmentType].grades.shift();
+      }
+      // Add the graded assignment to the list
+      gradeByAssignmentType[assignmentType].grades.push(numPointsEarned ? numPointsEarned / numPointsPossible : 0);
+      // Record the created assignment
+      gradeByAssignmentType[assignmentType].numAssignmentsCreated = numAssignmentsCreated;
+    });
+  });
+
+  return assignmentPolicies.map((assignment) => {
+    const { averageGrade, weightedGrade } = calculateAssignmentTypeGrades(
+      gradeByAssignmentType[assignment.type].grades,
+      assignment.weight,
+      assignment.numDroppable,
+    );
+
+    return {
+      averageGrade,
+      numDroppable: assignment.numDroppable,
+      shortLabel: assignment.shortLabel,
+      type: assignment.type,
+      weight: assignment.weight,
+      weightedGrade,
+    };
+  });
+}
+
 /**
  * Tweak the metadata for consistency
  * @param metadata the data to normalize
@@ -149,6 +236,11 @@ export async function getProgressTabData(courseId, targetUserId) {
     const { data } = await getAuthenticatedHttpClient().get(url);
     const camelCasedData = camelCaseObject(data);
 
+    camelCasedData.gradingPolicy.assignmentPolicies = normalizeAssignmentPolicies(
+      camelCasedData.gradingPolicy.assignmentPolicies,
+      camelCasedData.sectionScores,
+    );
+
     // We replace gradingPolicy.gradeRange with the original data to preserve the intended casing for the grade.
     // For example, if a grade range key is "A", we do not want it to be camel cased (i.e. "A" would become "a")
     // in order to preserve a course team's desired grade formatting.

src/course-home/progress-tab/ProgressTab.test.jsx

@@ -661,133 +661,143 @@ describe('Progress Tab', () => {
       expect(screen.getByText('Grade summary')).toBeInTheDocument();
     });
 
-    it('does not render Grade Summary when assignment type grade summary is not populated', async () => {
+    it('does not render Grade Summary when assignment policies are not populated', async () => {
       setTabData({
-        assignment_type_grade_summary: [],
+        grading_policy: {
+          assignment_policies: [],
+          grade_range: {
+            pass: 0.75,
+          },
+        },
+        section_scores: [],
       });
       await fetchAndRender();
       expect(screen.queryByText('Grade summary')).not.toBeInTheDocument();
     });
 
-    it('shows lock icon when all subsections of assignment type are hidden', async () => {
+    it('calculates grades correctly when number of droppable assignments equals total number of assignments', async () => {
       setTabData({
         grading_policy: {
           assignment_policies: [
+            {
+              num_droppable: 2,
+              num_total: 2,
+              short_label: 'HW',
+              type: 'Homework',
+              weight: 1,
+            },
+          ],
+          grade_range: {
+            pass: 0.75,
+          },
+        },
+      });
+      await fetchAndRender();
+      expect(screen.getByText('Grade summary')).toBeInTheDocument();
+      // The row is comprised of "{Assignment type} {footnote - optional} {weight} {grade} {weighted grade}"
+      expect(screen.getByRole('row', { name: 'Homework 1 100% 0% 0%' })).toBeInTheDocument();
+    });
+    it('calculates grades correctly when number of droppable assignments is less than total number of assignments', async () => {
+      await fetchAndRender();
+      expect(screen.getByText('Grade summary')).toBeInTheDocument();
+      // The row is comprised of "{Assignment type} {footnote - optional} {weight} {grade} {weighted grade}"
+      expect(screen.getByRole('row', { name: 'Homework 1 100% 100% 100%' })).toBeInTheDocument();
+    });
+    it('calculates grades correctly when number of droppable assignments is zero', async () => {
+      setTabData({
+        grading_policy: {
+          assignment_policies: [
+            {
+              num_droppable: 0,
+              num_total: 2,
+              short_label: 'HW',
+              type: 'Homework',
+              weight: 1,
+            },
+          ],
+          grade_range: {
+            pass: 0.75,
+          },
+        },
+      });
+      await fetchAndRender();
+      expect(screen.getByText('Grade summary')).toBeInTheDocument();
+      // The row is comprised of "{Assignment type} {weight} {grade} {weighted grade}"
+      expect(screen.getByRole('row', { name: 'Homework 100% 50% 50%' })).toBeInTheDocument();
+    });
+    it('calculates grades correctly when number of total assignments is less than the number of assignments created', async () => {
+      setTabData({
+        grading_policy: {
+          assignment_policies: [
+            {
+              num_droppable: 1,
+              num_total: 1, // two assignments created in the factory, but 1 is expected per Studio settings
+              short_label: 'HW',
+              type: 'Homework',
+              weight: 1,
+            },
+          ],
+          grade_range: {
+            pass: 0.75,
+          },
+        },
+      });
+      await fetchAndRender();
+      expect(screen.getByText('Grade summary')).toBeInTheDocument();
+      // The row is comprised of "{Assignment type} {footnote - optional} {weight} {grade} {weighted grade}"
+      expect(screen.getByRole('row', { name: 'Homework 1 100% 100% 100%' })).toBeInTheDocument();
+    });
+    it('calculates grades correctly when number of total assignments is greater than the number of assignments created', async () => {
+      setTabData({
+        grading_policy: {
+          assignment_policies: [
+            {
+              num_droppable: 0,
+              num_total: 5, // two assignments created in the factory, but 5 are expected per Studio settings
+              short_label: 'HW',
+              type: 'Homework',
+              weight: 1,
+            },
+          ],
+          grade_range: {
+            pass: 0.75,
+          },
+        },
+      });
+      await fetchAndRender();
+      expect(screen.getByText('Grade summary')).toBeInTheDocument();
+      // The row is comprised of "{Assignment type} {weight} {grade} {weighted grade}"
+      expect(screen.getByRole('row', { name: 'Homework 100% 20% 20%' })).toBeInTheDocument();
+    });
+    it('calculates weighted grades correctly', async () => {
+      setTabData({
+        grading_policy: {
+          assignment_policies: [
+            {
+              num_droppable: 1,
+              num_total: 2,
+              short_label: 'HW',
+              type: 'Homework',
+              weight: 0.5,
+            },
             {
               num_droppable: 0,
               num_total: 1,
-              short_label: 'Final',
-              type: 'Final Exam',
-              weight: 1,
+              short_label: 'Ex',
+              type: 'Exam',
+              weight: 0.5,
             },
           ],
           grade_range: {
             pass: 0.75,
           },
         },
-        assignment_type_grade_summary: [
-          {
-            type: 'Final Exam',
-            weight: 0.4,
-            average_grade: 0.0,
-            weighted_grade: 0.0,
-            last_grade_publish_date: '2025-10-15T14:17:04.368903Z',
-            has_hidden_contribution: 'all',
-            short_label: 'Final',
-            num_droppable: 0,
-          },
-        ],
       });
       await fetchAndRender();
-      // Should show lock icon for grade and weighted grade
-      expect(screen.getAllByTestId('lock-icon')).toHaveLength(2);
-    });
-
-    it('shows percent plus hidden grades when some subsections of assignment type are hidden', async () => {
-      setTabData({
-        grading_policy: {
-          assignment_policies: [
-            {
-              num_droppable: 0,
-              num_total: 2,
-              short_label: 'HW',
-              type: 'Homework',
-              weight: 1,
-            },
-          ],
-          grade_range: {
-            pass: 0.75,
-          },
-        },
-        assignment_type_grade_summary: [
-          {
-            type: 'Homework',
-            weight: 1,
-            average_grade: 0.25,
-            weighted_grade: 0.25,
-            last_grade_publish_date: '2025-10-15T14:17:04.368903Z',
-            has_hidden_contribution: 'some',
-            short_label: 'HW',
-            num_droppable: 0,
-          },
-        ],
-      });
-      await fetchAndRender();
-      // Should show percent + hidden scores for grade and weighted grade
-      const hiddenScoresCells = screen.getAllByText(/% \+ Hidden Scores/);
-      expect(hiddenScoresCells).toHaveLength(2);
-      // Only correct visible scores should be shown (from subsection2)
-      // The correct visible score is 1/4 = 0.25 -> 25%
-      expect(hiddenScoresCells[0]).toHaveTextContent('25% + Hidden Scores');
-      expect(hiddenScoresCells[1]).toHaveTextContent('25% + Hidden Scores');
-    });
-
-    it('displays a warning message with the latest due date when not all assignment scores are included in the total grade', async () => {
-      setTabData({
-        grading_policy: {
-          assignment_policies: [
-            {
-              num_droppable: 0,
-              num_total: 2,
-              short_label: 'HW',
-              type: 'Homework',
-              weight: 1,
-            },
-          ],
-          grade_range: {
-            pass: 0.75,
-          },
-        },
-        assignment_type_grade_summary: [
-          {
-            type: 'Homework',
-            weight: 1,
-            average_grade: 1,
-            weighted_grade: 1,
-            last_grade_publish_date: tomorrow.toISOString(),
-            has_hidden_contribution: 'none',
-            short_label: 'HW',
-            num_droppable: 0,
-          },
-        ],
-      });
-
-      await fetchAndRender();
-
-      const formattedDateTime = new Intl.DateTimeFormat('en', {
-        year: 'numeric',
-        month: 'long',
-        day: 'numeric',
-        hour: 'numeric',
-        minute: 'numeric',
-        timeZoneName: 'short',
-      }).format(tomorrow);
-
-      expect(
-        screen.getByText(
-          `Some assignment scores are not yet included in your total grade. These grades will be released by ${formattedDateTime}.`,
-        ),
-      ).toBeInTheDocument();
+      expect(screen.getByText('Grade summary')).toBeInTheDocument();
+      // The row is comprised of "{Assignment type} {footnote - optional} {weight} {grade} {weighted grade}"
+      expect(screen.getByRole('row', { name: 'Homework 1 50% 100% 50%' })).toBeInTheDocument();
+      expect(screen.getByRole('row', { name: 'Exam 50% 0% 0%' })).toBeInTheDocument();
     });
 
     it('renders override notice', async () => {

src/course-home/progress-tab/grades/course-grade/CourseGradeFooter.jsx

@@ -8,57 +8,26 @@ import { useModel } from '../../../../generic/model-store';
 
 import GradeRangeTooltip from './GradeRangeTooltip';
 import messages from '../messages';
-import { getLatestDueDateInFuture } from '../../utils';
-
-const ResponsiveText = ({
-  wideScreen, children, hasLetterGrades, passingGrade,
-}) => {
-  const className = wideScreen ? 'h4 m-0 align-bottom' : 'h5 align-bottom';
-  const iconSize = wideScreen ? 'h3' : 'h4';
-
-  return (
-    <span className={className}>
-      {children}
-      {hasLetterGrades && (
-        <span style={{ whiteSpace: 'nowrap' }}>
-          &nbsp;
-          <GradeRangeTooltip iconButtonClassName={iconSize} passingGrade={passingGrade} />
-        </span>
-      )}
-    </span>
-  );
-};
-
-const NoticeRow = ({
-  wideScreen, icon, bgClass, message,
-}) => {
-  const textClass = wideScreen ? 'h4 m-0 align-bottom' : 'h5 align-bottom';
-  return (
-    <div className={`row w-100 m-0 px-4 py-3 py-md-4 rounded-bottom ${bgClass}`}>
-      <div className="col-auto p-0">{icon}</div>
-      <div className="col-11 pl-2 px-0">
-        <span className={textClass}>{message}</span>
-      </div>
-    </div>
-  );
-};
 
 const CourseGradeFooter = ({ passingGrade }) => {
   const intl = useIntl();
   const courseId = useContextId();
 
   const {
-    assignmentTypeGradeSummary,
-    courseGrade: { isPassing, letterGrade },
-    gradingPolicy: { gradeRange },
+    courseGrade: {
+      isPassing,
+      letterGrade,
+    },
+    gradingPolicy: {
+      gradeRange,
+    },
   } = useModel('progress', courseId);
 
-  const latestDueDate = getLatestDueDateInFuture(assignmentTypeGradeSummary);
   const wideScreen = useWindowSize().width >= breakpoints.medium.minWidth;
-  const hasLetterGrades = Object.keys(gradeRange).length > 1;
 
-  // build footer text
+  const hasLetterGrades = Object.keys(gradeRange).length > 1; // A pass/fail course will only have one key
   let footerText = intl.formatMessage(messages.courseGradeFooterNonPassing, { passingGrade });
+
   if (isPassing) {
     if (hasLetterGrades) {
       const minGradeRangeCutoff = gradeRange[letterGrade] * 100;
@@ -78,63 +47,42 @@ const CourseGradeFooter = ({ passingGrade }) => {
     }
   }
 
-  const passingIcon = isPassing ? (
-    <Icon src={CheckCircle} className="text-success-300 d-inline-flex align-bottom" />
-  ) : (
-    <Icon src={WarningFilled} className="d-inline-flex align-bottom" />
-  );
+  const icon = isPassing ? <Icon src={CheckCircle} className="text-success-300 d-inline-flex align-bottom" />
+    : <Icon src={WarningFilled} className="d-inline-flex align-bottom" />;
 
   return (
-    <div>
-      <NoticeRow
-        wideScreen={wideScreen}
-        icon={passingIcon}
-        bgClass={isPassing ? 'bg-success-100' : 'bg-warning-100'}
-        message={(
-          <ResponsiveText
-            wideScreen={wideScreen}
-            hasLetterGrades={hasLetterGrades}
-            passingGrade={passingGrade}
-          >
+    <div className={`row w-100 m-0 px-4 py-3 py-md-4 rounded-bottom ${isPassing ? 'bg-success-100' : 'bg-warning-100'}`}>
+      <div className="col-auto p-0">
+        {icon}
+      </div>
+      <div className="col-11 pl-2 px-0">
+        {!wideScreen && (
+          <span className="h5 align-bottom">
             {footerText}
-          </ResponsiveText>
+            {hasLetterGrades && (
+              <span style={{ whiteSpace: 'nowrap' }}>
+                &nbsp;
+                <GradeRangeTooltip iconButtonClassName="h4" passingGrade={passingGrade} />
+              </span>
+            )}
+          </span>
         )}
-      />
-      {latestDueDate && (
-        <NoticeRow
-          wideScreen={wideScreen}
-          icon={<Icon src={WarningFilled} className="d-inline-flex align-bottom" />}
-          bgClass="bg-warning-100"
-          message={intl.formatMessage(messages.courseGradeFooterDueDateNotice, {
-            dueDate: intl.formatDate(latestDueDate, {
-              year: 'numeric',
-              month: 'long',
-              day: 'numeric',
-              hour: 'numeric',
-              minute: 'numeric',
-              timeZoneName: 'short',
-            }),
-          })}
-        />
-      )}
+        {wideScreen && (
+          <span className="h4 m-0 align-bottom">
+            {footerText}
+            {hasLetterGrades && (
+              <span style={{ whiteSpace: 'nowrap' }}>
+                &nbsp;
+                <GradeRangeTooltip iconButtonClassName="h3" passingGrade={passingGrade} />
+              </span>
+            )}
+          </span>
+        )}
+      </div>
     </div>
   );
 };
 
-ResponsiveText.propTypes = {
-  wideScreen: PropTypes.bool.isRequired,
-  children: PropTypes.node.isRequired,
-  hasLetterGrades: PropTypes.bool.isRequired,
-  passingGrade: PropTypes.number.isRequired,
-};
-
-NoticeRow.propTypes = {
-  wideScreen: PropTypes.bool.isRequired,
-  icon: PropTypes.element.isRequired,
-  bgClass: PropTypes.string.isRequired,
-  message: PropTypes.string.isRequired,
-};
-
 CourseGradeFooter.propTypes = {
   passingGrade: PropTypes.number.isRequired,
 };

src/course-home/progress-tab/grades/course-grade/CurrentGradeTooltip.jsx

@@ -13,7 +13,6 @@ const CurrentGradeTooltip = ({ tooltipClassName }) => {
   const courseId = useContextId();
 
   const {
-    assignmentTypeGradeSummary,
     courseGrade: {
       isPassing,
       percent,
@@ -26,8 +25,6 @@ const CurrentGradeTooltip = ({ tooltipClassName }) => {
 
   const isLocaleRtl = isRtl(getLocale());
 
-  const hasHiddenGrades = assignmentTypeGradeSummary.some((assignmentType) => assignmentType.hasHiddenContribution !== 'none');
-
   if (isLocaleRtl) {
     currentGradeDirection = currentGrade < 50 ? '-' : '';
   }
@@ -59,15 +56,6 @@ const CurrentGradeTooltip = ({ tooltipClassName }) => {
       >
         {intl.formatMessage(messages.currentGradeLabel)}
       </text>
-      <text
-        className="x-small"
-        textAnchor={currentGrade < 50 ? 'start' : 'end'}
-        x={`${Math.min(...[isLocaleRtl ? 100 - currentGrade : currentGrade, 100])}%`}
-        y="35px"
-        style={{ transform: `translateX(${currentGradeDirection}3.4em)` }}
-      >
-        {hasHiddenGrades ? ` + ${intl.formatMessage(messages.hiddenScoreLabel)}` : ''}
-      </text>
     </>
   );
 };

src/course-home/progress-tab/grades/grade-summary/GradeSummary.jsx

@@ -10,12 +10,14 @@ const GradeSummary = () => {
   const courseId = useContextId();
 
   const {
-    assignmentTypeGradeSummary,
+    gradingPolicy: {
+      assignmentPolicies,
+    },
   } = useModel('progress', courseId);
 
   const [allOfSomeAssignmentTypeIsLocked, setAllOfSomeAssignmentTypeIsLocked] = useState(false);
 
-  if (assignmentTypeGradeSummary.length === 0) {
+  if (assignmentPolicies.length === 0) {
     return null;
   }
 

src/course-home/progress-tab/grades/grade-summary/GradeSummaryTable.jsx

@@ -2,7 +2,6 @@ import PropTypes from 'prop-types';
 
 import { getLocale, isRtl, useIntl } from '@edx/frontend-platform/i18n';
 import { DataTable } from '@openedx/paragon';
-import { Lock } from '@openedx/paragon/icons';
 import { useContextId } from '../../../../data/hooks';
 import { useModel } from '../../../../generic/model-store';
 
@@ -17,7 +16,9 @@ const GradeSummaryTable = ({ setAllOfSomeAssignmentTypeIsLocked }) => {
   const courseId = useContextId();
 
   const {
-    assignmentTypeGradeSummary,
+    gradingPolicy: {
+      assignmentPolicies,
+    },
     gradesFeatureIsFullyLocked,
     sectionScores,
   } = useModel('progress', courseId);
@@ -54,7 +55,7 @@ const GradeSummaryTable = ({ setAllOfSomeAssignmentTypeIsLocked }) => {
     return false;
   };
 
-  const gradeSummaryData = assignmentTypeGradeSummary.map((assignment) => {
+  const gradeSummaryData = assignmentPolicies.map((assignment) => {
     const {
       averageGrade,
       numDroppable,
@@ -79,24 +80,13 @@ const GradeSummaryTable = ({ setAllOfSomeAssignmentTypeIsLocked }) => {
     const locked = !gradesFeatureIsFullyLocked && hasNoAccessToAssignmentsOfType(assignmentType);
     const isLocaleRtl = isRtl(getLocale());
 
-    let weightedGradeDisplay = `${getGradePercent(weightedGrade)}${isLocaleRtl ? '\u200f' : ''}%`;
-    let gradeDisplay = `${getGradePercent(averageGrade)}${isLocaleRtl ? '\u200f' : ''}%`;
-
-    if (assignment.hasHiddenContribution === 'all') {
-      gradeDisplay = <Lock data-testid="lock-icon" />;
-      weightedGradeDisplay = <Lock data-testid="lock-icon" />;
-    } else if (assignment.hasHiddenContribution === 'some') {
-      gradeDisplay = `${getGradePercent(averageGrade)}${isLocaleRtl ? '\u200f' : ''}% + ${intl.formatMessage(messages.hiddenScoreLabel)}`;
-      weightedGradeDisplay = `${getGradePercent(weightedGrade)}${isLocaleRtl ? '\u200f' : ''}% + ${intl.formatMessage(messages.hiddenScoreLabel)}`;
-    }
-
     return {
       type: {
         footnoteId, footnoteMarker, type: assignmentType, locked,
       },
       weight: { weight: `${(weight * 100).toFixed(0)}${isLocaleRtl ? '\u200f' : ''}%`, locked },
-      grade: { grade: gradeDisplay, locked },
-      weightedGrade: { weightedGrade: weightedGradeDisplay, locked },
+      grade: { grade: `${getGradePercent(averageGrade)}${isLocaleRtl ? '\u200f' : ''}%`, locked },
+      weightedGrade: { weightedGrade: `${getGradePercent(weightedGrade)}${isLocaleRtl ? '\u200f' : ''}%`, locked },
     };
   });
   const getAssignmentTypeCell = (value) => (
@@ -112,16 +102,6 @@ const GradeSummaryTable = ({ setAllOfSomeAssignmentTypeIsLocked }) => {
 
   return (
     <>
-      <ul className="micro mb-3 pl-3 text-gray-700">
-        <li>
-          <b>{intl.formatMessage(messages.hiddenScoreLabel)}: </b>
-          {intl.formatMessage(messages.hiddenScoreInfoText)}
-        </li>
-        <li>
-          <b><Lock style={{ height: '15px' }} />: </b>
-          {` ${intl.formatMessage(messages.hiddenScoreLockInfoText)}`}
-        </li>
-      </ul>
       <DataTable
         data={gradeSummaryData}
         itemCount={gradeSummaryData.length}

src/course-home/progress-tab/grades/grade-summary/GradeSummaryTableFooter.jsx

@@ -1,6 +1,9 @@
+import { useContext } from 'react';
+
 import { getLocale, isRtl, useIntl } from '@edx/frontend-platform/i18n';
 import {
   DataTable,
+  DataTableContext,
   Icon,
   OverlayTrigger,
   Stack,
@@ -14,6 +17,18 @@ import messages from '../messages';
 
 const GradeSummaryTableFooter = () => {
   const intl = useIntl();
+
+  const { data } = useContext(DataTableContext);
+
+  const rawGrade = data.reduce(
+    (grade, currentValue) => {
+      const { weightedGrade } = currentValue.weightedGrade;
+      const percent = weightedGrade.replace(/%/g, '').trim();
+      return grade + parseFloat(percent);
+    },
+    0,
+  ).toFixed(2);
+
   const courseId = useContextId();
 
   const {
@@ -21,16 +36,8 @@ const GradeSummaryTableFooter = () => {
       isPassing,
       percent,
     },
-    finalGrades,
   } = useModel('progress', courseId);
 
-  const getGradePercent = (grade) => {
-    const percentage = grade * 100;
-    return Number.isInteger(percentage) ? percentage.toFixed(0) : percentage.toFixed(2);
-  };
-
-  const rawGrade = getGradePercent(finalGrades);
-
   const bgColor = isPassing ? 'bg-success-100' : 'bg-warning-100';
   const totalGrade = (percent * 100).toFixed(0);
 

src/course-home/progress-tab/grades/messages.ts

@@ -21,11 +21,6 @@ const messages = defineMessages({
     defaultMessage: 'Your current grade is {currentGrade}%. A weighted grade of {passingGrade}% is required to pass in this course.',
     description: 'Alt text for the grade chart bar',
   },
-  courseGradeFooterDueDateNotice: {
-    id: 'progress.courseGrade.footer.dueDateNotice',
-    defaultMessage: 'Some assignment scores are not yet included in your total grade. These grades will be released by {dueDate}.',
-    description: 'This is shown when there are pending assignments with a due date in the future',
-  },
   courseGradeFooterGenericPassing: {
     id: 'progress.courseGrade.footer.generic.passing',
     defaultMessage: 'You’re currently passing this course',
@@ -153,21 +148,6 @@ const messages = defineMessages({
       + "Your weighted grade is what's used to determine if you pass the course.",
     description: 'The content of (tip box) for the grade summary section',
   },
-  hiddenScoreLabel: {
-    id: 'progress.hiddenScoreLabel',
-    defaultMessage: 'Hidden Scores',
-    description: 'Text to indicate that some scores are hidden',
-  },
-  hiddenScoreInfoText: {
-    id: 'progress.hiddenScoreInfoText',
-    defaultMessage: 'Scores from assignments that count toward your final grade but some are not shown here.',
-    description: 'Information text about hidden score label',
-  },
-  hiddenScoreLockInfoText: {
-    id: 'progress.hiddenScoreLockInfoText',
-    defaultMessage: 'Scores for an assignment type are hidden but still counted toward the course grade.',
-    description: 'Information text about hidden score label when learners have limited access to grades feature',
-  },
   noAccessToAssignmentType: {
     id: 'progress.noAcessToAssignmentType',
     defaultMessage: 'You do not have access to assignments of type {assignmentType}',

src/course-home/progress-tab/utils.ts

@@ -5,15 +5,3 @@ export const showUngradedAssignments = () => (
   getConfig().SHOW_UNGRADED_ASSIGNMENT_PROGRESS === 'true'
   || getConfig().SHOW_UNGRADED_ASSIGNMENT_PROGRESS === true
 );
-
-export const getLatestDueDateInFuture = (assignmentTypeGradeSummary) => {
-  let latest = null;
-  assignmentTypeGradeSummary.forEach((assignment) => {
-    const assignmentLastGradePublishDate = assignment.lastGradePublishDate;
-    if (assignmentLastGradePublishDate && (!latest || new Date(assignmentLastGradePublishDate) > new Date(latest))
-       && new Date(assignmentLastGradePublishDate) > new Date()) {
-      latest = assignmentLastGradePublishDate;
-    }
-  });
-  return latest;
-};

src/courseware/course/sequence/Unit/ContentIFrame.jsx

@@ -1,8 +1,8 @@
 import PropTypes from 'prop-types';
 
+import { ErrorPage } from '@edx/frontend-platform/react';
 import { ModalDialog } from '@openedx/paragon';
 import { ContentIFrameLoaderSlot } from '../../../../plugin-slots/ContentIFrameLoaderSlot';
-import { ContentIFrameErrorSlot } from '../../../../plugin-slots/ContentIFrameErrorSlot';
 
 import * as hooks from './hooks';
 
@@ -66,11 +66,7 @@ const ContentIFrame = ({
   return (
     <>
       {(shouldShowContent && !hasLoaded) && (
-        showError ? (
-          <ContentIFrameErrorSlot courseId={courseId} />
-        ) : (
-          <ContentIFrameLoaderSlot courseId={courseId} loadingMessage={loadingMessage} />
-        )
+        showError ? <ErrorPage /> : <ContentIFrameLoaderSlot courseId={courseId} loadingMessage={loadingMessage} />
       )}
       {shouldShowContent && (
         <div className="unit-iframe-wrapper">

src/plugin-slots/ContentIFrameErrorSlot/README.md

@@ -1,39 +0,0 @@
-# Content iFrame Error Slot
-
-### Slot ID: `org.openedx.frontend.learning.content_iframe_error.v1`
-
-### Parameters: `courseId`
-
-## Description
-
-This slot is used to replace/modify the content iframe error page.
-
-## Example
-
-The following `env.config.jsx` will replace the error page with emojis.
-
-```js
-import { DIRECT_PLUGIN, PLUGIN_OPERATIONS } from '@openedx/frontend-plugin-framework';
-
-const config = {
-  pluginSlots: {
-    'org.openedx.frontend.learning.content_iframe_error.v1': {
-      keepDefault: false,
-      plugins: [
-        {
-          op: PLUGIN_OPERATIONS.Insert,
-          widget: {
-            id: 'custom_error_page',
-            type: DIRECT_PLUGIN,
-            RenderWidget: ({courseId}) => (
-              <h1>🚨🤖💥</h1>
-            ),
-          },
-        },
-      ]
-    }
-  },
-}
-
-export default config;
-```

src/plugin-slots/ContentIFrameErrorSlot/index.tsx

@@ -1,17 +0,0 @@
-import React from 'react';
-
-import { PluginSlot } from '@openedx/frontend-plugin-framework';
-import { ErrorPage } from '@edx/frontend-platform/react';
-
-interface Props {
-  courseId: string;
-}
-
-export const ContentIFrameErrorSlot : React.FC<Props> = ({ courseId }: Props) => (
-  <PluginSlot
-    id="org.openedx.frontend.learning.content_iframe_error.v1"
-    pluginProps={{ courseId }}
-  >
-    <ErrorPage />
-  </PluginSlot>
-);