@hed-hog/lms 0.0.304 → 0.0.305

package/src/training/training.service.ts

@@ -0,0 +1,574 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { Injectable } from '@nestjs/common';
+import { CreateTrainingDto, LearningPathItemDto } from './dto/create-training.dto';
+import { UpdateTrainingDto } from './dto/update-training.dto';
+
+@Injectable()
+export class TrainingService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async list(params: {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+    status?: string;
+    level?: string;
+    area?: string;
+  }) {
+    const page = Math.max(Number(params.page) || 1, 1);
+    const pageSize = Math.max(Number(params.pageSize) || 12, 1);
+    const skip = (page - 1) * pageSize;
+
+    const where: any = {};
+
+    const normalizedStatus = this.normalizeStatus(params.status);
+    if (normalizedStatus) {
+      where.status = normalizedStatus;
+    }
+
+    const normalizedLevel = this.normalizeLevel(params.level);
+    if (normalizedLevel) {
+      where.level = normalizedLevel;
+    }
+
+    if (params.search?.trim()) {
+      const search = params.search.trim();
+      where.OR = [
+        { title: { contains: search, mode: 'insensitive' } },
+        { slug: { contains: search, mode: 'insensitive' } },
+        { description: { contains: search, mode: 'insensitive' } },
+        { short_description: { contains: search, mode: 'insensitive' } },
+      ];
+    }
+
+    const areaSlugs = this.areaToCategorySlugs(params.area);
+    if (areaSlugs.length > 0) {
+      where.learning_path_step = {
+        some: {
+          step_type: 'course',
+          course: {
+            course_category: {
+              some: {
+                category: {
+                  slug: {
+                    in: areaSlugs,
+                  },
+                },
+              },
+            },
+          },
+        },
+      };
+    }
+
+    const [paths, total] = await Promise.all([
+      this.prisma.learning_path.findMany({
+        skip,
+        take: pageSize,
+        where,
+        orderBy: { created_at: 'desc' },
+        include: {
+          learning_path_step: {
+            orderBy: { order: 'asc' },
+            include: {
+              course: {
+                select: {
+                  id: true,
+                  title: true,
+                  duration_hours: true,
+                  course_category: {
+                    include: {
+                      category: {
+                        select: { slug: true },
+                      },
+                    },
+                  },
+                },
+              },
+              exam: {
+                select: {
+                  id: true,
+                  title: true,
+                  time_limit_minutes: true,
+                },
+              },
+            },
+          },
+          _count: {
+            select: {
+              learning_path_enrollment: true,
+              learning_path_step: true,
+            },
+          },
+        },
+      }),
+      this.prisma.learning_path.count({ where }),
+    ]);
+
+    return {
+      total,
+      page,
+      pageSize,
+      lastPage: Math.max(1, Math.ceil(total / pageSize)),
+      data: paths.map((path) => this.mapTraining(path)),
+    };
+  }
+
+  async stats() {
+    const [totalTraining, activeTraining, enrolledStudents, coveredCourses] =
+      await Promise.all([
+        this.prisma.learning_path.count(),
+        this.prisma.learning_path.count({ where: { status: 'active' } }),
+        this.prisma.learning_path_enrollment.count(),
+        this.prisma.learning_path_step.groupBy({
+          by: ['course_id'],
+          where: { course_id: { not: null } },
+        }),
+      ]);
+
+    return {
+      totalTraining,
+      activeTraining,
+      enrolledStudents,
+      coveredCourses: coveredCourses.length,
+    };
+  }
+
+  async getById(id: number) {
+    const path = await this.prisma.learning_path.findUnique({
+      where: { id },
+      include: {
+        learning_path_step: {
+          orderBy: { order: 'asc' },
+          include: {
+            course: {
+              select: {
+                id: true,
+                title: true,
+                duration_hours: true,
+                course_category: {
+                  include: {
+                    category: {
+                      select: { slug: true },
+                    },
+                  },
+                },
+              },
+            },
+            exam: {
+              select: {
+                id: true,
+                title: true,
+                time_limit_minutes: true,
+              },
+            },
+          },
+        },
+        _count: {
+          select: {
+            learning_path_enrollment: true,
+            learning_path_step: true,
+          },
+        },
+      },
+    });
+
+    if (!path) return null;
+    return this.mapTraining(path);
+  }
+
+  async create(dto: CreateTrainingDto) {
+    const slug = dto.slug?.trim() || this.slugify(dto.title);
+    const stepItems = this.resolveIncomingSteps(dto);
+    const normalizedLevel = this.normalizeLevel(dto.level) ?? 'beginner';
+    const normalizedStatus = this.normalizeStatus(dto.status) ?? 'draft';
+
+    const created = await this.prisma.learning_path.create({
+      data: {
+        title: dto.title,
+        slug,
+        description: dto.description,
+        short_description: dto.shortDescription,
+        level: normalizedLevel,
+        status: normalizedStatus,
+        ...(dto.primaryColor !== undefined && { primary_color: dto.primaryColor }),
+        ...(dto.secondaryColor !== undefined && { secondary_color: dto.secondaryColor }),
+        ...(stepItems.length > 0 && {
+          learning_path_step: {
+            create: stepItems.map((item, index) =>
+              this.toLearningPathCreateStep(item, index),
+            ),
+          },
+        }),
+      },
+      include: {
+        learning_path_step: {
+          orderBy: { order: 'asc' },
+          include: {
+            course: {
+              select: {
+                id: true,
+                title: true,
+                duration_hours: true,
+                course_category: {
+                  include: {
+                    category: {
+                      select: { slug: true },
+                    },
+                  },
+                },
+              },
+            },
+            exam: {
+              select: {
+                id: true,
+                title: true,
+                time_limit_minutes: true,
+              },
+            },
+          },
+        },
+        _count: {
+          select: {
+            learning_path_enrollment: true,
+            learning_path_step: true,
+          },
+        },
+      },
+    });
+
+    return this.mapTraining(created);
+  }
+
+  async update(id: number, dto: UpdateTrainingDto) {
+    const stepItems = this.resolveIncomingSteps(dto);
+    const stepsWereProvided = dto.items !== undefined || dto.courseIds !== undefined;
+    const normalizedLevel =
+      dto.level !== undefined ? this.normalizeLevel(dto.level) : undefined;
+    const normalizedStatus =
+      dto.status !== undefined ? this.normalizeStatus(dto.status) : undefined;
+
+    if (stepsWereProvided) {
+      await this.prisma.learning_path_step.deleteMany({
+        where: {
+          learning_path_id: id,
+        },
+      });
+    }
+
+    const updated = await this.prisma.learning_path.update({
+      where: { id },
+      data: {
+        ...(dto.title !== undefined && { title: dto.title }),
+        ...(dto.slug !== undefined && { slug: dto.slug || this.slugify(dto.title ?? '') }),
+        ...(dto.description !== undefined && { description: dto.description }),
+        ...(dto.shortDescription !== undefined && {
+          short_description: dto.shortDescription,
+        }),
+        ...(normalizedLevel !== undefined && { level: normalizedLevel }),
+        ...(normalizedStatus !== undefined && { status: normalizedStatus }),
+        ...(dto.primaryColor !== undefined && { primary_color: dto.primaryColor }),
+        ...(dto.secondaryColor !== undefined && { secondary_color: dto.secondaryColor }),
+        ...(stepsWereProvided &&
+          stepItems.length > 0 && {
+            learning_path_step: {
+              create: stepItems.map((item, index) =>
+                this.toLearningPathCreateStep(item, index),
+              ),
+            },
+          }),
+      },
+      include: {
+        learning_path_step: {
+          orderBy: { order: 'asc' },
+          include: {
+            course: {
+              select: {
+                id: true,
+                title: true,
+                duration_hours: true,
+                course_category: {
+                  include: {
+                    category: {
+                      select: { slug: true },
+                    },
+                  },
+                },
+              },
+            },
+            exam: {
+              select: {
+                id: true,
+                title: true,
+                time_limit_minutes: true,
+              },
+            },
+          },
+        },
+        _count: {
+          select: {
+            learning_path_enrollment: true,
+            learning_path_step: true,
+          },
+        },
+      },
+    });
+
+    return this.mapTraining(updated);
+  }
+
+  async remove(id: number) {
+    await this.prisma.learning_path.delete({ where: { id } });
+    return { success: true };
+  }
+
+  private mapTraining(path: any) {
+    const steps = [...(path.learning_path_step ?? [])].sort(
+      (a: any, b: any) => (a?.order ?? 0) - (b?.order ?? 0),
+    );
+    const courseSteps = steps.filter((step: any) => step?.course);
+    const examSteps = steps.filter((step: any) => step?.exam);
+
+    const courses = courseSteps.map((step: any) => step.course.title);
+    const exams = examSteps.map((step: any) => step.exam.title);
+    const courseIds = courseSteps.map((step: any) => step.course.id);
+    const examIds = examSteps.map((step: any) => step.exam.id);
+    const cargaTotal = courseSteps.reduce(
+      (sum: number, step: any) => sum + (step.course?.duration_hours ?? 0),
+      0,
+    );
+
+    const firstCategorySlug = steps
+      .flatMap((step: any) => step.course?.course_category ?? [])
+      .map((item: any) => item.category?.slug)
+      .find(Boolean);
+
+    const items = steps
+      .map((step: any, index: number) => {
+        if (step?.course) {
+          return {
+            id: step.id,
+            type: 'course' as const,
+            itemId: step.course.id,
+            title: step.course.title,
+            durationHours: step.course.duration_hours ?? 0,
+            order: step.order ?? index,
+            isRequired: step.is_required !== false,
+          };
+        }
+
+        if (step?.exam) {
+          return {
+            id: step.id,
+            type: 'exam' as const,
+            itemId: step.exam.id,
+            title: step.exam.title,
+            durationMinutes: step.exam.time_limit_minutes ?? 0,
+            order: step.order ?? index,
+            isRequired: step.is_required !== false,
+          };
+        }
+
+        return null;
+      })
+      .filter(Boolean);
+
+    return {
+      id: path.id,
+      nome: path.title,
+      descricao: path.description ?? path.short_description ?? '',
+      area: this.slugToArea(firstCategorySlug),
+      nivel: this.levelToPt(path.level),
+      prerequisitos: path.short_description ?? '',
+      cursos: courses,
+      exams,
+      courseIds,
+      examIds,
+      items,
+      cargaTotal,
+      alunos: path._count?.learning_path_enrollment ?? 0,
+      status: this.statusToPt(path.status),
+      criadoEm: path.created_at,
+      primaryColor: path.primary_color ?? undefined,
+      secondaryColor: path.secondary_color ?? undefined,
+      code: this.idToCode(path.id),
+      slug: path.slug,
+      level: path.level,
+      statusRaw: path.status,
+      students: path._count?.learning_path_enrollment ?? 0,
+      createdAt: path.created_at,
+    };
+  }
+
+  private resolveIncomingSteps(dto: {
+    items?: LearningPathItemDto[];
+    courseIds?: number[];
+  }) {
+    if (dto.items !== undefined) {
+      const normalized = dto.items
+        .map((item, index) => ({
+          type: item.type,
+          itemId: Number(item.itemId),
+          order: Number.isFinite(item.order) ? Number(item.order) : index,
+          isRequired: item.isRequired !== false,
+        }))
+        .filter(
+          (item) =>
+            (item.type === 'course' || item.type === 'exam') &&
+            Number.isFinite(item.itemId) &&
+            item.itemId > 0,
+        );
+
+      const uniqueByPair = new Map<string, (typeof normalized)[number]>();
+      normalized.forEach((item) => {
+        uniqueByPair.set(`${item.type}:${item.itemId}`, item);
+      });
+
+      return Array.from(uniqueByPair.values()).sort(
+        (a, b) => a.order - b.order,
+      );
+    }
+
+    const courseIds = [...new Set(dto.courseIds ?? [])].filter(
+      (courseId) => Number.isFinite(courseId) && courseId > 0,
+    );
+
+    return courseIds.map((courseId, index) => ({
+      type: 'course' as const,
+      itemId: courseId,
+      order: index,
+      isRequired: true,
+    }));
+  }
+
+  private toLearningPathCreateStep(
+    item: {
+      type: 'course' | 'exam';
+      itemId: number;
+      order: number;
+      isRequired: boolean;
+    },
+    fallbackOrder: number,
+  ) {
+    return {
+      step_type: item.type,
+      course_id: item.type === 'course' ? item.itemId : null,
+      exam_id: item.type === 'exam' ? item.itemId : null,
+      order: Number.isFinite(item.order) ? item.order : fallbackOrder,
+      is_required: item.isRequired,
+    };
+  }
+
+  private normalizeStatus(value?: string) {
+    if (!value) return undefined;
+    const normalized = value.trim().toLowerCase();
+
+    if (normalized === 'ativa' || normalized === 'active') return 'active';
+    if (normalized === 'rascunho' || normalized === 'draft') return 'draft';
+    if (normalized === 'encerrada' || normalized === 'archived') {
+      return 'archived';
+    }
+
+    return undefined;
+  }
+
+  private normalizeLevel(value?: string) {
+    if (!value) return undefined;
+    const normalized = value
+      .trim()
+      .toLowerCase()
+      .normalize('NFD')
+      .replace(/[\u0300-\u036f]/g, '');
+
+    if (normalized === 'iniciante' || normalized === 'beginner') {
+      return 'beginner';
+    }
+    if (normalized === 'intermediario' || normalized === 'intermediate') {
+      return 'intermediate';
+    }
+    if (normalized === 'avancado' || normalized === 'advanced') {
+      return 'advanced';
+    }
+
+    return undefined;
+  }
+
+  private areaToCategorySlugs(value?: string) {
+    if (!value || value === 'todos') return [];
+
+    const normalized = value
+      .trim()
+      .toLowerCase()
+      .normalize('NFD')
+      .replace(/[\u0300-\u036f]/g, '');
+
+    const map: Record<string, string[]> = {
+      tecnologia: ['tecnologia', 'technology'],
+      design: ['design'],
+      gestao: ['gestao', 'management'],
+      marketing: ['marketing'],
+      financas: ['financas', 'finance'],
+    };
+
+    return map[normalized] ?? [normalized];
+  }
+
+  private slugToArea(slug?: string) {
+    if (!slug) return 'Tecnologia';
+
+    const normalized = slug
+      .trim()
+      .toLowerCase()
+      .normalize('NFD')
+      .replace(/[\u0300-\u036f]/g, '');
+
+    const map: Record<string, string> = {
+      tecnologia: 'Tecnologia',
+      technology: 'Tecnologia',
+      design: 'Design',
+      gestao: 'Gestao',
+      management: 'Gestao',
+      marketing: 'Marketing',
+      financas: 'Financas',
+      finance: 'Financas',
+    };
+
+    return map[normalized] ?? 'Tecnologia';
+  }
+
+  private levelToPt(level: string) {
+    const map: Record<string, string> = {
+      beginner: 'Iniciante',
+      intermediate: 'Intermediario',
+      advanced: 'Avancado',
+    };
+
+    return map[level] ?? level;
+  }
+
+  private statusToPt(status: string) {
+    const map: Record<string, string> = {
+      draft: 'rascunho',
+      active: 'ativa',
+      archived: 'encerrada',
+    };
+
+    return map[status] ?? status;
+  }
+
+  private slugify(value: string) {
+    return value
+      .toLowerCase()
+      .normalize('NFD')
+      .replace(/[\u0300-\u036f]/g, '')
+      .replace(/[^a-z0-9\s-]/g, '')
+      .trim()
+      .replace(/\s+/g, '-')
+      .replace(/-+/g, '-')
+      .slice(0, 255);
+  }
+
+  private idToCode(id: number) {
+    return `TR-${String(id).padStart(3, '0')}`;
+  }
+}