[Meta] Rework population stats

This will have failing lint. The commit is done on purpose.

Author: santeri0200

services/backend/src/services/populations/formatStatisticsForApi.ts

@@ -6,7 +6,7 @@ import { CreditModel } from '../../models'
 import { hasTransferredFromOrToProgramme } from '../studyProgramme/studyProgrammeHelpers'
 import type { StudentStudyPlan, StudentStudyRight } from './getStudentData'
 import { getCurriculumVersion } from './shared'
-import type { AnonymousCredit, AnonymousEnrollment } from './statisticsOf'
+import type { AnonymousCredit } from './statisticsOf'
 
 const yearMap: [string, keyof ProgressCriteria['courses']][] = [
   ['year1', 'yearOne'],
@@ -151,35 +151,13 @@ export const formatStudentForAPI = (
   startDate: string,
   student: StudentData,
   tags: StudentTags[],
-  credits: AnonymousCredit[],
-  enrollments: AnonymousEnrollment[],
   optionData: Name | undefined,
-  criteria: ProgressCriteria
-): FormattedStudent => {
+): Omit<FormattedStudent, 'course' | 'enrollment' | 'criteriaProgress'> => {
   const { studentnumber, studyRights, studyplans } = student
 
   const hops = studyplans.find(plan => plan.programme_code === code)
   const [transferredStudyright, transferSource] = getTransferSource(code, studyRights)
 
-  const courses = credits.map(credit => {
-    const attainmentDateNormalized = credit.attainment_date.toISOString()
-    const passed =
-      CreditModel.passed({ credittypecode: credit.credittypecode }) ||
-      CreditModel.improved({ credittypecode: credit.credittypecode })
-
-    return {
-      course_code: credit.course_code,
-      date: attainmentDateNormalized,
-      passed,
-      grade: passed ? credit.grade : 'Hyl.',
-      credits: credit.credits,
-      isStudyModuleCredit: credit.isStudyModule,
-      credittypecode: credit.credittypecode,
-      language: credit.language,
-      studyright_id: credit.studyright_id,
-    }
-  })
-
   return {
     firstnames: student.firstnames,
     lastname: student.lastname,
@@ -199,15 +177,12 @@ export const formatStudentForAPI = (
     birthdate: student.birthdate,
     sis_person_id: student.sis_person_id,
     citizenships: student.citizenships,
-    criteriaProgress: getProgressCriteria(startDate, criteria, credits, hops),
     curriculumVersion: getCurriculumVersion(hops?.curriculum_period_id),
 
     tags,
     transferredStudyright,
     transferSource,
     studyRights,
     studyplans,
-    courses,
-    enrollments,
   }
 }

services/backend/src/services/populations/shared.ts

@@ -244,8 +244,8 @@ export const parseCourseData = async (
     }
   }
 
-  const courses = await getCourses(Array.from(coursestats.keys()))
-  const courseSubMap = new Map(courses.map(({ code, name, substitutions }) => [code, { name, substitutions }]))
+  const courses = await getCourses()
+  const courseSubMap = new Map(courses.map(({ code, ...rest }) => [code, rest]))
 
   return Array.from(coursestats.entries()).map(([code, { attempts, enrollments, grades, students, stats }]) => {
     const courseMapObj = courseSubMap.get(code)

services/backend/src/services/populations/statisticsOf.ts

@@ -10,7 +10,7 @@ import {
   getCredits,
   getStudyRightElementsForStudyRight,
 } from './getStudentData'
-import { getOptionsForStudents, parseCourseData } from './shared'
+import { getCourses, getOptionsForStudents } from './shared'
 
 export type OptimizedStatisticsQuery = {
   userId: string
@@ -45,43 +45,22 @@ export const statisticsOf = async (
       getStudyRightElementsForStudyRight(studentNumbers, code),
     ])
 
-  const studentStartingYears = new Map(
-    students.map(({ studentnumber, studyRights }) => [
-      studentnumber,
-      studyRights
-        ?.flatMap(({ studyRightElements }) => studyRightElements)
-        .find(element => element.code === code)
-        ?.startDate.getFullYear() ?? +mockedStartDate,
-    ])
-  )
-
-  const creditsAndEnrollmentsByStudent = new Map<string, [AnonymousCredit[], AnonymousEnrollment[]]>(
-    studentNumbers.map(n => [n, [[], []]])
-  )
-
-  for (const credit of credits) {
-    const { student_studentnumber, ...rest } = credit
-    creditsAndEnrollmentsByStudent.get(student_studentnumber)![0].push(rest)
-  }
-
-  for (const enrollment of enrollments) {
-    const { studentnumber, ...rest } = enrollment
-    creditsAndEnrollmentsByStudent.get(studentnumber)![1].push(rest)
-  }
-
-  const formattedCoursestats = await parseCourseData(studentStartingYears, enrollments, credits)
+  const courseCodes = new Set<string>()
+  for (const { course_code } of credits) courseCodes.add(course_code)
+  for (const { course_code } of enrollments) courseCodes.add(course_code)
+  const courses = await getCourses(Array.from(courseCodes))
 
   const optionData = getOptionsForStudents(studyRightElementsForStudyRight, degreeProgrammeType)
   const formattedStudents = students.map(student => {
     const tags = tagMap.get(student.studentnumber) ?? []
     const options = optionData.get(student.studentnumber)
-    const [credits, enrollments] = creditsAndEnrollmentsByStudent.get(student.studentnumber)!
 
-    return formatStudentForAPI(code, mockedStartDate, student, tags, credits, enrollments, options, criteria)
+    return formatStudentForAPI(code, mockedStartDate, student, tags, options)
   })
 
   return {
-    coursestatistics: formattedCoursestats,
     students: formattedStudents,
+    criteria,
+    coursestatistics: { courses, enrollments, credits },
   }
 }

services/frontend/src/components/CoursePopulation/index.tsx

@@ -174,13 +174,13 @@ export const CoursePopulation = () => {
 
   return (
     <FilterView
-      courses={population?.coursestatistics ?? []}
+      coursestatistics={population?.coursestatistics}
       displayTray={!isFetching}
       filters={[
         genderFilter(),
         studentNumberFilter(),
         ageFilter(),
-        courseFilter({ courses: population?.coursestatistics }),
+        courseFilter({ courses: population?.coursestatistics.courses }),
         creditsEarnedFilter(),
         startYearAtUniFilter(),
         programmeFilter({

services/frontend/src/components/CustomPopulation/CustomPopulationWrapper.tsx

@@ -46,7 +46,7 @@ export const CustomPopulationWrapper = ({
     const filtersList = [
       genderFilter(),
       ageFilter(),
-      courseFilter({ courses: population?.coursestatistics ?? [] }),
+      courseFilter({ courses: population?.coursestatistics.courses ?? [] }),
       creditsEarnedFilter(),
       transferredToProgrammeFilter(),
       startYearAtUniFilter(),
@@ -66,7 +66,7 @@ export const CustomPopulationWrapper = ({
 
   return (
     <FilterView
-      courses={population?.coursestatistics ?? []}
+      coursestatistics={population?.coursestatistics}
       displayTray={populationStudents.length > 0}
       filters={filters}
       initialOptions={[]}

services/frontend/src/components/FilterView/filters/courses/CourseCard.tsx

@@ -47,7 +47,7 @@ export const CourseCard = ({
     key,
     text: label,
     value: type,
-    disabled: !Object.keys(course?.students[key] ?? {}).length,
+    disabled: !course?.students[key]?.size,
   }))
 
   return (
@@ -63,19 +63,19 @@ export const CourseCard = ({
     >
       <Stack direction="row" sx={{ justifyContent: 'space-between' }}>
         <Box sx={{ mb: 2 }}>
-          <Typography>{getTextIn(course.course?.name)}</Typography>
-          {course.course?.substitutions?.length ? (
-            <Tooltip title={getSubstitutionTooltip(course.course.substitutions)}>
+          <Typography>{getTextIn(course?.name)}</Typography>
+          {course?.substitutions?.length ? (
+            <Tooltip title={getSubstitutionTooltip(course.substitutions)}>
               <Typography sx={{ color: 'text.secondary' }}>
-                {course.course?.code}... +{course.course?.substitutions?.length}
+                {course?.code}... +{course?.substitutions?.length}
               </Typography>
             </Tooltip>
           ) : (
-            <Typography sx={{ color: 'text.secondary' }}>{course.course?.code}</Typography>
+            <Typography sx={{ color: 'text.secondary' }}>{course?.code}</Typography>
           )}
         </Box>
         <ClearIcon
-          data-cy={`courseFilter-${course.course?.code}-clear`}
+          data-cy={`courseFilter-${course?.code}-clear`}
           onClick={() => onChange(null)}
           sx={{
             color: theme => theme.palette.error.dark,
@@ -86,7 +86,7 @@ export const CourseCard = ({
         />
       </Stack>
       <FilterSelect
-        filterKey={`courseFilter-${course.course?.code}`}
+        filterKey={`courseFilter-${course?.code}`}
         label="Select course"
         onChange={({ target }) => onChange(target.value)}
         options={dropdownOptions}

services/frontend/src/components/FilterView/filters/courses/filterType.ts

@@ -1,6 +1,6 @@
-export const FilterType = {
-  ALL: 'ALL',
-  PASSED: 'PASSED',
-  FAILED: 'FAILED',
-  ENROLLED_NO_GRADE: 'ENROLLED_NO_GRADE',
-} as const
+export enum FilterType {
+  ALL,
+  PASSED,
+  FAILED,
+  ENROLLED_NO_GRADE,
+}

services/frontend/src/components/FilterView/filters/courses/index.tsx

@@ -1,5 +1,3 @@
-import { keyBy } from 'lodash'
-
 import { useLanguage } from '@/components/LanguagePicker/useLanguage'
 import type { FilterTrayProps } from '../../FilterTray'
 import { FilterSearchableSelect } from '../common/FilterSearchableSelect'
@@ -16,12 +14,12 @@ const CourseFilterCard = ({ precomputed, options, onOptionsChange }: FilterTrayP
   const { getTextIn } = useLanguage()
 
   const dropdownOptions = Object.values(courseStats)
-    .filter(cs => !courseFilters[cs.course.code])
-    .sort((a, b) => a.course.code.localeCompare(b.course.code))
+    .filter(cs => !courseFilters[cs.code])
+    .sort((a, b) => a.code.localeCompare(b.code))
     .map(cs => ({
-      key: `courseFilter-option-${cs.course.code}`,
-      text: `${cs.course.code} - ${getTextIn(cs.course.name)}`,
-      value: cs.course.code,
+      key: `courseFilter-option-${cs.code}`,
+      text: `${cs.code} - ${getTextIn(cs.name)}`,
+      value: cs.code,
     }))
 
   const setCourseFilter = (code, type) => {
@@ -64,7 +62,7 @@ export const courseFilter = createFilter({
 
   precompute: ({ args }) => {
     const substitutedBy = args.courses.reduce(
-      (acc, { course }) => {
+      (acc, course) => {
         const { code, substitutions } = course
         for (const original of substitutions) {
           acc[original] ??= []
@@ -77,27 +75,34 @@ export const courseFilter = createFilter({
     )
 
     return {
-      courses: keyBy(args.courses, 'course.code'),
+      courses: Object.fromEntries(args.courses.map(course => [course.code, course])),
       substitutedBy,
     }
   },
 
   isActive: ({ courseFilters }) => Object.keys(courseFilters).length > 0,
 
-  filter({ studentNumber }, { precomputed, options }) {
-    const filterKeys = {
-      [FilterType.ALL]: 'all',
-      [FilterType.PASSED]: 'passed',
-      [FilterType.FAILED]: 'failed',
-      [FilterType.ENROLLED_NO_GRADE]: 'enrolledNoGrade',
-    }
+  filter(student, { precomputed, options }) {
+    const { courses, enrollments } = student
 
     for (const [code, filterType] of Object.entries(options.courseFilters)) {
       const found = [code, ...(precomputed.substitutedBy[code] ?? [])].some(course => {
-        const students = precomputed.courses?.[course]?.students ?? {}
-        const key = filterKeys[filterType as string]
-
-        return students?.[key]?.includes(studentNumber)
+        const enrolled = enrollments.some(({ course_code }) => course_code === course)
+        const attainment = courses.some(({ course_code }) => course_code === code)
+        const passed = courses.some(({ course_code, passed }) => course_code === code && passed)
+
+        switch (filterType) {
+          case FilterType.ALL:
+            return enrolled || attainment
+          case FilterType.PASSED:
+            return passed
+          case FilterType.FAILED:
+            return attainment && !passed
+          case FilterType.ENROLLED_NO_GRADE:
+            return enrolled && !attainment
+          default:
+            return false
+        }
       })
 
       if (!found) return false

services/frontend/src/components/FilterView/index.tsx

@@ -2,10 +2,9 @@ import Stack from '@mui/material/Stack'
 import { FC, useMemo } from 'react'
 
 import { selectViewFilters } from '@/redux/filters'
+import type { ExpandedCourseStats } from '@/redux/populations/util'
 import { useAppSelector } from '@/redux/hooks'
-import { filterCourses } from '@/util/coursesOfPopulation'
-import type { CourseStats } from '@oodikone/shared/routes/populations'
-import type { FormattedCourse as Course } from '@oodikone/shared/types/courseData'
+import { filterCourses, type FilteredCourse } from '@/util/coursesOfPopulation'
 import type { FormattedStudent as Student } from '@oodikone/shared/types/studentData'
 
 import { PageLayout } from '../common/PageLayout'
@@ -16,14 +15,14 @@ import type { Filter } from './filters/createFilter'
 import { FilterTray } from './FilterTray'
 
 export const FilterView: FC<{
-  children: (filteredStudents: Student[], filteredCourses: Course[]) => React.ReactNode
+  children: (filteredStudents: Student[], filteredCourses: FilteredCourse[]) => React.ReactNode
   name: string
   filters: Filter[]
   students: Student[]
-  courses: CourseStats[]
+  coursestatistics: ExpandedCourseStats | undefined
   displayTray: boolean
   initialOptions: Record<Filter['key'], any>
-}> = ({ children, name, filters, students, courses, displayTray, initialOptions }) => {
+}> = ({ children, name, filters, students, coursestatistics, displayTray, initialOptions }) => {
   const storedOptions = useAppSelector(state => selectViewFilters(state, name))
 
   const filterArgs = Object.fromEntries(filters.map(({ key, args }) => [key, args]))
@@ -59,15 +58,16 @@ export const FilterView: FC<{
   })
 
   const filteredStudents = useMemo(
-    () =>
-      filters
-        .filter(({ key, isActive }) => isActive(filterOptions[key]))
-        .reduce((students, { key, filter }) => {
-          return students.filter(student => filter(structuredClone(student), getFilterContext(key)))
-        }, students),
+    () => filters
+      .filter(({ key, isActive }) => isActive(filterOptions[key]))
+      .reduce((students, { key, filter }) => {
+        return students.filter(student => filter(structuredClone(student), getFilterContext(key)))
+      }, students),
     [filters, filterOptions]
   )
-  const filteredCourses = filterCourses(courses, filteredStudents.length)
+
+  const filteredCourses = useMemo(() => filterCourses(coursestatistics, filteredStudents), [filters, filterOptions])
+
 
   const ctxState: FilterViewContextState = { viewName: name, getContextByKey: getFilterContext }