@hed-hog/lms 0.0.365 → 0.0.366

package/src/platforma/platforma-performance.service.ts

@@ -0,0 +1,606 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { Injectable } from '@nestjs/common';
+
+const CATEGORY_COLORS = [
+  '#8B5CF6',
+  '#22C55E',
+  '#3B82F6',
+  '#F59E0B',
+  '#EC4899',
+  '#14B8A6',
+];
+
+const TRAIL_COLORS = [
+  '#8B5CF6',
+  '#34D399',
+  '#F59E0B',
+  '#60A5FA',
+  '#FB7185',
+  '#A78BFA',
+];
+
+const PT_MONTHS: Record<string, string> = {
+  Jan: 'Jan',
+  Feb: 'Fev',
+  Mar: 'Mar',
+  Apr: 'Abr',
+  May: 'Mai',
+  Jun: 'Jun',
+  Jul: 'Jul',
+  Aug: 'Ago',
+  Sep: 'Set',
+  Oct: 'Out',
+  Nov: 'Nov',
+  Dec: 'Dez',
+};
+
+function slugToTitle(slug: string): string {
+  return slug
+    .split('-')
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+    .join(' ');
+}
+
+function toPtMonth(enAbbr: string): string {
+  return PT_MONTHS[enAbbr] ?? enAbbr;
+}
+
+function parsePeriod(period: string): {
+  start: Date;
+  previousStart: Date;
+  previousEnd: Date;
+} {
+  const now = new Date();
+  const start = new Date(now);
+
+  if (period === '3m') {
+    start.setMonth(start.getMonth() - 3);
+  } else if (period === 'year') {
+    start.setMonth(0, 1);
+    start.setHours(0, 0, 0, 0);
+  } else {
+    // default: 30d
+    start.setDate(start.getDate() - 30);
+  }
+
+  const periodMs = now.getTime() - start.getTime();
+  const previousEnd = new Date(start);
+  const previousStart = new Date(start.getTime() - periodMs);
+
+  return { start, previousStart, previousEnd };
+}
+
+function formatHms(totalSeconds: number): string {
+  const h = Math.floor(totalSeconds / 3600);
+  const m = Math.floor((totalSeconds % 3600) / 60);
+  if (h > 0) return `${h}h ${m}m`;
+  return `${m}m`;
+}
+
+function calcChange(current: number, previous: number): number {
+  if (previous === 0) return current > 0 ? 100 : 0;
+  return Math.round(((current - previous) / previous) * 100);
+}
+
+@Injectable()
+export class PlatformaPerformanceService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async getSummary(userId: number, period: string) {
+    const { start, previousStart, previousEnd } = parsePeriod(period);
+
+    const personId = await this.getPersonId(userId);
+
+    const [kpis, studyHours, areaPerformance, accuracy, lessonsByCategory, avgLessonTime, trailProgress, ranking] =
+      await Promise.all([
+        this.getKpis(userId, personId, start, previousStart, previousEnd),
+        this.getStudyHoursChart(personId),
+        this.getAreaPerformance(personId),
+        this.getAccuracyDistribution(personId, start),
+        this.getLessonsByCategory(personId, start),
+        this.getAvgLessonTime(personId),
+        this.getTrailProgress(personId),
+        this.getRanking(),
+      ]);
+
+    return {
+      kpis,
+      studyHours,
+      areaPerformance,
+      accuracyDistribution: accuracy,
+      lessonsByCategory,
+      avgLessonTime,
+      trailProgress,
+      ranking,
+    };
+  }
+
+  // ---------------------------------------------------------------------------
+  // KPI cards
+  // ---------------------------------------------------------------------------
+
+  private async getKpis(
+    userId: number,
+    personId: number | null,
+    start: Date,
+    previousStart: Date,
+    previousEnd: Date,
+  ) {
+    const [
+      studyTimeCurrent,
+      studyTimePrev,
+      lessonsCurrent,
+      lessonsPrev,
+      exercisesCurrent,
+      exercisesPrev,
+      accuracyCurrent,
+      accuracyPrev,
+      bitcodes,
+      bitcodesEarnedCurrent,
+      bitcodesEarnedPrev,
+      studySparkline,
+      lessonsSparkline,
+      exercisesSparkline,
+      bitcodesSparkline,
+    ] = await Promise.all([
+      this.countStudySeconds(userId, start, new Date()),
+      this.countStudySeconds(userId, previousStart, previousEnd),
+      this.countCompletedLessons(personId, start, new Date()),
+      this.countCompletedLessons(personId, previousStart, previousEnd),
+      this.countResolvedExercises(personId, start, new Date()),
+      this.countResolvedExercises(personId, previousStart, previousEnd),
+      this.getAccuracyRate(personId, start, new Date()),
+      this.getAccuracyRate(personId, previousStart, previousEnd),
+      this.getBitcodesBalance(personId),
+      this.getBitcodesEarned(personId, start, new Date()),
+      this.getBitcodesEarned(personId, previousStart, previousEnd),
+      this.getWeeklySparkline((w) => this.countStudySeconds(userId, w.start, w.end), 10),
+      this.getWeeklySparkline((w) => this.countCompletedLessons(personId, w.start, w.end), 10),
+      this.getWeeklySparkline((w) => this.countResolvedExercises(personId, w.start, w.end), 10),
+      this.getWeeklySparkline((w) => this.getBitcodesEarned(personId, w.start, w.end), 10),
+    ]);
+
+    const accuracyChange = calcChange(accuracyCurrent, accuracyPrev);
+
+    return [
+      {
+        id: 'study-time',
+        title: 'Tempo de estudo',
+        value: formatHms(studyTimeCurrent),
+        subtitle: 'Horas totais',
+        change: this.fmtChange(calcChange(studyTimeCurrent, studyTimePrev)),
+        icon: 'clock' as const,
+        color: '#8B5CF6',
+        sparkline: studySparkline,
+      },
+      {
+        id: 'completed-lessons',
+        title: 'Aulas concluídas',
+        value: String(lessonsCurrent),
+        subtitle: 'Total de aulas',
+        change: this.fmtChange(calcChange(lessonsCurrent, lessonsPrev)),
+        icon: 'bookOpen' as const,
+        color: '#22C55E',
+        sparkline: lessonsSparkline,
+      },
+      {
+        id: 'resolved-exercises',
+        title: 'Exercícios resolvidos',
+        value: String(exercisesCurrent),
+        subtitle: 'Total de exercícios',
+        change: this.fmtChange(calcChange(exercisesCurrent, exercisesPrev)),
+        icon: 'pencil' as const,
+        color: '#FB923C',
+        sparkline: exercisesSparkline,
+      },
+      {
+        id: 'accuracy-rate',
+        title: 'Taxa de acerto',
+        value: `${accuracyCurrent}%`,
+        subtitle: 'Média de acertos',
+        change: this.fmtChange(accuracyChange),
+        icon: 'target' as const,
+        color: '#3B82F6',
+        sparkline: await this.getWeeklySparkline(
+          (w) => this.getAccuracyRate(personId, w.start, w.end),
+          10,
+        ),
+      },
+      {
+        id: 'bitcodes',
+        title: 'Bitcodes',
+        value: bitcodes.toLocaleString('pt-BR'),
+        subtitle: 'Saldo atual',
+        change: this.fmtBitcodesChange(bitcodesEarnedCurrent, bitcodesEarnedPrev),
+        icon: 'coins' as const,
+        color: '#F59E0B',
+        sparkline: bitcodesSparkline,
+      },
+    ];
+  }
+
+  private fmtChange(pct: number): string {
+    const sign = pct >= 0 ? '+' : '';
+    return `${sign}${pct}% vs. mês passado`;
+  }
+
+  private fmtBitcodesChange(current: number, previous: number): string {
+    const diff = current - previous;
+    const sign = diff >= 0 ? '+' : '';
+    return `${sign}${diff.toLocaleString('pt-BR')} vs. mês passado`;
+  }
+
+  private async countStudySeconds(userId: number, start: Date, end: Date): Promise<number> {
+    const rows = await (this.prisma as any).$queryRaw<[{ total: bigint }]>`
+      SELECT COUNT(*) * 15 AS total
+      FROM lesson_view_event
+      WHERE user_id = ${userId}
+        AND created_at >= ${start}
+        AND created_at < ${end}
+    `;
+    return Number(rows[0]?.total ?? 0);
+  }
+
+  private async countCompletedLessons(
+    personId: number | null,
+    start: Date,
+    end: Date,
+  ): Promise<number> {
+    if (!personId) return 0;
+    const rows = await (this.prisma as any).$queryRaw<[{ total: bigint }]>`
+      SELECT COUNT(*) AS total
+      FROM course_lesson_progress clp
+      JOIN course_enrollment ce ON ce.id = clp.course_enrollment_id
+      WHERE ce.person_id = ${personId}
+        AND clp.status = 'completed'
+        AND clp.completed_at >= ${start}
+        AND clp.completed_at < ${end}
+    `;
+    return Number(rows[0]?.total ?? 0);
+  }
+
+  private async countResolvedExercises(
+    personId: number | null,
+    start: Date,
+    end: Date,
+  ): Promise<number> {
+    if (!personId) return 0;
+    const rows = await (this.prisma as any).$queryRaw<[{ total: bigint }]>`
+      SELECT COUNT(ea.id) AS total
+      FROM exam_answer ea
+      JOIN exam_attempt att ON att.id = ea.exam_attempt_id
+      WHERE att.student_id = ${personId}
+        AND att.started_at >= ${start}
+        AND att.started_at < ${end}
+    `;
+    return Number(rows[0]?.total ?? 0);
+  }
+
+  private async getAccuracyRate(
+    personId: number | null,
+    start: Date,
+    end: Date,
+  ): Promise<number> {
+    if (!personId) return 0;
+    const rows = await (this.prisma as any).$queryRaw<
+      [{ correct: bigint; total: bigint }]
+    >`
+      SELECT
+        COUNT(CASE WHEN ea.is_correct = true THEN 1 END) AS correct,
+        COUNT(*) AS total
+      FROM exam_answer ea
+      JOIN exam_attempt att ON att.id = ea.exam_attempt_id
+      WHERE att.student_id = ${personId}
+        AND ea.is_correct IS NOT NULL
+        AND att.started_at >= ${start}
+        AND att.started_at < ${end}
+    `;
+    const { correct, total } = rows[0] ?? { correct: BigInt(0), total: BigInt(0) };
+    const t = Number(total);
+    return t === 0 ? 0 : Math.round((Number(correct) / t) * 100);
+  }
+
+  private async getBitcodesBalance(personId: number | null): Promise<number> {
+    if (!personId) return 0;
+    const row = await (this.prisma as any).bitcode_wallet.findFirst({
+      where: { person_id: personId },
+      select: { current_balance: true },
+    });
+    return Number(row?.current_balance ?? 0);
+  }
+
+  private async getBitcodesEarned(
+    personId: number | null,
+    start: Date,
+    end: Date,
+  ): Promise<number> {
+    if (!personId) return 0;
+    const rows = await (this.prisma as any).$queryRaw<[{ total: bigint }]>`
+      SELECT COALESCE(SUM(bwt.amount), 0) AS total
+      FROM bitcode_wallet_transaction bwt
+      JOIN bitcode_wallet bw ON bw.id = bwt.wallet_id
+      WHERE bw.person_id = ${personId}
+        AND bwt.type = 'credit'
+        AND bwt.created_at >= ${start}
+        AND bwt.created_at < ${end}
+    `;
+    return Number(rows[0]?.total ?? 0);
+  }
+
+  private async getWeeklySparkline(
+    fetcher: (w: { start: Date; end: Date }) => Promise<number>,
+    weeks: number,
+  ): Promise<Array<{ index: number; value: number }>> {
+    const now = new Date();
+    const results: Array<{ index: number; value: number }> = [];
+
+    for (let i = weeks - 1; i >= 0; i--) {
+      const end = new Date(now.getTime() - i * 7 * 24 * 3600 * 1000);
+      const start = new Date(end.getTime() - 7 * 24 * 3600 * 1000);
+      const value = await fetcher({ start, end });
+      results.push({ index: weeks - i, value });
+    }
+
+    return results;
+  }
+
+  // ---------------------------------------------------------------------------
+  // Study hours chart
+  // ---------------------------------------------------------------------------
+
+  private async getStudyHoursChart(
+    personId: number | null,
+  ): Promise<Array<{ month: string; hours: number }>> {
+    if (!personId) return [];
+
+    const tenMonthsAgo = new Date();
+    tenMonthsAgo.setMonth(tenMonthsAgo.getMonth() - 10);
+
+    const rows = await (this.prisma as any).$queryRaw<
+      Array<{ month_label: string; hours: number }>
+    >`
+      SELECT
+        TO_CHAR(DATE_TRUNC('month', clp.completed_at), 'Mon') AS month_label,
+        ROUND(SUM(cl.duration_seconds) / 3600.0, 1)           AS hours
+      FROM course_lesson_progress clp
+      JOIN course_enrollment  ce ON ce.id = clp.course_enrollment_id
+      JOIN course_lesson       cl ON cl.id = clp.course_lesson_id
+      WHERE ce.person_id    = ${personId}
+        AND clp.status       = 'completed'
+        AND clp.completed_at IS NOT NULL
+        AND clp.completed_at >= ${tenMonthsAgo}
+      GROUP BY DATE_TRUNC('month', clp.completed_at)
+      ORDER BY DATE_TRUNC('month', clp.completed_at)
+    `;
+
+    return rows.map((r) => ({
+      month: toPtMonth(r.month_label),
+      hours: Number(r.hours),
+    }));
+  }
+
+  // ---------------------------------------------------------------------------
+  // Area radar chart
+  // ---------------------------------------------------------------------------
+
+  private async getAreaPerformance(
+    personId: number | null,
+  ): Promise<Array<{ area: string; score: number }>> {
+    if (!personId) return [];
+
+    const rows = await (this.prisma as any).$queryRaw<
+      Array<{ slug: string; score: number }>
+    >`
+      SELECT
+        cat.slug                      AS slug,
+        ROUND(AVG(ce.progress_percent)) AS score
+      FROM course_enrollment  ce
+      JOIN course_category     cc  ON cc.course_id  = ce.course_id
+      JOIN category            cat ON cat.id        = cc.category_id
+      WHERE ce.person_id = ${personId}
+      GROUP BY cat.id, cat.slug
+      ORDER BY score DESC
+      LIMIT 6
+    `;
+
+    return rows.map((r) => ({
+      area: slugToTitle(r.slug),
+      score: Number(r.score),
+    }));
+  }
+
+  // ---------------------------------------------------------------------------
+  // Accuracy donut chart
+  // ---------------------------------------------------------------------------
+
+  private async getAccuracyDistribution(
+    personId: number | null,
+    start: Date,
+  ): Promise<Array<{ label: string; value: number; fill: string }>> {
+    if (!personId) {
+      return [
+        { label: 'Acertos', value: 0, fill: '#4ADE80' },
+        { label: 'Erros', value: 0, fill: '#FB7185' },
+        { label: 'Não respondidas', value: 0, fill: '#D1D5DB' },
+      ];
+    }
+
+    const rows = await (this.prisma as any).$queryRaw<
+      [{ correct: bigint; incorrect: bigint; unanswered: bigint }]
+    >`
+      SELECT
+        COUNT(CASE WHEN ea.is_correct = true  THEN 1 END) AS correct,
+        COUNT(CASE WHEN ea.is_correct = false THEN 1 END) AS incorrect,
+        COUNT(CASE WHEN ea.is_correct IS NULL THEN 1 END) AS unanswered
+      FROM exam_answer ea
+      JOIN exam_attempt att ON att.id = ea.exam_attempt_id
+      WHERE att.student_id  = ${personId}
+        AND att.started_at >= ${start}
+    `;
+
+    const { correct, incorrect, unanswered } = rows[0] ?? {
+      correct: BigInt(0),
+      incorrect: BigInt(0),
+      unanswered: BigInt(0),
+    };
+    const total = Number(correct) + Number(incorrect) + Number(unanswered);
+    const pct = (n: bigint) =>
+      total === 0 ? 0 : Math.round((Number(n) / total) * 100);
+
+    return [
+      { label: 'Acertos', value: pct(correct), fill: '#4ADE80' },
+      { label: 'Erros', value: pct(incorrect), fill: '#FB7185' },
+      { label: 'Não respondidas', value: pct(unanswered), fill: '#D1D5DB' },
+    ];
+  }
+
+  // ---------------------------------------------------------------------------
+  // Lessons by category chart
+  // ---------------------------------------------------------------------------
+
+  private async getLessonsByCategory(
+    personId: number | null,
+    start: Date,
+  ): Promise<Array<{ label: string; value: number; fill: string }>> {
+    if (!personId) return [];
+
+    const rows = await (this.prisma as any).$queryRaw<
+      Array<{ slug: string; value: bigint }>
+    >`
+      SELECT
+        cat.slug     AS slug,
+        COUNT(clp.id) AS value
+      FROM course_lesson_progress clp
+      JOIN course_enrollment  ce  ON ce.id  = clp.course_enrollment_id
+      JOIN course_lesson       cl  ON cl.id  = clp.course_lesson_id
+      JOIN course_module       cm  ON cm.id  = cl.course_module_id
+      JOIN course_category     cc  ON cc.course_id = cm.course_id
+      JOIN category            cat ON cat.id = cc.category_id
+      WHERE ce.person_id    = ${personId}
+        AND clp.status       = 'completed'
+        AND clp.completed_at >= ${start}
+      GROUP BY cat.id, cat.slug
+      ORDER BY value DESC
+      LIMIT 6
+    `;
+
+    return rows.map((r, i) => ({
+      label: slugToTitle(r.slug),
+      value: Number(r.value),
+      fill: CATEGORY_COLORS[i % CATEGORY_COLORS.length],
+    }));
+  }
+
+  // ---------------------------------------------------------------------------
+  // Average lesson time chart
+  // ---------------------------------------------------------------------------
+
+  private async getAvgLessonTime(
+    personId: number | null,
+  ): Promise<Array<{ month: string; minutes: number }>> {
+    if (!personId) return [];
+
+    const tenMonthsAgo = new Date();
+    tenMonthsAgo.setMonth(tenMonthsAgo.getMonth() - 10);
+
+    const rows = await (this.prisma as any).$queryRaw<
+      Array<{ month_label: string; minutes: number }>
+    >`
+      SELECT
+        TO_CHAR(DATE_TRUNC('month', clp.completed_at), 'Mon') AS month_label,
+        ROUND(AVG(cl.duration_seconds) / 60.0)                AS minutes
+      FROM course_lesson_progress clp
+      JOIN course_enrollment ce ON ce.id = clp.course_enrollment_id
+      JOIN course_lesson      cl ON cl.id = clp.course_lesson_id
+      WHERE ce.person_id    = ${personId}
+        AND clp.status       = 'completed'
+        AND clp.completed_at IS NOT NULL
+        AND clp.completed_at >= ${tenMonthsAgo}
+      GROUP BY DATE_TRUNC('month', clp.completed_at)
+      ORDER BY DATE_TRUNC('month', clp.completed_at)
+    `;
+
+    return rows.map((r) => ({
+      month: toPtMonth(r.month_label),
+      minutes: Number(r.minutes),
+    }));
+  }
+
+  // ---------------------------------------------------------------------------
+  // Trail progress card
+  // ---------------------------------------------------------------------------
+
+  private async getTrailProgress(
+    personId: number | null,
+  ): Promise<Array<{ trail: string; progress: number; color: string }>> {
+    if (!personId) return [];
+
+    const rows = await (this.prisma as any).$queryRaw<
+      Array<{ title: string; progress: number }>
+    >`
+      SELECT
+        c.title              AS title,
+        ce.progress_percent  AS progress
+      FROM course_enrollment ce
+      JOIN course c ON c.id = ce.course_id
+      WHERE ce.person_id = ${personId}
+        AND ce.status IN ('active', 'completed')
+        AND ce.progress_percent > 0
+      ORDER BY ce.progress_percent DESC
+      LIMIT 5
+    `;
+
+    return rows.map((r, i) => ({
+      trail: r.title,
+      progress: Number(r.progress),
+      color: TRAIL_COLORS[i % TRAIL_COLORS.length],
+    }));
+  }
+
+  // ---------------------------------------------------------------------------
+  // Weekly ranking
+  // ---------------------------------------------------------------------------
+
+  private async getRanking(): Promise<
+    Array<{
+      id: string;
+      position: number;
+      name: string;
+      score: string;
+      avatar: string | null;
+    }>
+  > {
+    const rows = await (this.prisma as any).$queryRaw<
+      Array<{ person_id: number; name: string; current_balance: number }>
+    >`
+      SELECT
+        bw.person_id,
+        p.name,
+        bw.current_balance
+      FROM bitcode_wallet bw
+      JOIN person p ON p.id = bw.person_id
+      ORDER BY bw.current_balance DESC
+      LIMIT 5
+    `;
+
+    return rows.map((r, i) => ({
+      id: String(r.person_id),
+      position: i + 1,
+      name: r.name ?? 'Aluno',
+      score: `${Number(r.current_balance).toLocaleString('pt-BR')} BITCODES`,
+      avatar: null,
+    }));
+  }
+
+  // ---------------------------------------------------------------------------
+  // Helpers
+  // ---------------------------------------------------------------------------
+
+  private async getPersonId(userId: number): Promise<number | null> {
+    const row = await this.prisma.person_user.findFirst({
+      where: { user_id: userId },
+      select: { person_id: true },
+    });
+    return row?.person_id ?? null;
+  }
+}

