SWAMPy

✎ CARVE FLESH

EDITING: utils.js

/*
 * Copyright (C) 2023 - 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/>.
 */

import React from 'react'
import {ASSIGNMENT_SORT_OPTIONS, ASSIGNMENT_NOT_APPLICABLE} from './constants'
import {IconCheckLine, IconXLine} from '@instructure/ui-icons'
import {Pill} from '@instructure/ui-pill'
import {useScope as useI18nScope} from '@canvas/i18n'

const I18n = useI18nScope('grade_summary')

export const getGradingPeriodID = () => {
  return window?.location?.search
    ?.split('?')[1]
    ?.split('&')
    ?.filter(param => param.includes('grading_period_id'))[0]
    ?.split('=')[1]
}

export const filteredAssignments = data => {
  return (
    data?.assignmentsConnection?.nodes.filter(assignment => {
      return !assignment?.submissionsConnection?.nodes[0]?.hideGradeFromStudent
    }) || []
  )
}

export const sortAssignments = (sortBy, assignments) => {
  if (sortBy === ASSIGNMENT_SORT_OPTIONS.NAME) {
    assignments = [...assignments]?.sort((a, b) => a?.name?.localeCompare(b?.name))
  } else if (sortBy === ASSIGNMENT_SORT_OPTIONS.DUE_DATE) {
    const assignmentsWithDueDates = assignments
      ?.filter(a => a?.dueAt)
      ?.sort((a, b) => a?.dueAt?.localeCompare(b?.dueAt))
    const assignmentsWithoutDueDates = assignments?.filter(a => !a?.dueAt)
    assignments = [...assignmentsWithDueDates, ...assignmentsWithoutDueDates]
  } else if (sortBy === ASSIGNMENT_SORT_OPTIONS.ASSIGNMENT_GROUP) {
    assignments = [...assignments]?.sort((a, b) =>
      a?.assignmentGroup?.name?.localeCompare(b?.assignmentGroup?.name)
    )
  }
  return assignments
}

export const getAssignmentGroupScore = assignmentGroup => {
  if (assignmentGroup?.gradesConnection.nodes[0].overrideScore)
    return `${assignmentGroup?.gradesConnection.nodes[0].overrideScore}%`
  else if (assignmentGroup?.gradesConnection.nodes[0].currentScore)
    return `${assignmentGroup?.gradesConnection.nodes[0].currentScore}%`
  else return ASSIGNMENT_NOT_APPLICABLE
}

export const formatNumber = number => {
  if (typeof number === 'string') {
    number = parseFloat(number)
  }

return number?.toLocaleString(undefined, {
    minimumFractionDigits: 2,
    maximumFractionDigits: 2,
  })
}

export const submissionCommentsPresent = assignment => {
  return (
    assignment?.submissionsConnection.nodes.filter(submission => {
      return submission?.commentsConnection?.nodes?.length > 0
    }).length > 0
  )
}

export const getDisplayStatus = assignment => {
  if (assignment?.submissionsConnection?.nodes[0]?.gradingStatus === 'excused') {
    return <Pill>{I18n.t('Excused')}</Pill>
  } else if (assignment?.gradingType === 'not_graded') {
    return <Pill>{I18n.t('Not Graded')}</Pill>
  } else if (assignment?.submissionsConnection?.nodes?.length === 0) {
    return getNoSubmissionStatus(assignment?.dueAt)
  } else if (assignment?.submissionsConnection?.nodes[0]?.late) {
    return <Pill color="warning">{I18n.t('Late')}</Pill>
  } else if (assignment?.submissionsConnection?.nodes[0]?.gradingStatus === 'graded') {
    return <Pill color="success">{I18n.t('Graded')}</Pill>
  } else {
    return <Pill>{I18n.t('Not Graded')}</Pill>
  }
}

export const getNoSubmissionStatus = dueDate => {
  const assignmentDueDate = new Date(dueDate)
  const currentDate = new Date()
  if (dueDate && assignmentDueDate < currentDate) {
    return <Pill color="danger">{I18n.t('Missing')}</Pill>
  } else {
    return <Pill>{I18n.t('Not Submitted')}</Pill>
  }
}

