refactor: remove progress page calculation logic and use data from backend

Author: Anas12091101

src/course-home/data/api.js

@@ -3,114 +3,6 @@ import { getAuthenticatedHttpClient } from '@edx/frontend-platform/auth';
 import { logInfo } from '@edx/frontend-platform/logging';
 import { appendBrowserTimezoneToUrl } from '../../utils';
 
-const calculateAssignmentTypeGrades = (points, visibilities, 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);
-    visibilities.splice(lowestScoreIndex, 1);
-    dropCount--;
-  }
-  let averageGrade = 0;
-  let weightedGrade = 0;
-  let totalWeightedGrade = 0;
-
-  if (points.length) {
-    // Scores for visible grades (exclude never_but_include_grade)
-    const visibleScores = points.filter(
-      (_, idx) => visibilities[idx] !== 'never_but_include_grade',
-    );
-
-    // Average all scores (for totalWeightedGrade)
-    const overallAverage = parseFloat(
-      (points.reduce((a, b) => a + b, 0) / points.length).toFixed(4),
-    );
-    totalWeightedGrade = overallAverage * assignmentWeight;
-    if (visibleScores.length) {
-      const visibleAverage = parseFloat(
-        (visibleScores.reduce((a, b) => a + b, 0) / points.length).toFixed(4),
-      );
-      averageGrade = visibleAverage;
-      weightedGrade = averageGrade * assignmentWeight;
-    }
-  }
-  return { averageGrade, weightedGrade, totalWeightedGrade };
-};
-
-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,
-      visibility: Array(assignment.numTotal),
-    };
-  });
-
-  sectionScores.forEach((chapter) => {
-    chapter.subsections.forEach((subsection) => {
-      if (!(subsection.hasGradedAssignment && subsection.showGrades && subsection.numPointsPossible)) {
-        return;
-      }
-      const {
-        assignmentType,
-        numPointsEarned,
-        numPointsPossible,
-        showCorrectness,
-      } = 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();
-        gradeByAssignmentType[assignmentType].visibility.shift();
-      }
-      // Add the graded assignment to the list
-      gradeByAssignmentType[assignmentType].grades.push(numPointsEarned ? numPointsEarned / numPointsPossible : 0);
-      // Record the created assignment
-      gradeByAssignmentType[assignmentType].numAssignmentsCreated = numAssignmentsCreated;
-      gradeByAssignmentType[assignmentType].visibility.push(showCorrectness);
-    });
-  });
-
-  return assignmentPolicies.map((assignment) => {
-    const { averageGrade, weightedGrade, totalWeightedGrade } = calculateAssignmentTypeGrades(
-      gradeByAssignmentType[assignment.type].grades,
-      gradeByAssignmentType[assignment.type].visibility,
-      assignment.weight,
-      assignment.numDroppable,
-    );
-
-    return {
-      averageGrade,
-      numDroppable: assignment.numDroppable,
-      shortLabel: assignment.shortLabel,
-      type: assignment.type,
-      weight: assignment.weight,
-      weightedGrade,
-      totalWeightedGrade,
-    };
-  });
-}
-
 /**
  * Tweak the metadata for consistency
  * @param metadata the data to normalize
@@ -256,11 +148,7 @@ export async function getProgressTabData(courseId, targetUserId) {
   try {
     const { data } = await getAuthenticatedHttpClient().get(url);
     const camelCasedData = camelCaseObject(data);
-
-    camelCasedData.gradingPolicy.assignmentPolicies = normalizeAssignmentPolicies(
-      camelCasedData.gradingPolicy.assignmentPolicies,
-      camelCasedData.sectionScores,
-    );
+    camelCasedData.gradingPolicy.assignmentPolicies = camelCasedData.assignmentTypeGradeSummary;
 
     // 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")

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

@@ -9,6 +9,7 @@ import { useModel } from '../../../../generic/model-store';
 import GradeRangeTooltip from './GradeRangeTooltip';
 import messages from '../messages';
 import { getLatestDueDateInFuture } from '../../utils';
+import { assert } from 'joi';
 
 const ResponsiveText = ({
   wideScreen, children, hasLetterGrades, passingGrade,
@@ -48,12 +49,12 @@ const CourseGradeFooter = ({ passingGrade }) => {
   const courseId = useContextId();
 
   const {
+    assignmentTypeGradeSummary,
     courseGrade: { isPassing, letterGrade },
     gradingPolicy: { gradeRange },
-    sectionScores,
   } = useModel('progress', courseId);
 
-  const latestDueDate = getLatestDueDateInFuture(sectionScores);
+  const latestDueDate = getLatestDueDateInFuture(assignmentTypeGradeSummary);
   const wideScreen = useWindowSize().width >= breakpoints.medium.minWidth;
   const hasLetterGrades = Object.keys(gradeRange).length > 1;
 

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

@@ -5,7 +5,6 @@ import { OverlayTrigger, Popover } from '@openedx/paragon';
 import { useContextId } from '../../../../data/hooks';
 
 import { useModel } from '../../../../generic/model-store';
-import { areAllGradesHiddenForType, areSomeGradesHiddenForType } from '../../utils';
 
 import messages from '../messages';
 
@@ -14,14 +13,11 @@ const CurrentGradeTooltip = ({ tooltipClassName }) => {
   const courseId = useContextId();
 
   const {
-    gradingPolicy: {
-      assignmentPolicies,
-    },
+    assignmentTypeGradeSummary,
     courseGrade: {
       isPassing,
       percent,
     },
-    sectionScores,
   } = useModel('progress', courseId);
 
   const currentGrade = Number((percent * 100).toFixed(0));
@@ -30,10 +26,7 @@ const CurrentGradeTooltip = ({ tooltipClassName }) => {
 
   const isLocaleRtl = isRtl(getLocale());
 
-  const hasHiddenGrades = assignmentPolicies.some(
-    (assignment) => areSomeGradesHiddenForType(assignment.type, sectionScores)
-     || areAllGradesHiddenForType(assignment.type, sectionScores),
-  );
+  const hasHiddenGrades = assignmentTypeGradeSummary.some((assignmentType) => assignmentType.hasHiddenContribution !== "none");
 
   if (isLocaleRtl) {
     currentGradeDirection = currentGrade < 50 ? '-' : '';

src/course-home/progress-tab/grades/detailed-grades/DetailedGradesTable.jsx

@@ -22,7 +22,6 @@ const DetailedGradesTable = () => {
         (subsection) => !!(
           (showUngradedAssignments() || subsection.hasGradedAssignment)
             && subsection.showGrades
-            && subsection.showCorrectness !== 'never_but_include_grade'
             && (subsection.numPointsPossible > 0 || subsection.numPointsEarned > 0)
         ),
       );

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

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

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

@@ -11,16 +11,13 @@ import DroppableAssignmentFootnote from './DroppableAssignmentFootnote';
 import GradeSummaryTableFooter from './GradeSummaryTableFooter';
 
 import messages from '../messages';
-import { areAllGradesHiddenForType, areSomeGradesHiddenForType } from '../../utils';
 
 const GradeSummaryTable = ({ setAllOfSomeAssignmentTypeIsLocked }) => {
   const intl = useIntl();
   const courseId = useContextId();
 
   const {
-    gradingPolicy: {
-      assignmentPolicies,
-    },
+    assignmentTypeGradeSummary,
     gradesFeatureIsFullyLocked,
     sectionScores,
   } = useModel('progress', courseId);
@@ -57,7 +54,7 @@ const GradeSummaryTable = ({ setAllOfSomeAssignmentTypeIsLocked }) => {
     return false;
   };
 
-  const gradeSummaryData = assignmentPolicies.map((assignment) => {
+  const gradeSummaryData = assignmentTypeGradeSummary.map((assignment) => {
     const {
       averageGrade,
       numDroppable,
@@ -85,10 +82,10 @@ const GradeSummaryTable = ({ setAllOfSomeAssignmentTypeIsLocked }) => {
     let weightedGradeDisplay = `${getGradePercent(weightedGrade)}${isLocaleRtl ? '\u200f' : ''}%`;
     let gradeDisplay = `${getGradePercent(averageGrade)}${isLocaleRtl ? '\u200f' : ''}%`;
 
-    if (areAllGradesHiddenForType(assignmentType, sectionScores)) {
+    if (assignment.hasHiddenContribution === 'all') {
       gradeDisplay = <Lock data-testid="lock-icon" />;
       weightedGradeDisplay = <Lock data-testid="lock-icon" />;
-    } else if (areSomeGradesHiddenForType(assignmentType, sectionScores)) {
+    } else if (assignment.hasHiddenContribution === 'some') {
       gradeDisplay = `${getGradePercent(averageGrade)}${isLocaleRtl ? '\u200f' : ''}% + ${intl.formatMessage(messages.hiddenScoreLabel)}`;
       weightedGradeDisplay = `${getGradePercent(weightedGrade)}${isLocaleRtl ? '\u200f' : ''}% + ${intl.formatMessage(messages.hiddenScoreLabel)}`;
     }

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

@@ -17,27 +17,19 @@ const GradeSummaryTableFooter = () => {
   const courseId = useContextId();
 
   const {
-    gradingPolicy: { assignmentPolicies },
+    courseGrade: {
+      isPassing,
+      percent,
+    },
+    finalGrades,
   } = useModel('progress', courseId);
 
   const getGradePercent = (grade) => {
     const percent = grade * 100;
     return Number.isInteger(percent) ? percent.toFixed(0) : percent.toFixed(2);
   };
 
-  let rawGrade = assignmentPolicies.reduce(
-    (sum, { totalWeightedGrade }) => sum + totalWeightedGrade,
-    0,
-  );
-
-  rawGrade = getGradePercent(rawGrade);
-
-  const {
-    courseGrade: {
-      isPassing,
-      percent,
-    },
-  } = useModel('progress', courseId);
+  const rawGrade = getGradePercent(finalGrades);
 
   const bgColor = isPassing ? 'bg-success-100' : 'bg-warning-100';
   const totalGrade = (percent * 100).toFixed(0);
@@ -57,7 +49,7 @@ const GradeSummaryTableFooter = () => {
                 <Tooltip>
                   {intl.formatMessage(
                     messages.weightedGradeSummaryTooltip,
-                    { roundedGrade: totalGrade, rawGrade },
+                    { roundedGrade: totalGrade, rawGrade: rawGrade },
                   )}
                 </Tooltip>
               )}

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

@@ -6,39 +6,15 @@ export const showUngradedAssignments = () => (
   || getConfig().SHOW_UNGRADED_ASSIGNMENT_PROGRESS === true
 );
 
-// Returns the subsections for an assignment type
-const getSubsectionsOfType = (assignmentType, sectionScores) => (sectionScores || []).reduce((acc, chapter) => {
-  const subs = (chapter.subsections || []).filter(
-    (s) => s.assignmentType === assignmentType,
-  );
-  return acc.concat(subs);
-}, []);
 
-// Returns True if this subsection is "hidden"
-const isSubsectionHidden = (sub) => sub.showCorrectness === 'never_but_include_grade';
-
-// Returns True if all grades are hidden for this assignment type
-export const areAllGradesHiddenForType = (assignmentType, sectionScores) => {
-  const subs = getSubsectionsOfType(assignmentType, sectionScores);
-  if (subs.length === 0) { return false; } // no subsections -> treat as not hidden
-  return subs.every(isSubsectionHidden);
-};
-
-// Returns True if some grades are hidden for this assignment type
-export const areSomeGradesHiddenForType = (assignmentType, sectionScores) => {
-  const subs = getSubsectionsOfType(assignmentType, sectionScores);
-  return subs.some(isSubsectionHidden) && !areAllGradesHiddenForType(assignmentType, sectionScores);
-};
-
-export const getLatestDueDateInFuture = (sectionScores) => {
+export const getLatestDueDateInFuture = (assignmentTypeGradeSummary) => {
   let latest = null;
-  sectionScores.forEach((chapter) => {
-    chapter.subsections.forEach((subsection) => {
-      if (subsection.due && (!latest || new Date(subsection.due) > new Date(latest))
-         && new Date(subsection.due) > new Date()) {
-        latest = subsection.due;
-      }
-    });
+  assignmentTypeGradeSummary.forEach((assignment) => {
+    let assignmentLastGradePublishDate = assignment.lastGradePublishDate;
+    if (assignmentLastGradePublishDate && (!latest || new Date(assignmentLastGradePublishDate) > new Date(latest))
+       && new Date(assignmentLastGradePublishDate) > new Date()) {
+      latest = assignmentLastGradePublishDate;
+    }
   });
   return latest;
 };