package/src/platforma/platforma-search.service.ts

@@ -0,0 +1,48 @@
+import { Injectable } from '@nestjs/common';
+import { ClassGroupService } from '../class-group/class-group.service';
+import { TrainingStudentService } from '../enterprise/training/training-student.service';
+import { ExamService } from '../exam/exam.service';
+import { InstructorService } from '../instructor/instructor.service';
+import { TrainingService } from '../training/training.service';
+
+@Injectable()
+export class PlatformaSearchService {
+  constructor(
+    private readonly trainingStudentService: TrainingStudentService,
+    private readonly trainingService: TrainingService,
+    private readonly examService: ExamService,
+    private readonly classGroupService: ClassGroupService,
+    private readonly instructorService: InstructorService,
+  ) {}
+
+  async search(q: string, types: string[], pageSize = 5) {
+    const all = types.length === 0;
+
+    const [courses, tracks, exams, classrooms, instructors] =
+      await Promise.allSettled([
+        all || types.includes('course')
+          ? this.trainingStudentService.getPublishedCourses({ search: q, pageSize })
+          : Promise.resolve(null),
+        all || types.includes('track')
+          ? this.trainingService.list({ search: q, status: 'ativa', pageSize })
+          : Promise.resolve(null),
+        all || types.includes('exam')
+          ? this.examService.list({ search: q, status: 'published', pageSize })
+          : Promise.resolve(null),
+        all || types.includes('classroom')
+          ? this.classGroupService.list({ search: q, pageSize })
+          : Promise.resolve(null),
+        all || types.includes('instructor')
+          ? this.instructorService.list({ search: q, status: 'active', pageSize })
+          : Promise.resolve(null),
+      ]);
+
+    return {
+      courses: courses.status === 'fulfilled' ? courses.value : null,
+      tracks: tracks.status === 'fulfilled' ? tracks.value : null,
+      exams: exams.status === 'fulfilled' ? exams.value : null,
+      classrooms: classrooms.status === 'fulfilled' ? classrooms.value : null,
+      instructors: instructors.status === 'fulfilled' ? instructors.value : null,
+    };
+  }
+}