export const getDisplayScore = (assignment, gradingStandard) => {
  if (ENV.restrict_quantitative_data && assignment?.pointsPossible === 0)
    return getZeroPointAssignmentDisplayScore(
      getAssignmentEarnedPoints(assignment),
      assignment?.submissionsConnection?.nodes[0]?.gradingStatus,
      gradingStandard
    )

if (
    assignment?.submissionsConnection?.nodes?.length === 0 ||
    assignment?.submissionsConnection?.nodes[0]?.gradingStatus === 'needs_grading' ||
    assignment?.submissionsConnection?.nodes[0]?.gradingStatus === 'excused'
  ) {
    return '-'
  } else if (
    ENV.restrict_quantitative_data &&
    (assignment?.gradingType === 'gpa_scale' ||
      assignment?.gradingType === 'percent' ||
      assignment?.gradingType === 'points')
  ) {
    return getAssignmentLetterGrade(assignment, gradingStandard)
  } else if (
    assignment?.gradingType === 'letter_grade' ||
    assignment?.gradingType === 'gpa_scale'
  ) {
    return getAssignmentLetterGrade(assignment, gradingStandard)
  } else if (assignment?.gradingType === 'percentage') {
    return `${getAssignmentPercentage(assignment)}%`
  } else if (assignment?.gradingType === 'pass_fail') {
    return assignment?.submissionsConnection?.nodes[0]?.score ? <IconCheckLine /> : <IconXLine />
  }
  const earned = getAssignmentEarnedPoints(assignment)
  const total = getAssignmentTotalPoints(assignment)
  return `${earned || '0'}/${total || '0'}`
}

export const getZeroPointAssignmentDisplayScore = (score, gradingStatus, gradingStandard) => {
  if (gradingStatus !== 'graded') return '-'
  if (score === 0) {
    return <IconCheckLine />
  } else if (score >= 0) {
    return scorePercentageToLetterGrade(100, gradingStandard)
  } else if (score <= 0) {
    return `${score}/0`
  }
}

export const scorePercentageToLetterGrade = (score, gradingStandard) => {
  if (score === null || score === undefined) return null
  if (!Number.isFinite(Number.parseFloat(score))) return null
  if (score === ASSIGNMENT_NOT_APPLICABLE) return score

let letter = null
  gradingStandard?.data?.forEach(gradeLevel => {
    if (Number.parseFloat(score) / 100 >= gradeLevel.baseValue && !letter) {
      letter = gradeLevel.letterGrade
    }
  })
  return letter
}

// **************** ASSIGNMENTS ***************************************************

export const getAssignmentTotalPoints = assignment => {
  return assignment?.pointsPossible || 0
}

export const getAssignmentEarnedPoints = assignment => {
  return parseFloat(assignment?.submissionsConnection?.nodes[0]?.score) || 0
}

export const getAssignmentPercentage = assignment => {
  if (!getAssignmentTotalPoints(assignment)) return 0
  return (getAssignmentEarnedPoints(assignment) / getAssignmentTotalPoints(assignment) || 1) * 100
}

export const getAssignmentLetterGrade = (assignment, gradingStandard) => {
  if (
    assignment?.submissionsConnection?.nodes === undefined ||
    assignment?.submissionsConnection?.nodes.length === 0
  )
    return null

return scorePercentageToLetterGrade(getAssignmentPercentage(assignment), gradingStandard)
}

// **************** ASSIGNMENT GROUPS **********************************************

export const getAssignmentGroupTotalPoints = (assignmentGroup, assignments) => {
  return assignments?.reduce((total, assignment) => {
    if (
      assignment?.submissionsConnection?.nodes.length > 0 &&
      assignment?.submissionsConnection?.nodes[0]?.gradingStatus !== 'excused' &&
      assignment?.submissionsConnection?.nodes[0]?.gradingStatus !== 'needs_grading' &&
      assignment?.assignmentGroup?._id === assignmentGroup?._id
    ) {
      total += getAssignmentTotalPoints(assignment)
    }
    return total
  }, 0)
}

