@hed-hog/lms 0.0.318 → 0.0.320

package/src/enterprise/training/training-student.service.ts

@@ -0,0 +1,762 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { Injectable, NotFoundException } from '@nestjs/common';
+
+@Injectable()
+export class TrainingStudentService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async getDashboard(userId: number, enterpriseId?: number) {
+    const personUser = await this.prisma.person_user.findFirst({
+      where: { user_id: userId },
+      select: { person_id: true },
+    });
+
+    if (!personUser) {
+      throw new NotFoundException('No person profile found for this user');
+    }
+
+    const personId = personUser.person_id;
+    const now = new Date();
+    const weekStart = this.startOfWeek(now);
+    const weekEnd = this.endOfDay(this.addDays(weekStart, 6));
+
+    // Fetch all active enrollments for this student
+    const enrollments = await this.prisma.course_enrollment.findMany({
+      where: { person_id: personId, status: { not: 'cancelled' } },
+      select: {
+        id: true,
+        course_id: true,
+        course_class_group_id: true,
+        status: true,
+        progress_percent: true,
+        final_score: true,
+        enrolled_at: true,
+        completed_at: true,
+      },
+    });
+
+    let classEnrollments = enrollments.filter((e) => e.course_class_group_id != null);
+
+    // If enterpriseId provided, restrict to class groups linked to that enterprise
+    if (enterpriseId !== undefined) {
+      const enterpriseCgRows = await this.prisma.enterprise_class_group.findMany({
+        where: { enterprise_id: enterpriseId },
+        select: { course_class_group_id: true },
+      });
+      const enterpriseCgIds = new Set(enterpriseCgRows.map((r) => r.course_class_group_id));
+      classEnrollments = classEnrollments.filter((e) => enterpriseCgIds.has(e.course_class_group_id!));
+    }
+
+    const onDemandEnrollments = enrollments.filter((e) => e.course_class_group_id == null);
+    const cgIds = classEnrollments
+      .map((e) => e.course_class_group_id)
+      .filter((id): id is number => id != null);
+    const enrollmentIds = enrollments.map((e) => e.id);
+
+    const [kpis, myClasses, onDemandCourses, weeklySchedule, ranking, gamification] = await Promise.all([
+      this.getKpis(personId, enrollments, enrollmentIds),
+      this.getMyClasses(classEnrollments, now),
+      this.getOnDemandCourses(onDemandEnrollments),
+      this.getWeeklySchedule(cgIds, weekStart, weekEnd),
+      this.getRanking(personId, cgIds),
+      this.getGamification(personId, enrollmentIds, weekStart, weekEnd),
+    ]);
+
+    const myRanking = ranking.find((r) => r.isMe);
+
+    return {
+      kpis,
+      myClasses,
+      onDemandCourses,
+      weeklySchedule,
+      ranking,
+      gamification: {
+        ...gamification,
+        rankingPosition: myRanking?.position ?? null,
+      },
+    };
+  }
+
+  async getClassGroups(
+    userId: number,
+    options: {
+      enterpriseId?: number;
+      search?: string;
+      status?: string;
+      deliveryMode?: string;
+    } = {},
+  ) {
+    const personUser = await this.prisma.person_user.findFirst({
+      where: { user_id: userId },
+      select: { person_id: true },
+    });
+
+    if (!personUser) {
+      throw new NotFoundException('No person profile found for this user');
+    }
+
+    const personId = personUser.person_id;
+    const { enterpriseId, search, status, deliveryMode } = options;
+    const now = new Date();
+
+    let cgFilter: any = {};
+    if (enterpriseId !== undefined) {
+      cgFilter = { enterprise_class_group: { some: { enterprise_id: enterpriseId } } };
+    }
+    if (status) {
+      cgFilter = { ...cgFilter, status: status as any };
+    }
+    if (deliveryMode) {
+      cgFilter = { ...cgFilter, delivery_mode: deliveryMode as any };
+    }
+    if (search) {
+      cgFilter = {
+        ...cgFilter,
+        OR: [
+          { title: { contains: search, mode: 'insensitive' as const } },
+          { code: { contains: search, mode: 'insensitive' as const } },
+          { course: { title: { contains: search, mode: 'insensitive' as const } } },
+        ],
+      };
+    }
+
+    const enrollments = await this.prisma.course_enrollment.findMany({
+      where: {
+        person_id: personId,
+        status: { not: 'cancelled' },
+        course_class_group_id: { not: null },
+        course_class_group: Object.keys(cgFilter).length > 0 ? cgFilter : undefined,
+      },
+      include: {
+        course_class_group: {
+          include: {
+            course: {
+              select: {
+                id: true,
+                title: true,
+                course_image: {
+                  where: { image_type: { slug: { in: ['course-logo', 'course-banner'] } } },
+                  orderBy: { is_primary: 'desc' as const },
+                  select: {
+                    file: { select: { location: true } },
+                    image_type: { select: { slug: true } },
+                  },
+                },
+              },
+            },
+            instructor: {
+              include: { person: { select: { name: true } } },
+            },
+            course_class_session: {
+              where: { session_date: { gte: now } },
+              orderBy: { session_date: 'asc' },
+              take: 1,
+              select: { session_date: true, start_time: true, location: true },
+            },
+          },
+        },
+      },
+      orderBy: { enrolled_at: 'desc' },
+    });
+
+    // Compute session totals per class group for hour estimation
+    const cgIds = enrollments
+      .map((e) => e.course_class_group_id)
+      .filter((id): id is number => id != null);
+
+    const [totalSessionCounts, pastSessionCounts] =
+      cgIds.length > 0
+        ? await Promise.all([
+            this.prisma.course_class_session.groupBy({
+              by: ['course_class_group_id'],
+              where: { course_class_group_id: { in: cgIds } },
+              _count: { id: true },
+            }),
+            this.prisma.course_class_session.groupBy({
+              by: ['course_class_group_id'],
+              where: { course_class_group_id: { in: cgIds }, session_date: { lt: now } },
+              _count: { id: true },
+            }),
+          ])
+        : [[], []];
+
+    const totalSessionMap = new Map(totalSessionCounts.map((r) => [r.course_class_group_id, r._count.id]));
+    const pastSessionMap = new Map(pastSessionCounts.map((r) => [r.course_class_group_id, r._count.id]));
+
+    const HOURS_PER_SESSION = 2;
+
+    const data = enrollments.map((enrollment) => {
+      const cg = enrollment.course_class_group;
+      if (!cg) return null;
+      const nextSession = cg.course_class_session[0] ?? null;
+      const totalSessions = totalSessionMap.get(cg.id) ?? 0;
+      const pastSessions = pastSessionMap.get(cg.id) ?? 0;
+
+      return {
+        id: enrollment.id,
+        classGroupId: cg.id,
+        courseId: cg.course?.id ?? null,
+        courseName: cg.course?.title ?? null,
+        courseLogoUrl:
+          cg.course?.course_image.find((ci) => ci.image_type?.slug === 'course-logo')?.file
+            ?.location ?? null,
+        courseBannerUrl:
+          cg.course?.course_image.find((ci) => ci.image_type?.slug === 'course-banner')?.file
+            ?.location ?? null,
+        className: cg.title,
+        code: cg.code ?? '',
+        instructorName: (cg as any).instructor?.person?.name ?? null,
+        instructorAvatarUrl: null as string | null,
+        progress: enrollment.progress_percent ?? 0,
+        nextSession: nextSession
+          ? {
+              date: nextSession.session_date,
+              time: nextSession.start_time,
+              location: nextSession.location ?? null,
+            }
+          : null,
+        status: cg.status,
+        deliveryMode: cg.delivery_mode ?? null,
+        totalHours: totalSessions * HOURS_PER_SESSION,
+        completedHours: pastSessions * HOURS_PER_SESSION,
+      };
+    }).filter((item): item is NonNullable<typeof item> => item !== null);
+
+    return { data, total: data.length };
+  }
+
+  // ── Private helpers ───────────────────────────────────────────────────────────
+
+  private async getKpis(
+    personId: number,
+    enrollments: Array<{
+      id: number;
+      status: string;
+      progress_percent: number | null;
+    }>,
+    enrollmentIds: number[],
+  ) {
+    const completedCourses = enrollments.filter((e) => e.status === 'completed').length;
+    const activeEnrollments = enrollments.filter((e) =>
+      ['active', 'completed'].includes(e.status),
+    );
+
+    const overallProgress =
+      activeEnrollments.length > 0
+        ? this.round(
+            activeEnrollments.reduce((sum, e) => sum + (e.progress_percent ?? 0), 0) /
+              activeEnrollments.length,
+            0,
+          )
+        : 0;
+
+    const [pendingEvaluations, attendanceData] = await Promise.all([
+      enrollmentIds.length > 0
+        ? this.prisma.exam_attempt.count({
+            where: {
+              course_enrollment_id: { in: enrollmentIds },
+              status: { not: 'completed' },
+            },
+          })
+        : Promise.resolve(0),
+      this.prisma.course_class_attendance.findMany({
+        where: { student_id: personId },
+        select: { present: true },
+      }),
+    ]);
+
+    const totalAttendance = (attendanceData as Array<{ present: boolean }>).length;
+    const presentAttendance = (attendanceData as Array<{ present: boolean }>).filter(
+      (a) => a.present,
+    ).length;
+    const attendancePct =
+      totalAttendance > 0 ? this.round((presentAttendance / totalAttendance) * 100, 0) : 0;
+
+    return {
+      attendancePct: {
+        value: attendancePct,
+        change: null,
+        changeType: 'percent' as const,
+      },
+      overallProgress: {
+        value: overallProgress,
+        change: null,
+        changeType: 'percent' as const,
+      },
+      completedCourses: {
+        value: completedCourses,
+        change: null,
+        changeType: 'absolute' as const,
+      },
+      pendingEvaluations: {
+        value: pendingEvaluations,
+        change: null,
+        changeType: 'absolute' as const,
+      },
+    };
+  }
+
+  private async getMyClasses(
+    classEnrollments: Array<{
+      id: number;
+      course_id: number;
+      course_class_group_id: number | null;
+      progress_percent: number | null;
+    }>,
+    now: Date,
+  ) {
+    if (classEnrollments.length === 0) return [];
+
+    const cgIds = classEnrollments
+      .map((e) => e.course_class_group_id)
+      .filter((id): id is number => id != null);
+
+    const classGroups = await this.prisma.course_class_group.findMany({
+      where: { id: { in: cgIds } },
+      include: {
+        course: {
+          select: {
+            id: true,
+            title: true,
+            course_image: {
+              where: { image_type: { slug: 'course-logo' } },
+              orderBy: { is_primary: 'desc' as const },
+              take: 1,
+              select: { file: { select: { id: true } } },
+            },
+          },
+        },
+        course_class_session: {
+          where: { session_date: { gte: now } },
+          orderBy: { session_date: 'asc' },
+          take: 1,
+          include: {
+            course_class_session_instructor: {
+              where: { role: 'lead' },
+              take: 1,
+              include: {
+                instructor: { include: { person: { select: { name: true } } } },
+              },
+            },
+          },
+        },
+      },
+    });
+
+    const cgById = new Map(classGroups.map((cg) => [cg.id, cg]));
+
+    return classEnrollments.map((enrollment) => {
+      const cg = cgById.get(enrollment.course_class_group_id!);
+      const nextSession = cg?.course_class_session[0] ?? null;
+      const leadInstructor =
+        nextSession?.course_class_session_instructor[0]?.instructor?.person?.name ?? null;
+
+      return {
+        enrollmentId: enrollment.id,
+        classGroupId: enrollment.course_class_group_id,
+        courseId: cg?.course?.id ?? null,
+        courseName: cg?.course?.title ?? null,
+        hasCourseLogo: !!(cg?.course as any)?.course_image?.[0],
+        className: cg?.title ?? null,
+        instructorName: leadInstructor,
+        progress: enrollment.progress_percent ?? 0,
+        nextSession: nextSession
+          ? {
+              date: nextSession.session_date,
+              time: nextSession.start_time,
+              location: nextSession.location ?? null,
+            }
+          : null,
+        status: cg?.status ?? null,
+        deliveryMode: cg?.delivery_mode ?? null,
+      };
+    });
+  }
+
+  private async getOnDemandCourses(
+    onDemandEnrollments: Array<{
+      id: number;
+      course_id: number;
+      progress_percent: number | null;
+    }>,
+  ) {
+    if (onDemandEnrollments.length === 0) return [];
+
+    const courseIds = onDemandEnrollments.map((e) => e.course_id);
+    const courses = await this.prisma.course.findMany({
+      where: { id: { in: courseIds } },
+      select: {
+        id: true,
+        title: true,
+        duration_hours: true,
+        course_image: {
+          where: { image_type: { slug: 'course-logo' } },
+          orderBy: { is_primary: 'desc' as const },
+          take: 1,
+          select: { file: { select: { id: true } } },
+        },
+      },
+    });
+
+    const courseById = new Map(courses.map((c) => [c.id, c]));
+
+    return onDemandEnrollments.map((enrollment) => {
+      const course = courseById.get(enrollment.course_id);
+      return {
+        enrollmentId: enrollment.id,
+        courseId: enrollment.course_id,
+        courseName: course?.title ?? null,
+        hasCourseLogo: !!(course as any)?.course_image?.[0],
+        durationHours: (course as any)?.duration_hours ?? null,
+        progress: enrollment.progress_percent ?? 0,
+      };
+    });
+  }
+
+  private async getWeeklySchedule(cgIds: number[], weekStart: Date, weekEnd: Date) {
+    if (cgIds.length === 0) return [];
+
+    const sessions = await this.prisma.course_class_session.findMany({
+      where: {
+        course_class_group_id: { in: cgIds },
+        session_date: { gte: weekStart, lte: weekEnd },
+      },
+      orderBy: [{ session_date: 'asc' }, { start_time: 'asc' }],
+      select: {
+        id: true,
+        session_date: true,
+        start_time: true,
+        end_time: true,
+        location: true,
+        course_class_group_id: true,
+        course_class_group: { select: { title: true } },
+      },
+    });
+
+    // Group by day of week
+    const byDay = new Map<string, typeof sessions>();
+    for (const s of sessions) {
+      const key = s.session_date.toISOString().slice(0, 10);
+      if (!byDay.has(key)) byDay.set(key, []);
+      byDay.get(key)!.push(s);
+    }
+
+    return Array.from(byDay.entries()).map(([date, daySessions]) => ({
+      date,
+      sessions: daySessions.map((s) => ({
+        sessionId: s.id,
+        time: s.start_time,
+        endTime: s.end_time ?? null,
+        className: s.course_class_group?.title ?? null,
+        location: s.location ?? null,
+      })),
+    }));
+  }
+
+  private async getRanking(personId: number, cgIds: number[]) {
+    if (cgIds.length === 0) return [];
+
+    const enrollments = await this.prisma.course_enrollment.findMany({
+      where: {
+        course_class_group_id: { in: cgIds },
+        status: { not: 'cancelled' },
+      },
+      orderBy: { progress_percent: 'desc' },
+      take: 10,
+      include: {
+        person: { select: { id: true, name: true } },
+      },
+    });
+
+    return enrollments.map((e, index) => ({
+      position: index + 1,
+      personId: e.person_id,
+      name: e.person?.name ?? null,
+      progress: e.progress_percent ?? 0,
+      isMe: e.person_id === personId,
+    }));
+  }
+
+  // ── Date helpers ──────────────────────────────────────────────────────────────
+
+  private async getGamification(
+    personId: number,
+    enrollmentIds: number[],
+    weekStart: Date,
+    weekEnd: Date,
+  ) {
+    const attendanceThisWeek = await this.prisma.course_class_attendance.count({
+      where: {
+        student_id: personId,
+        present: true,
+        course_class_session: { session_date: { gte: weekStart, lte: weekEnd } },
+      },
+    });
+
+    const studyHoursThisWeek = Math.round(attendanceThisWeek * 1.5 * 10) / 10;
+
+    // Streak: distinct dates with attendance, ordered desc
+    const attendanceDates = await this.prisma.course_class_attendance.findMany({
+      where: { student_id: personId, present: true },
+      select: { course_class_session: { select: { session_date: true } } },
+      orderBy: { course_class_session: { session_date: 'desc' } },
+    });
+
+    const uniqueDates = Array.from(
+      new Set(
+        attendanceDates
+          .map((a) => a.course_class_session?.session_date?.toISOString().slice(0, 10))
+          .filter((d): d is string => !!d),
+      ),
+    ).sort((a, b) => b.localeCompare(a));
+
+    let streak = 0;
+    if (uniqueDates.length > 0) {
+      const today = new Date();
+      today.setHours(0, 0, 0, 0);
+      let cursor = new Date(today);
+      for (const dateStr of uniqueDates) {
+        const d = new Date(dateStr + 'T00:00:00');
+        const diff = Math.round((cursor.getTime() - d.getTime()) / 86400000);
+        if (diff > 1) break;
+        streak++;
+        cursor = d;
+      }
+    }
+
+    return { streak, studyHoursThisWeek };
+  }
+
+  // ── Class-group detail endpoints ─────────────────────────────────────────────
+
+  private async resolvePersonIdFromUser(userId: number) {
+    const personUser = await this.prisma.person_user.findFirst({
+      where: { user_id: userId },
+      select: { person_id: true },
+    });
+    if (!personUser) throw new NotFoundException('No person profile found for this user');
+    return personUser.person_id;
+  }
+
+  private async assertStudentEnrolled(userId: number, classGroupId: number) {
+    const personId = await this.resolvePersonIdFromUser(userId);
+    const enrollment = await this.prisma.course_enrollment.findFirst({
+      where: { person_id: personId, course_class_group_id: classGroupId, status: { not: 'cancelled' } },
+      select: { id: true },
+    });
+    if (!enrollment) throw new NotFoundException('Enrollment not found for this class group');
+    return { personId };
+  }
+
+  async getClassGroupDetail(userId: number, classGroupId: number) {
+    const { personId } = await this.assertStudentEnrolled(userId, classGroupId);
+    const now = new Date();
+
+    const [cg, enrollment] = await Promise.all([
+      this.prisma.course_class_group.findUnique({
+        where: { id: classGroupId },
+        include: {
+          course: { select: { id: true, title: true } },
+          instructor: { select: { person: { select: { name: true } } } },
+          _count: { select: { course_enrollment: { where: { status: { not: 'cancelled' } } } } },
+          course_class_session: {
+            where: { session_date: { gte: now } },
+            orderBy: { session_date: 'asc' },
+            take: 1,
+            select: { id: true, title: true, session_date: true, start_time: true, location: true, meeting_url: true },
+          },
+        },
+      }),
+      this.prisma.course_enrollment.findFirst({
+        where: { person_id: personId, course_class_group_id: classGroupId },
+        select: { id: true, progress_percent: true, final_score: true, status: true },
+      }),
+    ]);
+
+    if (!cg || !enrollment) throw new NotFoundException(`Class group #${classGroupId} not found`);
+
+    const [totalSessions, pastSessions] = await Promise.all([
+      this.prisma.course_class_session.count({ where: { course_class_group_id: classGroupId } }),
+      this.prisma.course_class_session.count({ where: { course_class_group_id: classGroupId, session_date: { lt: now } } }),
+    ]);
+
+    const myAttendanceCount = await this.prisma.course_class_attendance.count({
+      where: { student_id: personId, present: true, course_class_session: { course_class_group_id: classGroupId } },
+    });
+    const myAttendance = totalSessions > 0 ? this.round((myAttendanceCount / totalSessions) * 100, 0) : 0;
+
+    const allEnrollments = await this.prisma.course_enrollment.findMany({
+      where: { course_class_group_id: classGroupId, status: { not: 'cancelled' } },
+      orderBy: { progress_percent: 'desc' },
+      select: { person_id: true, progress_percent: true },
+    });
+
+    const rankingPosition = allEnrollments.findIndex((e) => e.person_id === personId) + 1;
+    const totalStudents = allEnrollments.length;
+
+    const HOURS_PER_SESSION = 2;
+    const totalHours = totalSessions * HOURS_PER_SESSION;
+    const completedHours = pastSessions * HOURS_PER_SESSION;
+    const nextSession = cg.course_class_session[0] ?? null;
+
+    const rankingData = allEnrollments.slice(0, 5).map((e, idx) => ({
+      position: idx + 1,
+      personId: e.person_id,
+      progress: e.progress_percent ?? 0,
+      isMe: e.person_id === personId,
+    }));
+    if (rankingPosition > 5) {
+      rankingData.push({ position: rankingPosition, personId, progress: enrollment.progress_percent ?? 0, isMe: true });
+    }
+
+    return {
+      id: cg.id,
+      courseName: cg.course?.title ?? null,
+      className: cg.title,
+      code: cg.code ?? null,
+      instructorName: cg.instructor?.person?.name ?? null,
+      instructorAvatarUrl: null as string | null,
+      instructorBio: null as string | null,
+      startDate: cg.start_date,
+      endDate: cg.end_date ?? null,
+      status: cg.status,
+      deliveryMode: cg.delivery_mode,
+      totalHours,
+      completedHours,
+      lessonsCompleted: pastSessions,
+      totalLessons: totalSessions,
+      progress: enrollment.progress_percent ?? 0,
+      myGrade: enrollment.final_score != null ? Number(enrollment.final_score) : null,
+      myAttendance,
+      rankingPosition: rankingPosition > 0 ? rankingPosition : totalStudents,
+      totalStudents,
+      rankingData,
+      nextSession: nextSession
+        ? {
+            date: nextSession.session_date,
+            time: nextSession.start_time,
+            title: nextSession.title,
+            location: nextSession.location ?? null,
+            meetingUrl: nextSession.meeting_url ?? null,
+          }
+        : null,
+    };
+  }
+
+  async getClassGroupSessions(userId: number, classGroupId: number) {
+    await this.assertStudentEnrolled(userId, classGroupId);
+    const now = new Date();
+
+    const sessions = await this.prisma.course_class_session.findMany({
+      where: { course_class_group_id: classGroupId },
+      orderBy: { session_date: 'asc' },
+      select: {
+        id: true,
+        title: true,
+        session_date: true,
+        start_time: true,
+        end_time: true,
+        location: true,
+        meeting_url: true,
+      },
+    });
+
+    let hasFoundNext = false;
+    return sessions.map((s) => {
+      const isPast = s.session_date < now;
+      let status: 'completed' | 'next' | 'upcoming';
+      if (isPast) {
+        status = 'completed';
+      } else if (!hasFoundNext) {
+        status = 'next';
+        hasFoundNext = true;
+      } else {
+        status = 'upcoming';
+      }
+      return {
+        id: s.id,
+        title: s.title,
+        date: s.session_date,
+        time: s.start_time,
+        endTime: s.end_time ?? null,
+        location: s.location ?? null,
+        meetingUrl: s.meeting_url ?? null,
+        status,
+        recordingUrl: null as string | null,
+      };
+    });
+  }
+
+  async getClassGroupMaterials(userId: number, classGroupId: number) {
+    await this.assertStudentEnrolled(userId, classGroupId);
+
+    const materials = await this.prisma.course_class_group_material.findMany({
+      where: { course_class_group_id: classGroupId },
+      orderBy: [{ sort_order: 'asc' }, { created_at: 'asc' }],
+      select: { id: true, title: true, description: true, material_type: true, url: true },
+    });
+
+    return materials.map((m) => ({
+      id: m.id,
+      title: m.title,
+      description: m.description ?? null,
+      materialType: m.material_type,
+      url: m.url ?? null,
+    }));
+  }
+
+  async getMyEvaluations(userId: number, classGroupId: number) {
+    const { personId } = await this.assertStudentEnrolled(userId, classGroupId);
+
+    const enrollment = await this.prisma.course_enrollment.findFirst({
+      where: { person_id: personId, course_class_group_id: classGroupId, status: { not: 'cancelled' } },
+      select: { id: true },
+    });
+    if (!enrollment) throw new NotFoundException('Enrollment not found');
+
+    const attempts = await this.prisma.exam_attempt.findMany({
+      where: { course_enrollment_id: enrollment.id },
+      orderBy: { started_at: 'desc' },
+      include: { exam: { select: { id: true, title: true } } },
+    });
+
+    const data = attempts.map((a) => ({
+      id: a.id,
+      titulo: a.exam?.title ?? 'Avaliação',
+      data: a.started_at?.toISOString().slice(0, 10) ?? null,
+      nota: a.score != null ? Number(a.score) : null,
+      status: a.score != null ? 'graded' : a.status === 'completed' ? 'pending' : 'in_progress',
+      comentario: (a as any).feedback ?? null,
+    }));
+
+    const graded = data.filter((e) => e.nota != null);
+    const avg = graded.length > 0 ? this.round(graded.reduce((s, e) => s + (e.nota ?? 0), 0) / graded.length, 1) : 0;
+    return { avg, total: data.length, graded: graded.length, data };
+  }
+
+  private round(value: number, digits = 0) {
+    const factor = 10 ** digits;
+    return Math.round(value * factor) / factor;
+  }
+
+  private addDays(date: Date, days: number) {
+    const result = new Date(date);
+    result.setDate(result.getDate() + days);
+    return result;
+  }
+
+  private endOfDay(date: Date) {
+    const result = new Date(date);
+    result.setHours(23, 59, 59, 999);
+    return result;
+  }
+
+  private startOfWeek(date: Date) {
+    const result = new Date(date);
+    result.setHours(0, 0, 0, 0);
+    const day = result.getDay();
+    const diff = day === 0 ? -6 : 1 - day;
+    result.setDate(result.getDate() + diff);
+    return result;
+  }
+}