@hed-hog/lms 0.0.319 → 0.0.321

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

@@ -0,0 +1,1303 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { FileService } from '@hed-hog/core';
+import { Injectable, NotFoundException } from '@nestjs/common';
+
+@Injectable()
+export class TrainingInstructorService {
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly fileService: FileService,
+  ) {}
+
+  async getDashboard(userId: number, enterpriseId?: number) {
+    const instructor = await this.prisma.instructor.findFirst({
+      where: { person: { person_user: { some: { user_id: userId } } } },
+      select: { id: true, person: { select: { name: true } } },
+    });
+
+    if (!instructor) {
+      throw new NotFoundException('No instructor profile found for this user');
+    }
+
+    const now = new Date();
+    const weekStart = this.startOfWeek(now);
+    const weekEnd = this.endOfDay(this.addDays(weekStart, 6));
+
+    const enterpriseFilter = enterpriseId !== undefined
+      ? { enterprise_class_group: { some: { enterprise_id: enterpriseId } } }
+      : {};
+
+    // Collect class group IDs where this instructor has sessions
+    const sessionRows = await this.prisma.course_class_session.findMany({
+      where: {
+        course_class_session_instructor: { some: { instructor_id: instructor.id } },
+        course_class_group: { status: { in: ['open', 'ongoing'] }, ...enterpriseFilter },
+      },
+      select: { course_class_group_id: true },
+      distinct: ['course_class_group_id'],
+    });
+
+    const cgIds = sessionRows
+      .map((r) => r.course_class_group_id)
+      .filter((id): id is number => id != null);
+
+    const [kpis, weeklyAgenda, myClasses, receivedFeedback] = await Promise.all([
+      this.getKpis(instructor.id, cgIds, weekStart, weekEnd),
+      this.getWeeklyAgenda(instructor.id, weekStart, weekEnd),
+      this.getMyClasses(cgIds, now),
+      this.getReceivedFeedbackSummary(instructor.id),
+    ]);
+
+    return {
+      kpis,
+      weeklyAgenda,
+      myClasses,
+      receivedFeedback,
+    };
+  }
+
+  // ── Private helpers ───────────────────────────────────────────────────────────
+
+  private async getKpis(
+    instructorId: number,
+    cgIds: number[],
+    weekStart: Date,
+    weekEnd: Date,
+  ) {
+    const [totalStudents, sessionsThisWeek, avgScore] = await Promise.all([
+      cgIds.length > 0
+        ? this.prisma.course_enrollment.count({
+            where: {
+              course_class_group_id: { in: cgIds },
+              status: { not: 'cancelled' },
+            },
+          })
+        : Promise.resolve(0),
+      this.prisma.course_class_session.count({
+        where: {
+          course_class_session_instructor: { some: { instructor_id: instructorId } },
+          session_date: { gte: weekStart, lte: weekEnd },
+        },
+      }),
+      this.prisma.exam_attempt.aggregate({
+        where: {
+          status: 'completed',
+          score: { not: null },
+          course_enrollment: {
+            course_class_group_id: cgIds.length > 0 ? { in: cgIds } : undefined,
+          },
+        },
+        _avg: { score: true },
+      }),
+    ]);
+
+    return {
+      activeClasses: {
+        value: cgIds.length,
+        change: null,
+        changeType: 'absolute' as const,
+      },
+      totalStudents: {
+        value: totalStudents,
+        change: null,
+        changeType: 'absolute' as const,
+      },
+      sessionsThisWeek: {
+        value: sessionsThisWeek,
+        change: null,
+        changeType: 'absolute' as const,
+      },
+      averageScore: {
+        value: this.round(avgScore._avg.score ?? 0, 1),
+        change: null,
+        changeType: 'absolute' as const,
+      },
+    };
+  }
+
+  private async getWeeklyAgenda(instructorId: number, weekStart: Date, weekEnd: Date) {
+    const sessions = await this.prisma.course_class_session.findMany({
+      where: {
+        course_class_session_instructor: { some: { instructor_id: instructorId } },
+        session_date: { gte: weekStart, lte: weekEnd },
+      },
+      orderBy: [{ session_date: 'asc' }, { start_time: 'asc' }],
+      include: {
+        course_class_group: {
+          include: {
+            course: { select: { title: true } },
+            _count: {
+              select: {
+                course_enrollment: { where: { status: { not: 'cancelled' } } },
+              },
+            },
+          },
+        },
+      },
+    });
+
+    return sessions.map((s) => ({
+      sessionId: s.id,
+      classGroupId: s.course_class_group?.id ?? null,
+      date: s.session_date,
+      time: s.start_time,
+      endTime: s.end_time ?? null,
+      className: s.course_class_group?.title ?? null,
+      courseName: s.course_class_group?.course?.title ?? null,
+      topic: (s as any).topic ?? null,
+      location: s.location ?? null,
+      meetingUrl: s.meeting_url ?? null,
+      deliveryMode: s.course_class_group?.delivery_mode ?? null,
+      studentCount: s.course_class_group?._count.course_enrollment ?? 0,
+    }));
+  }
+
+  private async getMyClasses(cgIds: number[], now: Date) {
+    if (cgIds.length === 0) return [];
+
+    const classGroups = await this.prisma.course_class_group.findMany({
+      where: { id: { in: cgIds } },
+      orderBy: { start_date: 'desc' },
+      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: { location: true } } },
+            },
+          },
+        },
+        _count: {
+          select: {
+            course_enrollment: { where: { status: { not: 'cancelled' } } },
+          },
+        },
+        course_class_session: {
+          where: { session_date: { gte: now } },
+          orderBy: { session_date: 'asc' },
+          take: 1,
+          select: { session_date: true, start_time: true, location: true },
+        },
+      },
+    });
+
+    return classGroups.map((cg) => {
+      const nextSession = cg.course_class_session[0] ?? null;
+      const start = cg.start_date?.getTime() ?? 0;
+      const end = cg.end_date?.getTime() ?? 0;
+      const elapsed = end > start ? ((now.getTime() - start) / (end - start)) * 100 : 0;
+
+      return {
+        id: cg.id,
+        name: cg.title,
+        code: cg.code ?? null,
+        courseId: cg.course?.id ?? null,
+        courseName: cg.course?.title ?? null,
+        courseLogoUrl: cg.course?.course_image?.[0]?.file?.location ?? null,
+        studentCount: cg._count.course_enrollment,
+        nextSession: nextSession
+          ? {
+              date: nextSession.session_date,
+              time: nextSession.start_time,
+              location: nextSession.location ?? null,
+            }
+          : null,
+        progress: this.round(Math.min(Math.max(elapsed, 0), 100), 0),
+        status: cg.status,
+        deliveryMode: cg.delivery_mode ?? null,
+        pendingEvaluations: 0, // populated separately if needed
+      };
+    });
+  }
+
+  private async getReceivedFeedbackSummary(instructorId: number) {
+    // Find session IDs taught by this instructor
+    const sessionRows = await this.prisma.course_class_session.findMany({
+      where: {
+        course_class_session_instructor: { some: { instructor_id: instructorId } },
+      },
+      select: {
+        id: true,
+        title: true,
+        session_date: true,
+        course_class_group: { select: { title: true } },
+      },
+      orderBy: { session_date: 'desc' },
+    });
+
+    const sessionIds = sessionRows.map((s) => s.id);
+    if (sessionIds.length === 0) {
+      return { totalRatings: 0, averageScore: 0, recentItems: [] };
+    }
+
+    // Fetch evaluation topics for these sessions
+    const topics = await this.prisma.evaluation_topic.findMany({
+      where: {
+        course_class_session_id: { in: sessionIds },
+        target_type: 'course_class_session',
+        is_active: true,
+      },
+      include: {
+        evaluation_rating: { select: { score: true } },
+        course_class_session: {
+          select: {
+            id: true,
+            title: true,
+            session_date: true,
+            course_class_group: { select: { title: true } },
+          },
+        },
+      },
+    });
+
+    // Aggregate per session
+    const sessionMap = new Map<number, {
+      sessionTitle: string;
+      className: string | null;
+      sessionDate: Date;
+      scores: number[];
+    }>();
+
+    for (const topic of topics) {
+      const sess = topic.course_class_session;
+      if (!sess) continue;
+      if (!sessionMap.has(sess.id)) {
+        sessionMap.set(sess.id, {
+          sessionTitle: sess.title,
+          className: sess.course_class_group?.title ?? null,
+          sessionDate: sess.session_date,
+          scores: [],
+        });
+      }
+      for (const r of topic.evaluation_rating) {
+        sessionMap.get(sess.id)!.scores.push(Number(r.score));
+      }
+    }
+
+    const allScores = [...sessionMap.values()].flatMap((v) => v.scores);
+    const totalRatings = allScores.length;
+    const averageScore =
+      totalRatings > 0 ? this.round(allScores.reduce((a, b) => a + b, 0) / totalRatings, 1) : 0;
+
+    // Recent items — last 5 sessions with at least 1 rating, sorted desc
+    const recentItems = [...sessionMap.entries()]
+      .filter(([, v]) => v.scores.length > 0)
+      .sort(([, a], [, b]) => b.sessionDate.getTime() - a.sessionDate.getTime())
+      .slice(0, 5)
+      .map(([, v]) => ({
+        sessionTitle: v.sessionTitle,
+        className: v.className,
+        sessionDate: v.sessionDate,
+        avgScore: this.round(v.scores.reduce((a, b) => a + b, 0) / v.scores.length, 1),
+        ratingCount: v.scores.length,
+      }));
+
+    return { totalRatings, averageScore, recentItems };
+  }
+
+  private async getPendingEvals(cgIds: number[]) {
+    if (cgIds.length === 0) return [];
+
+    const attempts = await this.prisma.exam_attempt.findMany({
+      where: {
+        status: 'completed',
+        score: null,
+        course_enrollment: { course_class_group_id: { in: cgIds } },
+      },
+      take: 20,
+      orderBy: { finished_at: 'asc' },
+      include: {
+        course_enrollment: {
+          include: {
+            person: { select: { name: true } },
+            course_class_group: { select: { title: true } },
+          },
+        },
+        exam: { select: { id: true, title: true } },
+      },
+    });
+
+    return attempts.map((a) => ({
+      attemptId: a.id,
+      studentName: a.course_enrollment?.person?.name ?? null,
+      className: a.course_enrollment?.course_class_group?.title ?? null,
+      examTitle: a.exam?.title ?? null,
+      submittedAt: a.finished_at,
+    }));
+  }
+
+  // ── Date helpers ──────────────────────────────────────────────────────────────
+
+  async getClassGroups(
+    userId: number,
+    options: {
+      enterpriseId?: number;
+      search?: string;
+      status?: string;
+      deliveryMode?: string;
+    } = {},
+  ) {
+    const instructor = await this.prisma.instructor.findFirst({
+      where: { person: { person_user: { some: { user_id: userId } } } },
+      select: { id: true },
+    });
+
+    if (!instructor) {
+      throw new NotFoundException('No instructor profile found for this user');
+    }
+
+    const { enterpriseId, search, status, deliveryMode } = options;
+    const now = new Date();
+
+    // IDs where instructor leads at least one session
+    const sessionRows = await this.prisma.course_class_session.findMany({
+      where: {
+        course_class_session_instructor: { some: { instructor_id: instructor.id } },
+      },
+      select: { course_class_group_id: true },
+      distinct: ['course_class_group_id'],
+    });
+    const cgIdsFromSessions = sessionRows
+      .map((r) => r.course_class_group_id)
+      .filter((id): id is number => id != null);
+
+    const classGroups = await this.prisma.course_class_group.findMany({
+      where: {
+        AND: [
+          // instructor of the group OR instructor of at least one session
+          {
+            OR: [
+              { instructor_id: instructor.id },
+              { id: { in: cgIdsFromSessions } },
+            ],
+          },
+          // enterprise filter
+          ...(enterpriseId !== undefined
+            ? [{ enterprise_class_group: { some: { enterprise_id: enterpriseId } } }]
+            : []),
+          // status filter
+          ...(status ? [{ status: status as any }] : []),
+          // delivery mode filter
+          ...(deliveryMode ? [{ delivery_mode: deliveryMode as any }] : []),
+          // search filter
+          ...(search
+            ? [
+                {
+                  OR: [
+                    { title: { contains: search, mode: 'insensitive' as const } },
+                    { code:  { contains: search, mode: 'insensitive' as const } },
+                    { course: { title: { contains: search, mode: 'insensitive' as const } } },
+                  ],
+                },
+              ]
+            : []),
+        ],
+      },
+      orderBy: { start_date: 'desc' },
+      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 } },
+              },
+            },
+          },
+        },
+        _count: {
+          select: {
+            course_enrollment: { where: { status: { not: 'cancelled' } } },
+          },
+        },
+        course_class_session: {
+          where: { session_date: { gte: now } },
+          orderBy: { session_date: 'asc' },
+          take: 1,
+          select: {
+            session_date: true,
+            start_time: true,
+            location: true,
+            meeting_url: true,
+          },
+        },
+        exam: {
+          select: {
+            id: true,
+            exam_attempt: {
+              where: { status: 'completed', score: null },
+              select: { id: true },
+            },
+          },
+        },
+      },
+    });
+
+    const data = classGroups.map((cg) => {
+      const start = cg.start_date?.getTime() ?? 0;
+      const end = cg.end_date?.getTime() ?? 0;
+      const elapsed = end > start ? ((now.getTime() - start) / (end - start)) * 100 : 0;
+
+      const nextSession = cg.course_class_session[0] ?? null;
+
+      const pendingEvaluations = cg.exam.reduce(
+        (sum, ex) => sum + ex.exam_attempt.length,
+        0,
+      );
+
+      return {
+        id: cg.id,
+        name: cg.title,
+        code: cg.code ?? '',
+        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,
+        studentCount: cg._count.course_enrollment,
+        maxStudents: cg.capacity,
+        nextSession: nextSession
+          ? {
+              date: nextSession.session_date,
+              time: nextSession.start_time,
+              location: nextSession.location ?? null,
+              meetingUrl: nextSession.meeting_url ?? null,
+            }
+          : null,
+        progress: this.round(Math.min(Math.max(elapsed, 0), 100), 0),
+        status: cg.status,
+        deliveryMode: cg.delivery_mode,
+        startDate: cg.start_date,
+        endDate: cg.end_date ?? null,
+        pendingEvaluations,
+      };
+    });
+
+    return { data, total: data.length };
+  }
+
+  // ── Class-group detail endpoints ─────────────────────────────────────────────
+
+  private async assertInstructorOwnsClass(userId: number, classGroupId: number) {
+    const instructor = await this.prisma.instructor.findFirst({
+      where: { person: { person_user: { some: { user_id: userId } } } },
+      select: { id: true },
+    });
+    if (!instructor) throw new NotFoundException('No instructor profile found for this user');
+
+    const cg = await this.prisma.course_class_group.findFirst({
+      where: {
+        id: classGroupId,
+        OR: [
+          { instructor_id: instructor.id },
+          {
+            course_class_session: {
+              some: {
+                course_class_session_instructor: { some: { instructor_id: instructor.id } },
+              },
+            },
+          },
+        ],
+      },
+      select: { id: true },
+    });
+    if (!cg) throw new NotFoundException('Class group not found or not accessible to this instructor');
+    return { instructorId: instructor.id };
+  }
+
+  async getClassGroupDetail(userId: number, classGroupId: number) {
+    await this.assertInstructorOwnsClass(userId, classGroupId);
+    const now = new Date();
+
+    const cg = await 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: true,
+          },
+        },
+        course_class_session: {
+          where: { session_date: { gte: now } },
+          orderBy: { session_date: 'asc' },
+          take: 1,
+          select: { session_date: true, start_time: true, location: true, meeting_url: true },
+        },
+      },
+    });
+    if (!cg) throw new NotFoundException(`Class group #${classGroupId} not found`);
+
+    // completedSessions = sessions with session_date < now
+    const completedSessions = await this.prisma.course_class_session.count({
+      where: { course_class_group_id: classGroupId, session_date: { lt: now } },
+    });
+
+    // avgAttendance: mean of (present/total) per past session
+    const pastSessions = await this.prisma.course_class_session.findMany({
+      where: { course_class_group_id: classGroupId, session_date: { lt: now } },
+      select: {
+        id: true,
+        _count: { select: { course_class_attendance: true } },
+        course_class_attendance: {
+          where: { present: true },
+          select: { student_id: true },
+        },
+      },
+    });
+
+    const totalEnrolled = cg._count.course_enrollment;
+    let avgAttendance = 0;
+    if (pastSessions.length > 0 && totalEnrolled > 0) {
+      const pcts = pastSessions.map((s) =>
+        (s.course_class_attendance.length / totalEnrolled) * 100,
+      );
+      avgAttendance = this.round(pcts.reduce((a, b) => a + b, 0) / pcts.length, 0);
+    }
+
+    const nextSession = cg.course_class_session[0] ?? null;
+
+    return {
+      id: cg.id,
+      courseName: cg.course?.title ?? null,
+      className: cg.title,
+      code: cg.code,
+      instructorName: cg.instructor?.person?.name ?? null,
+      startDate: cg.start_date,
+      endDate: cg.end_date ?? null,
+      status: cg.status,
+      deliveryMode: cg.delivery_mode,
+      totalSlots: cg.capacity,
+      enrolledCount: totalEnrolled,
+      totalSessions: cg._count.course_class_session,
+      completedSessions,
+      avgAttendance,
+      nextSession: nextSession
+        ? {
+            date: nextSession.session_date,
+            time: nextSession.start_time,
+            location: nextSession.location ?? null,
+            meetingUrl: nextSession.meeting_url ?? null,
+          }
+        : null,
+    };
+  }
+
+  async getClassGroupStudents(
+    userId: number,
+    classGroupId: number,
+    params: { page?: number; pageSize?: number; search?: string; status?: string },
+  ) {
+    await this.assertInstructorOwnsClass(userId, classGroupId);
+    const page = Math.max(Number(params.page) || 1, 1);
+    const pageSize = Math.max(Number(params.pageSize) || 20, 1);
+    const skip = (page - 1) * pageSize;
+
+    const where: any = {
+      course_class_group_id: classGroupId,
+      status: { not: 'cancelled' },
+    };
+    if (params.search) {
+      where.person = { name: { contains: params.search, mode: 'insensitive' } };
+    }
+
+    const [enrollments, total, totalSessions] = await Promise.all([
+      this.prisma.course_enrollment.findMany({
+        where,
+        skip,
+        take: pageSize,
+        orderBy: { person: { name: 'asc' } },
+        include: {
+          person: { select: { id: true, name: true } },
+        },
+      }),
+      this.prisma.course_enrollment.count({ where }),
+      this.prisma.course_class_session.count({ where: { course_class_group_id: classGroupId } }),
+    ]);
+
+    if (enrollments.length === 0) {
+      return { total, page, pageSize, lastPage: Math.max(1, Math.ceil(total / pageSize)), data: [] };
+    }
+
+    // Fetch attendance counts per student in one query
+    const personIds = enrollments.map((e) => e.person_id).filter(Boolean) as number[];
+    const attendanceRows = await this.prisma.course_class_attendance.groupBy({
+      by: ['student_id'],
+      where: { student_id: { in: personIds }, present: true },
+      _count: { id: true },
+    });
+    const attendanceMap = new Map(attendanceRows.map((r) => [r.student_id, r._count.id]));
+
+    const data = enrollments.map((e) => {
+      const presentCount = attendanceMap.get(e.person_id ?? 0) ?? 0;
+      const attendance = totalSessions > 0 ? this.round((presentCount / totalSessions) * 100, 0) : 0;
+      const progress = e.progress_percent ?? 0;
+      const grade = e.final_score != null ? Number(e.final_score) : null;
+      let status: 'ok' | 'risk' | 'inactive';
+      if (e.status === 'paused') status = 'inactive';
+      else if (attendance < 60 || progress < 50) status = 'risk';
+      else status = 'ok';
+
+      // Filter by status if requested
+      return { _status: status, id: e.person_id, name: e.person?.name ?? null, avatarUrl: null, progress, attendance, grade, status };
+    }).filter((s) => !params.status || s.status === params.status);
+
+    return {
+      total,
+      page,
+      pageSize,
+      lastPage: Math.max(1, Math.ceil(total / pageSize)),
+      data: data.map(({ _status: _, ...rest }) => rest),
+    };
+  }
+
+  async getClassGroupSessions(userId: number, classGroupId: number) {
+    await this.assertInstructorOwnsClass(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,
+        _count: { select: { course_class_attendance: true } },
+        course_class_attendance: {
+          where: { present: true },
+          select: { student_id: true },
+        },
+      },
+    });
+
+    const totalStudents = await this.prisma.course_enrollment.count({
+      where: { course_class_group_id: classGroupId, status: { not: 'cancelled' } },
+    });
+
+    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,
+        attendanceCount: isPast ? s.course_class_attendance.length : null,
+        totalStudents,
+      };
+    });
+  }
+
+  async getClassGroupAttendance(userId: number, classGroupId: number) {
+    await this.assertInstructorOwnsClass(userId, classGroupId);
+    const now = new Date();
+
+    const [sessions, enrollments] = await Promise.all([
+      this.prisma.course_class_session.findMany({
+        where: { course_class_group_id: classGroupId, session_date: { lt: now } },
+        orderBy: { session_date: 'asc' },
+        select: {
+          id: true,
+          title: true,
+          session_date: true,
+          course_class_attendance: {
+            select: { student_id: true, present: true },
+          },
+        },
+      }),
+      this.prisma.course_enrollment.findMany({
+        where: { course_class_group_id: classGroupId, status: { not: 'cancelled' } },
+        select: { person_id: true, person: { select: { name: true } } },
+        orderBy: { person: { name: 'asc' } },
+      }),
+    ]);
+
+    return {
+      students: enrollments.map((e) => ({
+        studentId: e.person_id,
+        studentName: e.person?.name ?? null,
+      })),
+      sessions: sessions.map((s) => {
+        const attendanceMap = new Map(s.course_class_attendance.map((a) => [a.student_id, a.present]));
+        return {
+          sessionId: s.id,
+          title: s.title,
+          date: s.session_date,
+          records: enrollments.map((e) => ({
+            studentId: e.person_id,
+            present: attendanceMap.get(e.person_id ?? 0) ?? null,
+          })),
+        };
+      }),
+    };
+  }
+
+  async getClassGroupMaterials(userId: number, classGroupId: number) {
+    await this.assertInstructorOwnsClass(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,
+        file_id: true,
+        url: true,
+        course_class_session_id: true,
+        sort_order: true,
+        created_at: true,
+      },
+    });
+
+    return materials.map((m) => ({
+      id: m.id,
+      title: m.title,
+      description: m.description ?? null,
+      materialType: m.material_type,
+      fileId: m.file_id ?? null,
+      url: m.url ?? null,
+      sessionId: m.course_class_session_id ?? null,
+      sortOrder: m.sort_order,
+      createdAt: m.created_at?.toISOString() ?? null,
+    }));
+  }
+
+  async getMaterialDownloadUrl(userId: number, classGroupId: number, materialId: number) {
+    await this.assertInstructorOwnsClass(userId, classGroupId);
+
+    const material = await this.prisma.course_class_group_material.findFirst({
+      where: { id: materialId, course_class_group_id: classGroupId },
+      select: { file_id: true },
+    });
+
+    if (!material) {
+      throw new NotFoundException('Material not found');
+    }
+
+    if (!material.file_id) {
+      throw new NotFoundException('This material has no associated file');
+    }
+
+    const file = await this.fileService.get(material.file_id);
+    return { url: await this.fileService.tempURL(file.path) };
+  }
+
+  async uploadMaterial(userId: number, classGroupId: number, file: MulterFile) {
+    await this.assertInstructorOwnsClass(userId, classGroupId);
+
+    const uploaded = await this.fileService.upload('class-materials', file);
+
+    const material = await this.prisma.course_class_group_material.create({
+      data: {
+        course_class_group_id: classGroupId,
+        title: uploaded.filename,
+        material_type: 'file' as any,
+        file_id: uploaded.id,
+        sort_order: 0,
+      },
+      select: {
+        id: true,
+        title: true,
+        description: true,
+        material_type: true,
+        file_id: true,
+        url: true,
+        course_class_session_id: true,
+        sort_order: true,
+        created_at: true,
+      },
+    });
+
+    return {
+      id: material.id,
+      title: material.title,
+      description: material.description ?? null,
+      materialType: material.material_type,
+      fileId: material.file_id ?? null,
+      url: material.url ?? null,
+      sessionId: material.course_class_session_id ?? null,
+      sortOrder: material.sort_order,
+      createdAt: material.created_at?.toISOString() ?? null,
+    };
+  }
+
+  async deleteMaterial(userId: number, classGroupId: number, materialId: number) {
+    await this.assertInstructorOwnsClass(userId, classGroupId);
+
+    const material = await this.prisma.course_class_group_material.findFirst({
+      where: { id: materialId, course_class_group_id: classGroupId },
+      select: { id: true },
+    });
+
+    if (!material) {
+      throw new NotFoundException('Material not found');
+    }
+
+    await this.prisma.course_class_group_material.delete({
+      where: { id: materialId },
+    });
+
+    return { success: true };
+  }
+
+  async getClassEvaluations(userId: number, classGroupId: number) {
+    await this.assertInstructorOwnsClass(userId, classGroupId);
+
+    // Fetch sessions of this class group
+    const sessions = await this.prisma.course_class_session.findMany({
+      where: { course_class_group_id: classGroupId },
+      select: { id: true, title: true, session_date: true },
+      orderBy: { session_date: 'asc' },
+    });
+
+    const sessionIds = sessions.map((s) => s.id);
+    if (sessionIds.length === 0) {
+      return {
+        totalRatings: 0,
+        averageScore: 0,
+        distribution: [
+          { range: '9–10', count: 0 },
+          { range: '7–8',  count: 0 },
+          { range: '5–6',  count: 0 },
+          { range: '0–4',  count: 0 },
+        ],
+        sessions: [],
+      };
+    }
+
+    // Fetch active evaluation topics for these sessions (anonymous — scores + comments, per-topic names)
+    const topics = await this.prisma.evaluation_topic.findMany({
+      where: {
+        course_class_session_id: { in: sessionIds },
+        target_type: 'course_class_session',
+        is_active: true,
+      },
+      select: {
+        id: true,
+        name: true,
+        course_class_session_id: true,
+        evaluation_rating: { select: { score: true, comment: true } },
+      },
+    });
+
+    // Build per-session aggregations (scores, anonymous comments, per-topic breakdown)
+    type SessionAgg = {
+      scores: number[];
+      comments: string[];
+      topics: Map<number, { name: string; scores: number[] }>;
+    };
+    const sessionMap = new Map<number, SessionAgg>();
+    for (const sessId of sessionIds) {
+      sessionMap.set(sessId, { scores: [], comments: [], topics: new Map() });
+    }
+    for (const topic of topics) {
+      const sessId = topic.course_class_session_id;
+      if (sessId == null) continue;
+      const agg = sessionMap.get(sessId);
+      if (!agg) continue;
+      if (!agg.topics.has(topic.id)) {
+        agg.topics.set(topic.id, { name: topic.name, scores: [] });
+      }
+      const topicAgg = agg.topics.get(topic.id)!;
+      for (const r of topic.evaluation_rating) {
+        const score = Number(r.score);
+        agg.scores.push(score);
+        topicAgg.scores.push(score);
+        if (r.comment) agg.comments.push(r.comment);
+      }
+    }
+
+    const allScores = [...sessionMap.values()].flatMap((a) => a.scores);
+    const totalRatings = allScores.length;
+    const averageScore =
+      totalRatings > 0 ? this.round(allScores.reduce((a, b) => a + b, 0) / totalRatings, 1) : 0;
+
+    const distribution = [
+      { range: '9–10', count: allScores.filter((s) => s >= 9).length },
+      { range: '7–8',  count: allScores.filter((s) => s >= 7 && s < 9).length },
+      { range: '5–6',  count: allScores.filter((s) => s >= 5 && s < 7).length },
+      { range: '0–4',  count: allScores.filter((s) => s < 5).length },
+    ];
+
+    const sessionData = sessions.map((s) => {
+      const agg = sessionMap.get(s.id) ?? {
+        scores: [], comments: [], topics: new Map<number, { name: string; scores: number[] }>(),
+      };
+      const avg =
+        agg.scores.length > 0
+          ? this.round(agg.scores.reduce((a, b) => a + b, 0) / agg.scores.length, 1)
+          : null;
+      const topicBreakdown = Array.from(agg.topics.entries()).map(([topicId, { name, scores }]) => ({
+        topicId,
+        name,
+        avgScore:
+          scores.length > 0
+            ? this.round(scores.reduce((a, b) => a + b, 0) / scores.length, 1)
+            : null,
+      }));
+      return {
+        sessionId:   s.id,
+        title:       s.title,
+        date:        s.session_date,
+        avgScore:    avg,
+        ratingCount: agg.scores.length,
+        topics:      topicBreakdown,
+        comments:    agg.comments,
+      };
+    });
+
+    return { totalRatings, averageScore, distribution, sessions: sessionData };
+  }
+
+  async getReports(userId: number, enterpriseId?: number, dateFrom?: string, dateTo?: string) {
+    const instructor = await this.prisma.instructor.findFirst({
+      where: { person: { person_user: { some: { user_id: userId } } } },
+      select: { id: true },
+    });
+    if (!instructor) throw new NotFoundException('No instructor profile found for this user');
+
+    const now = new Date();
+
+    // Date range for period filtering
+    const startDate = dateFrom ? new Date(dateFrom) : new Date(now.getFullYear(), 0, 1);
+    const endDate = dateTo ? new Date(dateTo + 'T23:59:59.999Z') : new Date(now.getFullYear(), 11, 31, 23, 59, 59);
+    const sessionDateFilter = { gte: startDate, lte: endDate };
+
+    // Treat enterpriseId=0 as "no filter" (frontend may send 0 when no enterprise is selected)
+    const effectiveEnterpriseId = enterpriseId && enterpriseId > 0 ? enterpriseId : undefined;
+
+    const enterpriseFilter = effectiveEnterpriseId !== undefined
+      ? { enterprise_class_group: { some: { enterprise_id: effectiveEnterpriseId } } }
+      : {};
+
+    // ── 1. Collect all class groups taught by this instructor ──────────────────
+    const sessionRows = await this.prisma.course_class_session.findMany({
+      where: {
+        course_class_session_instructor: { some: { instructor_id: instructor.id } },
+        session_date: sessionDateFilter,
+        ...(effectiveEnterpriseId !== undefined ? { course_class_group: enterpriseFilter } : {}),
+      },
+      select: { course_class_group_id: true },
+      distinct: ['course_class_group_id'],
+    });
+    const cgIds = sessionRows
+      .map((r) => r.course_class_group_id)
+      .filter((id): id is number => id != null);
+
+    const CLASS_COLORS = ['#F97316', '#6366F1', '#10B981', '#0EA5E9', '#8B5CF6', '#F43F5E'];
+
+    if (cgIds.length === 0) {
+      return {
+        kpis: { totalStudents: 0, averageEvaluationScore: 0, averageAttendance: 0, sessionsCompleted: 0 },
+        classes: [],
+        topicNames: [],
+        evaluationsBySession: [],
+        attendanceBySession: [],
+        studentGrades: [],
+      };
+    }
+
+    const classGroupRows = await this.prisma.course_class_group.findMany({
+      where: { id: { in: cgIds } },
+      orderBy: { start_date: 'asc' },
+      select: { id: true, title: true },
+      take: 6,
+    });
+    const cgIdsCapped = classGroupRows.map((cg) => cg.id);
+    const classes = classGroupRows.map((cg, i) => ({
+      key: `t${i + 1}` as string,
+      name: cg.title,
+      color: CLASS_COLORS[i] ?? '#94A3B8',
+    }));
+    const classKeyById = new Map(classGroupRows.map((cg, i) => [cg.id, `t${i + 1}`]));
+    const classNameById = new Map(classGroupRows.map((cg) => [cg.id, cg.title]));
+
+    // ── 2. Parallel data fetches ───────────────────────────────────────────────
+    const [allSessions, evalTopics, attendanceRows, enrollmentRows, completedSessionCount] =
+      await Promise.all([
+        // All sessions for these class groups within the date range
+        this.prisma.course_class_session.findMany({
+          where: { course_class_group_id: { in: cgIdsCapped }, session_date: sessionDateFilter },
+          select: {
+            id: true,
+            title: true,
+            session_date: true,
+            course_class_group_id: true,
+          },
+          orderBy: { session_date: 'asc' },
+        }),
+        // Evaluation topics+ratings for sessions taught by this instructor within the date range
+        this.prisma.evaluation_topic.findMany({
+          where: {
+            target_type: 'course_class_session',
+            is_active: true,
+            course_class_session: {
+              course_class_group_id: { in: cgIdsCapped },
+              session_date: sessionDateFilter,
+            },
+          },
+          select: {
+            id: true,
+            name: true,
+            course_class_session_id: true,
+            evaluation_rating: { select: { score: true } },
+          },
+        }),
+        // Attendance records for sessions in the date range
+        this.prisma.course_class_attendance.findMany({
+          where: {
+            course_class_session: {
+              course_class_group_id: { in: cgIdsCapped },
+              session_date: { gte: startDate, lt: now < endDate ? now : endDate },
+            },
+          },
+          select: {
+            course_class_session_id: true,
+            student_id: true,
+            present: true,
+          },
+        }),
+        // Enrollment final scores (notas de prova)
+        this.prisma.course_enrollment.findMany({
+          where: {
+            course_class_group_id: { in: cgIdsCapped },
+            final_score: { not: null },
+            status: { not: 'cancelled' },
+          },
+          select: {
+            course_class_group_id: true,
+            final_score: true,
+            person: { select: { name: true } },
+          },
+          orderBy: { final_score: 'desc' },
+        }),
+        // Completed sessions count within the date range
+        this.prisma.course_class_session.count({
+          where: {
+            course_class_group_id: { in: cgIdsCapped },
+            session_date: { gte: startDate, lt: now < endDate ? now : endDate },
+          },
+        }),
+      ]);
+
+    // ── 3. KPIs ────────────────────────────────────────────────────────────────
+    const totalStudents = await this.prisma.course_enrollment.count({
+      where: {
+        course_class_group_id: { in: cgIdsCapped },
+        status: { not: 'cancelled' },
+      },
+    });
+
+    // Average evaluation score: compute from already-filtered evalTopics
+    const allEvalScores: number[] = [];
+    for (const topic of evalTopics) {
+      for (const r of topic.evaluation_rating) allEvalScores.push(Number(r.score));
+    }
+    const averageEvaluationScore =
+      allEvalScores.length > 0
+        ? this.round(allEvalScores.reduce((a, b) => a + b, 0) / allEvalScores.length, 2)
+        : 0;
+
+    // Average attendance: per session, count present / total records
+    const pastSessions = allSessions.filter((s) => s.session_date < now);
+    let attendanceSum = 0;
+    let attendanceDenom = 0;
+    for (const sess of pastSessions) {
+      const records = attendanceRows.filter((r) => r.course_class_session_id === sess.id);
+      if (records.length > 0) {
+        attendanceSum += records.filter((r) => r.present).length;
+        attendanceDenom += records.length;
+      }
+    }
+    const averageAttendance =
+      attendanceDenom > 0 ? this.round((attendanceSum / attendanceDenom) * 100, 0) : 0;
+
+    // ── 4. Evaluations by session ──────────────────────────────────────────────
+    // Build session → { topics: Map<name, scores[]> }
+    type SessEvalAgg = { topics: Map<string, number[]> };
+    const sessEvalMap = new Map<number, SessEvalAgg>();
+    for (const s of allSessions) sessEvalMap.set(s.id, { topics: new Map() });
+
+    // Collect all unique topic names
+    const allTopicNames = new Set<string>();
+    for (const topic of evalTopics) {
+      if (topic.course_class_session_id == null) continue;
+      allTopicNames.add(topic.name);
+      const agg = sessEvalMap.get(topic.course_class_session_id);
+      if (!agg) continue;
+      if (!agg.topics.has(topic.name)) agg.topics.set(topic.name, []);
+      for (const r of topic.evaluation_rating) {
+        agg.topics.get(topic.name)!.push(Number(r.score));
+      }
+    }
+    const topicNames = Array.from(allTopicNames).sort();
+
+    const evaluationsBySession = allSessions
+      .filter((s) => {
+        const agg = sessEvalMap.get(s.id);
+        return agg && [...agg.topics.values()].some((scores) => scores.length > 0);
+      })
+      .map((s) => {
+        const agg = sessEvalMap.get(s.id)!;
+        const topicsObj: Record<string, number | null> = {};
+        let totalScore = 0;
+        let totalCount = 0;
+        for (const tName of topicNames) {
+          const scores = agg.topics.get(tName) ?? [];
+          if (scores.length > 0) {
+            const avg = this.round(scores.reduce((a, b) => a + b, 0) / scores.length, 2);
+            topicsObj[tName] = avg;
+            totalScore += avg;
+            totalCount++;
+          } else {
+            topicsObj[tName] = null;
+          }
+        }
+        const media = totalCount > 0 ? this.round(totalScore / totalCount, 2) : 0;
+        const classKey = classKeyById.get(s.course_class_group_id ?? -1) ?? null;
+        const className = classNameById.get(s.course_class_group_id ?? -1) ?? null;
+        // Short label: first 20 chars of title
+        const label = s.title.length > 20 ? `${s.title.slice(0, 18)}…` : s.title;
+        return {
+          sessionId: s.id,
+          label,
+          date: s.session_date,
+          classKey,
+          className,
+          topics: topicsObj,
+          media,
+          hi: Math.min(5, this.round(media + 0.5, 2)),
+          lo: Math.max(0, this.round(media - 0.5, 2)),
+        };
+      });
+
+    // ── 5. Attendance by session ───────────────────────────────────────────────
+    const attendanceBySession = pastSessions
+      .filter((s) => attendanceRows.some((r) => r.course_class_session_id === s.id))
+      .map((s) => {
+        const records = attendanceRows.filter((r) => r.course_class_session_id === s.id);
+        const presentCount = records.filter((r) => r.present).length;
+        const classKey = classKeyById.get(s.course_class_group_id ?? -1) ?? null;
+        const className = classNameById.get(s.course_class_group_id ?? -1) ?? null;
+        const label = s.title.length > 12 ? `${s.title.slice(0, 10)}…` : s.title;
+        return {
+          sessionId: s.id,
+          label,
+          date: s.session_date,
+          classKey,
+          className,
+          presentCount,
+        };
+      });
+
+    // ── 6. Student grades ──────────────────────────────────────────────────────
+    const studentGrades = enrollmentRows
+      .filter((e) => e.final_score != null)
+      .map((e) => ({
+        name: e.person?.name ?? 'Aluno',
+        grade: Number(e.final_score),
+        classKey: classKeyById.get(e.course_class_group_id ?? -1) ?? null,
+        className: classNameById.get(e.course_class_group_id ?? -1) ?? null,
+      }))
+      .sort((a, b) => b.grade - a.grade);
+
+    return {
+      kpis: {
+        totalStudents,
+        averageEvaluationScore,
+        averageAttendance,
+        sessionsCompleted: completedSessionCount,
+      },
+      classes,
+      topicNames,
+      evaluationsBySession,
+      attendanceBySession,
+      studentGrades,
+    };
+  }
+
+  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;
+  }
+
+  async submitSessionAttendance(
+    userId: number,
+    classGroupId: number,
+    sessionId: number,
+    records: { studentId: number; present: boolean }[],
+  ) {
+    await this.assertInstructorOwnsClass(userId, classGroupId);
+
+    const session = await this.prisma.course_class_session.findFirst({
+      where: { id: sessionId, course_class_group_id: classGroupId },
+      select: { id: true },
+    });
+    if (!session) throw new NotFoundException('Session not found in this class group');
+
+    await this.prisma.$transaction([
+      this.prisma.course_class_attendance.deleteMany({
+        where: { course_class_session_id: sessionId },
+      }),
+      this.prisma.course_class_attendance.createMany({
+        data: records.map((r) => ({
+          course_class_session_id: sessionId,
+          student_id: r.studentId,
+          present: r.present,
+        })),
+      }),
+    ]);
+
+    return { success: true, count: records.length };
+  }
+
+  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;
+  }
+}