export const getAssignmentGroupEarnedPoints = (assignmentGroup, assignments) => {
  return assignments?.reduce((total, assignment) => {
    if (
      assignment?.submissionsConnection?.nodes.length > 0 &&
      assignment?.submissionsConnection?.nodes[0]?.gradingStatus !== 'excused' &&
      assignment?.submissionsConnection?.nodes[0]?.gradingStatus !== 'needs_grading' &&
      assignment?.assignmentGroup?._id === assignmentGroup?._id
    ) {
      total += getAssignmentEarnedPoints(assignment)
    }
    return total
  }, 0)
}

export const getAssignmentGroupPercentage = (assignmentGroup, assignments, applyGroupWeights) => {
  if (
    getAssignmentGroupTotalPoints(assignmentGroup, assignments) === 0 ||
    !assignments ||
    assignments?.length === 0
  )
    return ASSIGNMENT_NOT_APPLICABLE
  const earned = getAssignmentGroupEarnedPoints(assignmentGroup, assignments)
  const total = getAssignmentGroupTotalPoints(assignmentGroup, assignments)

if (applyGroupWeights) {
    return ((((earned / total) * assignmentGroup?.groupWeight) / 100) * 100).toString()
  }

return `${(earned / total) * 100}`
}

export const getAssignmentGroupPercentageWithPartialWeight = (
  assignmentGroups = [],
  assignments = []
) => {
  if (assignmentGroups?.length === 0 || assignments?.length === 0) return ASSIGNMENT_NOT_APPLICABLE
  return (
    calculateTotalPercentageWithPartialWeight(
      assignmentGroups,
      group => getAssignmentGroupPercentage(group, assignments, false),
      group => group?.groupWeight || 0
    ) || '0'
  )
}

export const getAssignmentGroupLetterGrade = (assignmentGroup, assignments, gradingStandard) => {
  if (assignments?.length === 0) return ASSIGNMENT_NOT_APPLICABLE

const percentage = getAssignmentGroupPercentage(assignmentGroup, assignments, false)

return percentage === ASSIGNMENT_NOT_APPLICABLE
    ? percentage
    : scorePercentageToLetterGrade(percentage, gradingStandard)
}

// **************** GRADING PERIODS ***********************************************

export const getGradingPeriodTotalPoints = (gradingPeriod, assignments) => {
  return (
    assignments?.reduce((total, assignment) => {
      if (
        assignment?.submissionsConnection?.nodes[0]?.gradingPeriodId === gradingPeriod?._id &&
        !(assignment?.submissionsConnection?.nodes[0]?.gradingStatus === 'excused')
      ) {
        total += getAssignmentTotalPoints(assignment) || 0
      }
      return total
    }, 0) || 0
  )
}

export const getGradingPeriodEarnedPoints = (gradingPeriod, assignments) => {
  return (
    assignments?.reduce((total, assignment) => {
      if (
        assignment?.submissionsConnection?.nodes[0]?.gradingPeriodId === gradingPeriod?._id &&
        !(assignment?.submissionsConnection?.nodes[0]?.gradingStatus === 'excused')
      ) {
        total += getAssignmentEarnedPoints(assignment) || 0
      }
      return total
    }, 0) || 0
  )
}

export const getGradingPeriodPercentage = (
  gradingPeriod,
  assignments,
  assignmentGroups,
  applyGroupWeights
) => {
  if (!assignments || assignments?.length === 0) return ASSIGNMENT_NOT_APPLICABLE

if (applyGroupWeights) {
    return getAssignmentGroupPercentageWithPartialWeight(assignmentGroups, assignments)
  }

const gradingPeriodEarnedPoints = getGradingPeriodEarnedPoints(gradingPeriod, assignments)
  const gradingPeriodTotalPoints = getGradingPeriodTotalPoints(gradingPeriod, assignments)

if (gradingPeriodTotalPoints === 0 && gradingPeriodEarnedPoints === 0)
    return ASSIGNMENT_NOT_APPLICABLE

return (
    `${(gradingPeriodEarnedPoints / gradingPeriodTotalPoints) * 100}` || ASSIGNMENT_NOT_APPLICABLE
  )
}

// **************** COURSES *******************************************************

