[Meta] Rework class population data

Author: santeri0200

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

@@ -1,21 +1,10 @@
 import { SISStudyRight } from '@oodikone/shared/models'
-import { FormattedStudent, CriteriaYear, Name, ProgressCriteria } from '@oodikone/shared/types'
+import { FormattedStudent, Name } from '@oodikone/shared/types'
 import { StudentData, StudentTags } from '@oodikone/shared/types/studentData'
-import { dateYearsFromNow, dateDaysFromNow, dayInMilliseconds } from '@oodikone/shared/util/datetime'
-import { CreditModel } from '../../models'
+import { dateDaysFromNow, dayInMilliseconds } from '@oodikone/shared/util/datetime'
 import { hasTransferredFromOrToProgramme } from '../studyProgramme/studyProgrammeHelpers'
-import type { StudentStudyPlan, StudentStudyRight } from './getStudentData'
+import type { StudentStudyRight } from './getStudentData'
 import { getCurriculumVersion } from './shared'
-import type { AnonymousCredit, AnonymousEnrollment } from './statisticsOf'
-
-const yearMap: [string, keyof ProgressCriteria['courses']][] = [
-  ['year1', 'yearOne'],
-  ['year2', 'yearTwo'],
-  ['year3', 'yearThree'],
-  ['year4', 'yearFour'],
-  ['year5', 'yearFive'],
-  ['year6', 'yearSix'],
-]
 
 const getTransferSource = (code: string, studyRights: StudentStudyRight[]): [boolean, string | undefined] => {
   if (code) {
@@ -48,138 +37,18 @@ const getTransferSource = (code: string, studyRights: StudentStudyRight[]): [boo
   return [false, undefined]
 }
 
-const getCriteriaBase = (criteria: ProgressCriteria): [boolean, Record<string, CriteriaYear>] => {
-  const thereAreCriteriaCourses = !!Object.values(criteria.courses).flatMap(val => val).length
-  const thereAreCriteriaCredits = !!Object.values(criteria.credits).reduce((acc, cur) => acc + cur, 0)
-
-  const createEmptyCriteriaYear = (criteria: ProgressCriteria, year: keyof ProgressCriteria['courses']) => ({
-    credits: false,
-    totalSatisfied: 0,
-    coursesSatisfied: Object.fromEntries(criteria.courses[year].map(course => [course, null])),
-  })
-
-  const criteriaChecked: Record<string, CriteriaYear> = {
-    year1: createEmptyCriteriaYear(criteria, 'yearOne'),
-    year2: createEmptyCriteriaYear(criteria, 'yearTwo'),
-    year3: createEmptyCriteriaYear(criteria, 'yearThree'),
-    year4: createEmptyCriteriaYear(criteria, 'yearFour'),
-    year5: createEmptyCriteriaYear(criteria, 'yearFive'),
-    year6: createEmptyCriteriaYear(criteria, 'yearSix'),
-  }
-
-  return [thereAreCriteriaCourses || thereAreCriteriaCredits, criteriaChecked]
-}
-
-const getProgressCriteria = (
-  startDate: string,
-  criteria: ProgressCriteria,
-  credits: AnonymousCredit[],
-  hops: StudentStudyPlan | undefined
-) => {
-  const [thereAreCriteria, criteriaChecked] = getCriteriaBase(criteria)
-  if (!thereAreCriteria) return criteriaChecked
-
-  const startDateFromISO = new Date(startDate)
-
-  const criteriaCoursesBySubstitutionMap = new Map<string, string>()
-  for (const [courseCode, substitutionCodes] of Object.entries(criteria.allCourses)) {
-    criteriaCoursesBySubstitutionMap.set(courseCode, courseCode)
-
-    for (const substitutionCode of substitutionCodes) {
-      criteriaCoursesBySubstitutionMap.set(substitutionCode, courseCode)
-    }
-  }
-
-  const academicYears = { year1: 0, year2: 0, year3: 0, year4: 0, year5: 0, year6: 0 }
-
-  const courses = credits.map(({ attainment_date, course_code, credits, credittypecode }) => ({
-    course_code,
-    credits,
-    credittypecode,
-    date:
-      attainment_date < startDateFromISO
-        ? dateDaysFromNow(startDateFromISO, 1).toISOString()
-        : attainment_date.toISOString(),
-  }))
-
-  courses
-    .filter(({ course_code }) => !!criteriaCoursesBySubstitutionMap.get(course_code))
-    .filter(({ credittypecode }) => CreditModel.passed({ credittypecode }) || CreditModel.improved({ credittypecode }))
-    .forEach(course => {
-      const courseDate = new Date(course.date)
-      const correctCode = criteriaCoursesBySubstitutionMap.get(course.course_code)!
-
-      yearMap.forEach(([yearToAdd, criteriaYear]) => {
-        if (criteria.courses[criteriaYear].includes(correctCode)) {
-          const currentDate = criteriaChecked[yearToAdd].coursesSatisfied[correctCode]
-          if (!currentDate || courseDate < new Date(currentDate)) {
-            criteriaChecked[yearToAdd].coursesSatisfied[correctCode] = course.date
-          }
-        }
-      })
-    })
-
-  courses.forEach(course => {
-    const courseDate = new Date(course.date)
-    const correctCode = criteriaCoursesBySubstitutionMap.get(course.course_code)!
-
-    if (
-      startDateFromISO < courseDate &&
-      !!hops &&
-      (hops.included_courses.includes(course.course_code) || hops.included_courses.includes(correctCode))
-    )
-      Object.keys(academicYears)
-        .filter((_, index) => courseDate < dateYearsFromNow(startDateFromISO, index + 1))
-        .forEach(year => (academicYears[year] += course.credits))
-  })
-
-  yearMap.forEach(([yearToAdd, criteriaYear]) => {
-    criteriaChecked[yearToAdd].totalSatisfied +=
-      Object.values(criteriaChecked[yearToAdd].coursesSatisfied).filter(course => !!course).length ?? 0
-    // UPDATE CREDIT CRITERIA
-    if (!!criteria.credits[criteriaYear] && criteria.credits[criteriaYear] < academicYears[yearToAdd]) {
-      criteriaChecked[yearToAdd].credits = true
-      criteriaChecked[yearToAdd].totalSatisfied += 1
-    }
-  })
-
-  return criteriaChecked
-}
-
 export const formatStudentForAPI = (
   code: string,
   startDate: string,
   student: StudentData,
   tags: StudentTags[],
-  credits: AnonymousCredit[],
-  enrollments: AnonymousEnrollment[],
-  optionData: Name | undefined,
-  criteria: ProgressCriteria
-): FormattedStudent => {
+  optionData: Name | undefined
+): Omit<FormattedStudent, 'criteriaProgress' | 'courses' | 'enrollments'> => {
   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 +68,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

@@ -1,11 +1,9 @@
 import { orderBy } from 'lodash'
 import { Op } from 'sequelize'
 
-import type { CourseStats } from '@oodikone/shared/routes/populations'
-import { Name, DegreeProgrammeType, EnrollmentState } from '@oodikone/shared/types'
-import { SISStudyRightElementModel, CreditModel, CourseModel } from '../../models'
-import { getPassingSemester, SemesterStart } from '../../util/semester'
-import { StudentCredit, StudentEnrollment } from './getStudentData'
+import { Name, DegreeProgrammeType } from '@oodikone/shared/types'
+import { SISStudyRightElementModel, CourseModel } from '../../models'
+import { SemesterStart } from '../../util/semester'
 
 type QueryParams = {
   semesters: string[]
@@ -85,195 +83,3 @@ export const getCourses = (courses: string[]): Promise<Array<Pick<CourseModel, '
     },
     raw: true,
   })
-
-const defaultCourse = {
-  attempts: 0,
-  enrollments: {
-    [EnrollmentState.ENROLLED]: new Set<string>(),
-    [EnrollmentState.REJECTED]: new Set<string>(),
-    semesters: {
-      BEFORE: {
-        [EnrollmentState.ENROLLED]: new Set<string>(),
-        [EnrollmentState.REJECTED]: new Set<string>(),
-      },
-      '0-FALL': {
-        [EnrollmentState.ENROLLED]: new Set<string>(),
-        [EnrollmentState.REJECTED]: new Set<string>(),
-      },
-      '0-SPRING': {
-        [EnrollmentState.ENROLLED]: new Set<string>(),
-        [EnrollmentState.REJECTED]: new Set<string>(),
-      },
-      '1-FALL': {
-        [EnrollmentState.ENROLLED]: new Set<string>(),
-        [EnrollmentState.REJECTED]: new Set<string>(),
-      },
-      '1-SPRING': {
-        [EnrollmentState.ENROLLED]: new Set<string>(),
-        [EnrollmentState.REJECTED]: new Set<string>(),
-      },
-      '2-FALL': {
-        [EnrollmentState.ENROLLED]: new Set<string>(),
-        [EnrollmentState.REJECTED]: new Set<string>(),
-      },
-      '2-SPRING': {
-        [EnrollmentState.ENROLLED]: new Set<string>(),
-        [EnrollmentState.REJECTED]: new Set<string>(),
-      },
-      '3-FALL': {
-        [EnrollmentState.ENROLLED]: new Set<string>(),
-        [EnrollmentState.REJECTED]: new Set<string>(),
-      },
-      '3-SPRING': {
-        [EnrollmentState.ENROLLED]: new Set<string>(),
-        [EnrollmentState.REJECTED]: new Set<string>(),
-      },
-      '4-FALL': {
-        [EnrollmentState.ENROLLED]: new Set<string>(),
-        [EnrollmentState.REJECTED]: new Set<string>(),
-      },
-      '4-SPRING': {
-        [EnrollmentState.ENROLLED]: new Set<string>(),
-        [EnrollmentState.REJECTED]: new Set<string>(),
-      },
-      '5-FALL': {
-        [EnrollmentState.ENROLLED]: new Set<string>(),
-        [EnrollmentState.REJECTED]: new Set<string>(),
-      },
-      '5-SPRING': {
-        [EnrollmentState.ENROLLED]: new Set<string>(),
-        [EnrollmentState.REJECTED]: new Set<string>(),
-      },
-      LATER: {
-        [EnrollmentState.ENROLLED]: new Set<string>(),
-        [EnrollmentState.REJECTED]: new Set<string>(),
-      },
-    },
-  },
-  grades: {},
-  students: {
-    all: new Set<string>(),
-    passed: new Set<string>(),
-    failed: new Set<string>(),
-    improvedPassedGrade: new Set<string>(),
-    markedToSemester: new Set<string>(),
-    enrolledNoGrade: new Set<string>(),
-  },
-
-  stats: {
-    passingSemesters: {
-      BEFORE: 0,
-      '0-FALL': 0,
-      '0-SPRING': 0,
-      '1-FALL': 0,
-      '1-SPRING': 0,
-      '2-FALL': 0,
-      '2-SPRING': 0,
-      '3-FALL': 0,
-      '3-SPRING': 0,
-      '4-FALL': 0,
-      '4-SPRING': 0,
-      '5-FALL': 0,
-      '5-SPRING': 0,
-      LATER: 0,
-    },
-  },
-}
-
-export const parseCourseData = async (
-  studentStartingYears: Map<string, number>,
-  enrollments: StudentEnrollment[],
-  credits: StudentCredit[]
-): Promise<CourseStats[]> => {
-  const getYear = (studentnumber: string) => studentStartingYears.get(studentnumber)!
-
-  const coursestats = new Map<string, typeof defaultCourse>()
-  for (const enrollment of enrollments) {
-    const { course_code, studentnumber, state, enrollment_date_time } = enrollment
-
-    // We cannot display these
-    if (course_code === null) continue
-
-    if (!coursestats.has(course_code)) coursestats.set(course_code, structuredClone(defaultCourse))
-    const course = coursestats.get(course_code)!
-
-    const initialDate = new Date(enrollment_date_time)
-    const semester = getPassingSemester(getYear(studentnumber), initialDate)
-
-    course.students.all.add(studentnumber)
-    course.students.enrolledNoGrade.add(studentnumber)
-    course.enrollments[state].add(studentnumber)
-    course.enrollments.semesters[semester][state].add(studentnumber)
-  }
-
-  for (const credit of credits) {
-    const { course_code, student_studentnumber: studentnumber, grade, attainment_date: date } = credit
-
-    // We cannot display these
-    if (course_code === null) continue
-
-    const passingGrade = CreditModel.passed(credit)
-    const failingGrade = CreditModel.failed(credit)
-    const improvedGrade = CreditModel.improved(credit)
-
-    if (!coursestats.has(course_code)) coursestats.set(course_code, structuredClone(defaultCourse))
-    const course = coursestats.get(course_code)!
-
-    course.attempts += 1
-    const gradeCount = course.grades[grade]?.count ?? 0
-    course.grades[grade] = { count: gradeCount + 1, status: { passingGrade, failingGrade, improvedGrade } }
-
-    course.students.all.add(studentnumber)
-    course.students.enrolledNoGrade.delete(studentnumber)
-    if (passingGrade) {
-      if (!course.students.markedToSemester.has(studentnumber)) {
-        course.students.markedToSemester.add(studentnumber)
-
-        const semester = getPassingSemester(getYear(studentnumber), new Date(date))
-        course.stats.passingSemesters[semester]++
-      }
-
-      course.students.passed.add(studentnumber)
-      course.students.failed.delete(studentnumber)
-    } else if (improvedGrade) {
-      course.students.improvedPassedGrade.add(studentnumber)
-      course.students.passed.add(studentnumber)
-      course.students.failed.delete(studentnumber)
-    } else if (failingGrade && !course.students.passed.has(studentnumber)) {
-      course.students.failed.add(studentnumber)
-    }
-  }
-
-  const courses = await getCourses(Array.from(coursestats.keys()))
-  const courseSubMap = new Map(courses.map(({ code, name, substitutions }) => [code, { name, substitutions }]))
-
-  return Array.from(coursestats.entries()).map(([code, { attempts, enrollments, grades, students, stats }]) => {
-    const courseMapObj = courseSubMap.get(code)
-    return {
-      course: {
-        code,
-        name: courseMapObj?.name ?? { en: code },
-        substitutions: courseMapObj?.substitutions ?? [],
-      },
-      attempts,
-      enrollments: {
-        [EnrollmentState.ENROLLED]: Array.from(enrollments[EnrollmentState.ENROLLED]),
-        [EnrollmentState.REJECTED]: Array.from(enrollments[EnrollmentState.REJECTED]),
-        semesters: Object.fromEntries(
-          Object.entries(enrollments.semesters).map(([key, val]) => [
-            key,
-            {
-              [EnrollmentState.ENROLLED]: Array.from(val[EnrollmentState.ENROLLED]),
-              [EnrollmentState.REJECTED]: Array.from(val[EnrollmentState.REJECTED]),
-            },
-          ])
-        ),
-      },
-      grades,
-      students: Object.fromEntries(
-        Object.entries(students).map(([key, val]) => [key, Array.from(val)])
-      ) as CourseStats['students'],
-      stats,
-    }
-  })
-}