@hed-hog/lms 0.0.303 → 0.0.305

package/src/dashboard/dashboard.service.ts

@@ -0,0 +1,726 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { Injectable } from '@nestjs/common';
+
+const DASHBOARD_COLORS = [
+  '#f97316',
+  '#3b82f6',
+  '#22c55e',
+  '#a855f7',
+  '#ec4899',
+  '#14b8a6',
+];
+
+@Injectable()
+export class LmsDashboardService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async getDashboard(locale?: string) {
+    const localeCode = this.normalizeLocale(locale);
+    const now = new Date();
+    const calendarStart = this.startOfDay(this.addDays(now, -14));
+    const calendarEnd = this.endOfDay(this.addDays(now, 30));
+
+    const [
+      kpis,
+      studentGrowth,
+      engagement,
+      topCourses,
+      categoryDistribution,
+      calendarEvents,
+      latestEnrollments,
+      upcomingClasses,
+    ] = await Promise.all([
+      this.getKpis(now),
+      this.getStudentGrowth(localeCode, now),
+      this.getEngagement(localeCode, now),
+      this.getTopCourses(),
+      this.getCategoryDistribution(localeCode),
+      this.getCalendarEvents(calendarStart, calendarEnd),
+      this.getLatestEnrollments(),
+      this.getUpcomingClasses(now),
+    ]);
+
+    return {
+      kpis,
+      charts: {
+        studentGrowth,
+        engagement,
+        topCourses,
+        categoryDistribution,
+      },
+      calendarEvents,
+      latestEnrollments,
+      upcomingClasses,
+      footerSummary: {
+        activeClasses: kpis.activeClasses.value,
+        publishedCourses: kpis.activeCourses.value,
+        enrolledStudents: kpis.totalStudents.value,
+        certificates: kpis.issuedCertificates.value,
+      },
+    };
+  }
+
+  private async getKpis(now: Date) {
+    const currentMonthStart = this.startOfMonth(now);
+    const previousMonthStart = this.startOfMonth(this.addMonths(now, -1));
+    const previousMonthEnd = this.endOfMonth(this.addMonths(now, -1));
+
+    const [
+      totalStudents,
+      previousTotalStudents,
+      activeCourses,
+      previousActiveCourses,
+      activeClasses,
+      previousActiveClasses,
+      issuedCertificates,
+      previousIssuedCertificates,
+      overallCompletion,
+      currentCompletion,
+      previousCompletion,
+      overallAttempts,
+      currentAttempts,
+      previousAttempts,
+    ] = await Promise.all([
+      this.prisma.course_enrollment.count(),
+      this.prisma.course_enrollment.count({
+        where: { enrolled_at: { lt: currentMonthStart } },
+      }),
+      this.prisma.course.count({ where: { status: 'published' } }),
+      this.prisma.course.count({
+        where: {
+          status: 'published',
+          created_at: { lt: currentMonthStart },
+        },
+      }),
+      this.prisma.course_class_group.count({ where: { status: 'ongoing' } }),
+      this.prisma.course_class_group.count({
+        where: {
+          status: 'ongoing',
+          created_at: { lt: currentMonthStart },
+        },
+      }),
+      this.prisma.certificate.count(),
+      this.prisma.certificate.count({
+        where: { issued_at: { lt: currentMonthStart } },
+      }),
+      this.prisma.course_enrollment.aggregate({
+        where: { status: { in: ['active', 'completed'] } },
+        _avg: { progress_percent: true },
+      }),
+      this.prisma.course_enrollment.aggregate({
+        where: {
+          status: { in: ['active', 'completed'] },
+          updated_at: { gte: currentMonthStart },
+        },
+        _avg: { progress_percent: true },
+      }),
+      this.prisma.course_enrollment.aggregate({
+        where: {
+          status: { in: ['active', 'completed'] },
+          updated_at: {
+            gte: previousMonthStart,
+            lte: previousMonthEnd,
+          },
+        },
+        _avg: { progress_percent: true },
+      }),
+      this.prisma.exam_attempt.findMany({
+        where: {
+          status: 'completed',
+          score: { not: null },
+        },
+        select: {
+          score: true,
+          exam: { select: { min_score: true } },
+        },
+      }),
+      this.prisma.exam_attempt.findMany({
+        where: {
+          status: 'completed',
+          score: { not: null },
+          finished_at: { gte: currentMonthStart },
+        },
+        select: {
+          score: true,
+          exam: { select: { min_score: true } },
+        },
+      }),
+      this.prisma.exam_attempt.findMany({
+        where: {
+          status: 'completed',
+          score: { not: null },
+          finished_at: {
+            gte: previousMonthStart,
+            lte: previousMonthEnd,
+          },
+        },
+        select: {
+          score: true,
+          exam: { select: { min_score: true } },
+        },
+      }),
+    ]);
+
+    const overallApproval = this.calculateApprovalRate(overallAttempts);
+    const currentApproval = this.calculateApprovalRate(currentAttempts);
+    const previousApproval = this.calculateApprovalRate(previousAttempts);
+
+    return {
+      totalStudents: {
+        value: totalStudents,
+        change: this.percentChange(totalStudents, previousTotalStudents),
+        changeType: 'percent',
+      },
+      activeCourses: {
+        value: activeCourses,
+        change: activeCourses - previousActiveCourses,
+        changeType: 'absolute',
+      },
+      activeClasses: {
+        value: activeClasses,
+        change: activeClasses - previousActiveClasses,
+        changeType: 'absolute',
+      },
+      issuedCertificates: {
+        value: issuedCertificates,
+        change: issuedCertificates - previousIssuedCertificates,
+        changeType: 'absolute',
+      },
+      completionRate: {
+        value: Math.round(overallCompletion._avg.progress_percent ?? 0),
+        change: this.round((currentCompletion._avg.progress_percent ?? 0) - (previousCompletion._avg.progress_percent ?? 0), 1),
+        changeType: 'percent',
+      },
+      approvalRate: {
+        value: overallApproval,
+        change: this.round(currentApproval - previousApproval, 1),
+        changeType: 'percent',
+      },
+    };
+  }
+
+  private async getStudentGrowth(locale: string, now: Date) {
+    const formatter = new Intl.DateTimeFormat(locale, { month: 'short' });
+    const months = Array.from({ length: 7 }, (_, index) => {
+      const date = this.addMonths(now, index - 6);
+      return this.startOfMonth(date);
+    });
+
+    const counts = await Promise.all(
+      months.map((monthStart) =>
+        this.prisma.course_enrollment.count({
+          where: {
+            enrolled_at: { lte: this.endOfMonth(monthStart) },
+          },
+        }),
+      ),
+    );
+
+    return months.map((monthStart, index) => ({
+      label: this.capitalize(formatter.format(monthStart).replace('.', '')),
+      students: counts[index],
+    }));
+  }
+
+  private async getEngagement(locale: string, now: Date) {
+    const windowStart = this.startOfWeek(this.addDays(now, -7 * 7));
+    const [lessonProgress, examAttempts] = await Promise.all([
+      this.prisma.course_lesson_progress.findMany({
+        where: { updated_at: { gte: windowStart } },
+        select: {
+          updated_at: true,
+          course_lesson: { select: { type: true } },
+        },
+      }),
+      this.prisma.exam_attempt.findMany({
+        where: { started_at: { gte: windowStart } },
+        select: { started_at: true },
+      }),
+    ]);
+
+    const prefix = locale.startsWith('pt') ? 'S' : 'W';
+    const buckets = Array.from({ length: 8 }, (_, index) => {
+      const weekStart = this.startOfWeek(this.addDays(windowStart, index * 7));
+      const weekEnd = this.endOfDay(this.addDays(weekStart, 6));
+
+      const accessCount = lessonProgress.filter(
+        (item) => item.updated_at >= weekStart && item.updated_at <= weekEnd,
+      ).length;
+      const videoCount = lessonProgress.filter(
+        (item) =>
+          item.updated_at >= weekStart &&
+          item.updated_at <= weekEnd &&
+          item.course_lesson?.type === 'video',
+      ).length;
+      const exerciseCount = examAttempts.filter(
+        (item) => item.started_at >= weekStart && item.started_at <= weekEnd,
+      ).length;
+
+      return {
+        label: `${prefix}${index + 1}`,
+        accesses: accessCount,
+        videos: videoCount,
+        exercises: exerciseCount,
+      };
+    });
+
+    return buckets;
+  }
+
+  private async getTopCourses(limit = 6) {
+    const since = this.addDays(new Date(), -90);
+    const rows = await this.prisma.course_lesson_progress.findMany({
+      where: { updated_at: { gte: since } },
+      select: {
+        course_lesson: {
+          select: {
+            course_module: {
+              select: {
+                course: {
+                  select: {
+                    id: true,
+                    title: true,
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    });
+
+    const counts = new Map<number, { title: string; accesses: number }>();
+
+    for (const row of rows) {
+      const course = row.course_lesson?.course_module?.course;
+      if (!course) {
+        continue;
+      }
+
+      const current = counts.get(course.id) ?? { title: course.title, accesses: 0 };
+      current.accesses += 1;
+      counts.set(course.id, current);
+    }
+
+    if (counts.size === 0) {
+      const grouped = await this.prisma.course_enrollment.groupBy({
+        by: ['course_id'],
+        _count: { course_id: true },
+        orderBy: { _count: { course_id: 'desc' } },
+        take: limit,
+      });
+      const courses = await this.prisma.course.findMany({
+        where: { id: { in: grouped.map((item) => item.course_id) } },
+        select: { id: true, title: true },
+      });
+      const titleById = new Map(courses.map((item) => [item.id, item.title]));
+
+      return grouped.map((item) => ({
+        title: titleById.get(item.course_id) ?? `#${item.course_id}`,
+        accesses: item._count.course_id,
+      }));
+    }
+
+    return Array.from(counts.values())
+      .sort((left, right) => right.accesses - left.accesses)
+      .slice(0, limit);
+  }
+
+  private async getCategoryDistribution(locale: string) {
+    const rows = await this.prisma.course_category.findMany({
+      where: { course: { status: 'published' } },
+      select: {
+        course_id: true,
+        category: {
+          select: {
+            slug: true,
+            category_locale: {
+              where: { locale: { code: locale.slice(0, 2) as 'en' | 'pt' } },
+              take: 1,
+              select: { name: true },
+            },
+          },
+        },
+      },
+    });
+
+    const courseIds = new Set(rows.map((item) => item.course_id));
+    const counts = new Map<string, { name: string; count: number }>();
+
+    for (const row of rows) {
+      const key = row.category?.slug ?? 'uncategorized';
+      const current =
+        counts.get(key) ?? {
+          name: row.category?.category_locale?.[0]?.name ?? row.category?.slug ?? key,
+          count: 0,
+        };
+      current.count += 1;
+      counts.set(key, current);
+    }
+
+    const total = Math.max(courseIds.size, 1);
+
+    return Array.from(counts.values())
+      .map((item) => ({
+        name: item.name,
+        value: this.round((item.count / total) * 100, 0),
+      }))
+      .sort((left, right) => right.value - left.value)
+      .slice(0, 6);
+  }
+
+  private async getCalendarEvents(start: Date, end: Date) {
+    const sessions = await this.prisma.course_class_session.findMany({
+      where: {
+        session_date: {
+          gte: start,
+          lte: end,
+        },
+      },
+      orderBy: [{ session_date: 'asc' }, { start_time: 'asc' }],
+      include: {
+        course_class_group: {
+          select: {
+            id: true,
+            title: true,
+            delivery_mode: true,
+            status: true,
+            capacity: true,
+            location: true,
+            virtual_room_url: true,
+            course: {
+              select: {
+                id: true,
+                title: true,
+                primary_color: true,
+              },
+            },
+            _count: {
+              select: {
+                course_enrollment: true,
+              },
+            },
+          },
+        },
+        course_class_session_instructor: {
+          select: {
+            role: true,
+            instructor: {
+              select: {
+                person: {
+                  select: {
+                    name: true,
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    });
+
+    return sessions.map((session) => {
+      const classGroup = session.course_class_group;
+      const course = classGroup?.course;
+      const instructors = this.formatInstructorNames(
+        session.course_class_session_instructor,
+      );
+      const color =
+        course?.primary_color ??
+        DASHBOARD_COLORS[(course?.id ?? session.id) % DASHBOARD_COLORS.length];
+      const startDate = this.combineDateAndTime(
+        session.session_date,
+        session.start_time,
+      );
+      const endDate = this.combineDateAndTime(session.session_date, session.end_time);
+
+      return {
+        id: session.id,
+        title: session.title ?? classGroup?.title,
+        start: this.formatLocalISOString(startDate),
+        end: this.formatLocalISOString(endDate),
+        resource: {
+          id: String(classGroup?.id ?? session.id),
+          cor: color,
+          curso: course?.title ?? '',
+          professor: instructors,
+          tipo: this.normalizeDeliveryMode(classGroup?.delivery_mode),
+          local:
+            session.meeting_url ??
+            session.location ??
+            classGroup?.virtual_room_url ??
+            classGroup?.location ??
+            '',
+          vagas: classGroup?.capacity ?? 0,
+          matriculados: classGroup?._count?.course_enrollment ?? 0,
+          status: this.normalizeClassStatus(classGroup?.status),
+          turmaName: classGroup?.title ?? session.title,
+        },
+      };
+    });
+  }
+
+  private async getLatestEnrollments(limit = 12) {
+    const enrollments = await this.prisma.course_enrollment.findMany({
+      take: limit,
+      orderBy: { enrolled_at: 'desc' },
+      include: {
+        course: {
+          select: {
+            title: true,
+          },
+        },
+        person: {
+          select: {
+            name: true,
+            contact: {
+              orderBy: { is_primary: 'desc' },
+              select: {
+                value: true,
+                is_primary: true,
+              },
+            },
+          },
+        },
+      },
+    });
+
+    return enrollments.map((enrollment) => ({
+      id: enrollment.id,
+      studentName: enrollment.person?.name ?? '',
+      email: this.extractEmail(enrollment.person?.contact ?? []),
+      courseTitle: enrollment.course?.title ?? '',
+      enrolledAt: enrollment.enrolled_at.toISOString(),
+      status: this.normalizeEnrollmentStatus(enrollment.status),
+    }));
+  }
+
+  private async getUpcomingClasses(now: Date, limit = 10) {
+    const sessions = await this.prisma.course_class_session.findMany({
+      take: limit,
+      where: {
+        session_date: { gte: this.startOfDay(now) },
+        status: { not: 'cancelled' },
+      },
+      orderBy: [{ session_date: 'asc' }, { start_time: 'asc' }],
+      include: {
+        course_class_group: {
+          select: {
+            id: true,
+            title: true,
+          },
+        },
+        course_class_session_instructor: {
+          select: {
+            role: true,
+            instructor: {
+              select: {
+                person: {
+                  select: {
+                    name: true,
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    });
+
+    return sessions.map((session) => ({
+      id: session.id,
+      className: session.course_class_group?.title ?? session.title,
+      subject: session.title,
+      teacher: this.formatInstructorNames(session.course_class_session_instructor),
+      date: this.formatLocalISOString(this.combineDateAndTime(session.session_date, null)),
+      startTime: session.start_time,
+      endTime: session.end_time,
+    }));
+  }
+
+  private calculateApprovalRate(
+    attempts: Array<{ score: number | null; exam: { min_score: number | null } }>,
+  ) {
+    if (attempts.length === 0) {
+      return 0;
+    }
+
+    const approved = attempts.filter(
+      (attempt) => (attempt.score ?? 0) >= (attempt.exam?.min_score ?? 0),
+    ).length;
+
+    return this.round((approved / attempts.length) * 100, 1);
+  }
+
+  private normalizeLocale(locale?: string) {
+    if (!locale) {
+      return 'pt-BR';
+    }
+
+    return locale.toLowerCase().startsWith('en') ? 'en-US' : 'pt-BR';
+  }
+
+  private normalizeDeliveryMode(value?: string | null) {
+    if (value === 'presential') {
+      return 'inPerson';
+    }
+
+    if (value === 'hybrid') {
+      return 'hybrid';
+    }
+
+    return 'online';
+  }
+
+  private normalizeClassStatus(value?: string | null) {
+    if (value === 'ongoing') {
+      return 'inProgress';
+    }
+
+    if (value === 'completed') {
+      return 'completed';
+    }
+
+    if (value === 'cancelled') {
+      return 'cancelled';
+    }
+
+    return 'open';
+  }
+
+  private normalizeEnrollmentStatus(value?: string | null) {
+    if (value === 'pending') {
+      return 'pending';
+    }
+
+    if (value === 'completed') {
+      return 'completed';
+    }
+
+    if (value === 'cancelled') {
+      return 'cancelled';
+    }
+
+    if (value === 'paused') {
+      return 'paused';
+    }
+
+    return 'active';
+  }
+
+  private extractEmail(contacts: Array<{ value: string; is_primary: boolean }>) {
+    const sorted = [...contacts].sort(
+      (left, right) => Number(right.is_primary) - Number(left.is_primary),
+    );
+
+    return (
+      sorted.find((contact) => contact.value.includes('@'))?.value ??
+      sorted[0]?.value ??
+      ''
+    );
+  }
+
+  private formatInstructorNames(
+    instructors: Array<{
+      role?: string;
+      instructor?: { person?: { name?: string | null } | null } | null;
+    }>,
+  ) {
+    const names = instructors
+      .sort((left, right) => {
+        if (left.role === 'lead') return -1;
+        if (right.role === 'lead') return 1;
+        return 0;
+      })
+      .map((item) => item.instructor?.person?.name)
+      .filter((value): value is string => Boolean(value));
+
+    return names.length > 0 ? names.join(', ') : '-';
+  }
+
+  private percentChange(current: number, previous: number) {
+    if (previous <= 0) {
+      return current > 0 ? 100 : 0;
+    }
+
+    return this.round(((current - previous) / previous) * 100, 1);
+  }
+
+  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 addMonths(date: Date, months: number) {
+    const result = new Date(date);
+    result.setMonth(result.getMonth() + months);
+    return result;
+  }
+
+  private startOfDay(date: Date) {
+    const result = new Date(date);
+    result.setHours(0, 0, 0, 0);
+    return result;
+  }
+
+  private endOfDay(date: Date) {
+    const result = new Date(date);
+    result.setHours(23, 59, 59, 999);
+    return result;
+  }
+
+  private startOfMonth(date: Date) {
+    return new Date(date.getFullYear(), date.getMonth(), 1, 0, 0, 0, 0);
+  }
+
+  private endOfMonth(date: Date) {
+    return new Date(date.getFullYear(), date.getMonth() + 1, 0, 23, 59, 59, 999);
+  }
+
+  private startOfWeek(date: Date) {
+    const result = this.startOfDay(date);
+    const currentDay = result.getDay();
+    const diff = currentDay === 0 ? -6 : 1 - currentDay;
+    result.setDate(result.getDate() + diff);
+    return result;
+  }
+
+  private combineDateAndTime(date: Date, time?: string | null) {
+    // Prisma returns date-only fields as UTC midnight; extract parts via UTC
+    // methods so the calendar date is never shifted by the server timezone.
+    const year = date.getUTCFullYear();
+    const month = date.getUTCMonth();
+    const day = date.getUTCDate();
+
+    let hours = 0;
+    let minutes = 0;
+
+    if (time) {
+      const parts = time.split(':');
+      hours = Number(parts[0]) || 0;
+      minutes = Number(parts[1]) || 0;
+    }
+
+    return new Date(year, month, day, hours, minutes, 0, 0);
+  }
+
+  /** Serialise a Date as a local ISO string with no timezone suffix so the
+   *  browser treats it as local time instead of converting from UTC. */
+  private formatLocalISOString(date: Date): string {
+    const pad = (n: number) => String(n).padStart(2, '0');
+    return (
+      `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}` +
+      `T${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`
+    );
+  }
+
+  private capitalize(value: string) {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+  }
+}