export const getCourseTotalPoints = assignments => {
  return (
    assignments?.reduce((total, assignment) => {
      if (
        !(assignment?.submissionsConnection?.nodes[0]?.gradingStatus === 'excused') &&
        assignment?.submissionsConnection?.nodes.length > 0
      ) {
        total += getAssignmentTotalPoints(assignment)
      }
      return total
    }, 0) || 0
  )
}

export const getCourseEarnedPoints = (assignments = []) => {
  return (
    assignments?.reduce((total, assignment) => {
      if (
        !(assignment?.submissionsConnection?.nodes[0]?.gradingStatus === 'excused') &&
        assignment?.submissionsConnection?.nodes.length > 0
      ) {
        total += getAssignmentEarnedPoints(assignment)
      }
      return total
    }, 0) || 0
  )
}

export const getCoursePercentage = (assignments = []) => {
  if (!getCourseTotalPoints(assignments)) return 0
  return (getCourseEarnedPoints(assignments) / getCourseTotalPoints(assignments)) * 100
}

// **************** TOTAL *********************************************************

export const calculateTotalPercentageWithPartialWeight = (
  items,
  getItemPercentage,
  getItemWeight
) => {
  const filteredItems = items?.filter(item => {
    return getItemWeight(item) && getItemPercentage(item) !== 'N/A'
  })

let returnTotal =
    filteredItems?.reduce((total, item) => {
      const itemPercentage = getItemPercentage(item)
      const itemWeight = getItemWeight(item)
      return `${Number.parseFloat(total) + itemPercentage * (itemWeight / 100)}`
    }, '0') || '0'

if (returnTotal === '0') return ASSIGNMENT_NOT_APPLICABLE

const availableWeightsSum = filteredItems?.reduce((total, item) => {
    const itemWeight = getItemWeight(item)
    return total + itemWeight
  }, 0)

if (availableWeightsSum < 100) {
    returnTotal = `${Number.parseFloat(returnTotal) * (1 / (availableWeightsSum / 100))}`
  }

return returnTotal
}

export const getTotal = (assignments, assignmentGroups, gradingPeriods, applyWeights) => {
  if (!assignments || assignments?.length === 0) return ASSIGNMENT_NOT_APPLICABLE

const validGradingPeriodsCount =
    gradingPeriods?.filter(period => {
      return period?.weight && period?.weight > 0
    }) || []

let returnTotal = 0
  if (getGradingPeriodID() === '0' && validGradingPeriodsCount.length > 0) {
    returnTotal = calculateTotalPercentageWithPartialWeight(
      gradingPeriods,
      period =>
        getGradingPeriodPercentage(
          period,
          assignments?.filter(assignment => {
            return assignment?.submissionsConnection?.nodes[0]?.gradingPeriodId === period?._id
          }),
          assignmentGroups,
          validGradingPeriodsCount.length === gradingPeriods.length ? applyWeights : false
        ),
      period => period?.weight || 0
    )
  } else if (applyWeights) {
    returnTotal = getAssignmentGroupPercentageWithPartialWeight(assignmentGroups, assignments)
  } else {
    returnTotal = `${getCoursePercentage(assignments)}`
  }
  return returnTotal === '0' ? ASSIGNMENT_NOT_APPLICABLE : returnTotal
}

// ********************************************************************************

CANCEL

Name	Type	Size	Modified	Actions
↩ ..	DIR	—	—
📁 __tests__/	DIR	—	2023-09-24 03:39
📁 AssignmentTableRows/	DIR	—	2023-09-24 03:39
📄 AssignmentTable.js	JS	3.3 KB	2023-09-24 03:39	EDIT
📄 AssignmentTable.stories.js	JS	19.8 KB	2023-09-24 03:39	EDIT
📄 constants.js	JS	871 B	2023-09-24 03:39	EDIT
📄 context.js	JS	868 B	2023-09-24 03:39	EDIT
📄 GradeSummaryContainer.js	JS	5.9 KB	2023-09-24 03:39	EDIT
📄 GradeSummaryManager.js	JS	2.3 KB	2023-09-24 03:39	EDIT
📄 SubmissionComment.js	JS	2.1 KB	2023-09-24 03:39	EDIT
📄 SubmissionComment.stories.js	JS	1.9 KB	2023-09-24 03:39	EDIT
📄 utils.js	JS	14.3 KB	2023-09-24 03:39	EDIT