@hed-hog/lms 0.0.304 → 0.0.306

package/src/course/course-structure.service.ts

@@ -0,0 +1,525 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
+import { CreateCourseStructureLessonDto } from './dto/create-course-structure-lesson.dto';
+import { CreateCourseStructureSessionDto } from './dto/create-course-structure-session.dto';
+import { UpdateCourseStructureLessonDto } from './dto/update-course-structure-lesson.dto';
+import { UpdateCourseStructureSessionDto } from './dto/update-course-structure-session.dto';
+import { InstructorService } from '../instructor/instructor.service';
+
+type LessonUiType = 'video' | 'questao' | 'post' | 'exercicio';
+type LessonDbType = 'video' | 'text' | 'quiz';
+
+@Injectable()
+export class CourseStructureService {
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly instructorService: InstructorService,
+  ) {}
+
+  async getStructure(courseId: number) {
+    await this.ensureCourseExists(courseId);
+
+    const [modules, instructors] = await Promise.all([
+      this.prisma.course_module.findMany({
+        where: { course_id: courseId },
+        orderBy: { order: 'asc' },
+        include: {
+          course_lesson: {
+            orderBy: { order: 'asc' },
+            include: {
+              course_lesson_file: true,
+              course_lesson_question: {
+                orderBy: { order: 'asc' },
+              },
+              course_lesson_instructor: {
+                include: {
+                  instructor: {
+                    include: {
+                      person: {
+                        select: {
+                          name: true,
+                        },
+                      },
+                    },
+                  },
+                },
+                orderBy: { id: 'asc' },
+              },
+            },
+          },
+        },
+      }),
+      this.instructorService.listQualifiedInstructorOptions(['course-lessons']),
+    ]);
+
+    const sessoes = modules.map((module, index) => ({
+      id: String(module.id),
+      codigo: this.formatCode('S', module.order ?? index + 1),
+      titulo: module.title,
+      duracao: module.duration_minutes ?? 0,
+      collapsed: false,
+    }));
+
+    const aulas = modules.flatMap((module) =>
+      module.course_lesson.map((lesson, index) => {
+        const parsedContent = this.parseLessonContent(lesson.content);
+        const tipo = this.mapDbTypeToUiType(lesson.type, parsedContent?.sourceType);
+
+        return {
+          id: String(lesson.id),
+          codigo: this.formatCode('A', lesson.order ?? index + 1),
+          titulo: lesson.title,
+          descricaoPublica: lesson.description ?? '',
+          descricaoPrivada: parsedContent?.descricaoPrivada ?? '',
+          tipo,
+          duracao: Math.max(1, Math.round((lesson.duration_seconds ?? 0) / 60)),
+          sessaoId: String(module.id),
+          videoProvedor: parsedContent?.videoProvedor,
+          videoUrl: parsedContent?.videoUrl,
+          duracaoAutomatica: parsedContent?.duracaoAutomatica,
+          transcricao: parsedContent?.transcricao,
+          exameVinculado:
+            parsedContent?.exameVinculado != null
+              ? String(parsedContent.exameVinculado)
+              : lesson.course_lesson_question[0]?.question_id != null
+                ? String(lesson.course_lesson_question[0].question_id)
+                : undefined,
+          conteudoPost: parsedContent?.conteudoPost,
+          recursos: lesson.course_lesson_file.map((fileLink) => ({
+            id: String(fileLink.id),
+            nome: fileLink.title,
+            tamanho: '',
+            tipo: '',
+            publico: true,
+          })),
+          instrutores: lesson.course_lesson_instructor.map((item) => ({
+            id: String(item.instructor_id),
+            role: item.role,
+            nome: this.personName(item.instructor?.person),
+          })),
+        };
+      }),
+    );
+
+    return {
+      sessoes,
+      aulas,
+      instructors: instructors.map((instructor) => ({
+        id: instructor.id,
+        name: instructor.name,
+      })),
+    };
+  }
+
+  async createSession(courseId: number, dto: CreateCourseStructureSessionDto) {
+    await this.ensureCourseExists(courseId);
+    const nextOrder = await this.nextModuleOrder(courseId);
+
+    const created = await this.prisma.course_module.create({
+      data: {
+        course_id: courseId,
+        title: dto.titulo,
+        description: dto.descricao ?? null,
+        duration_minutes: dto.duracao,
+        order: nextOrder,
+      },
+    });
+
+    return {
+      id: String(created.id),
+      codigo: this.formatCode('S', created.order ?? nextOrder),
+      titulo: created.title,
+      duracao: created.duration_minutes ?? 0,
+      collapsed: false,
+    };
+  }
+
+  async updateSession(
+    courseId: number,
+    sessionId: number,
+    dto: UpdateCourseStructureSessionDto,
+  ) {
+    const module = await this.prisma.course_module.findFirst({
+      where: { id: sessionId, course_id: courseId },
+    });
+
+    if (!module) {
+      throw new NotFoundException('Session not found for this course');
+    }
+
+    const updated = await this.prisma.course_module.update({
+      where: { id: sessionId },
+      data: {
+        ...(dto.titulo !== undefined && { title: dto.titulo }),
+        ...(dto.descricao !== undefined && { description: dto.descricao }),
+        ...(dto.duracao !== undefined && { duration_minutes: dto.duracao }),
+      },
+    });
+
+    return {
+      id: String(updated.id),
+      codigo: this.formatCode('S', updated.order ?? 0),
+      titulo: updated.title,
+      duracao: updated.duration_minutes ?? 0,
+      collapsed: false,
+    };
+  }
+
+  async deleteSession(courseId: number, sessionId: number) {
+    const module = await this.prisma.course_module.findFirst({
+      where: { id: sessionId, course_id: courseId },
+    });
+
+    if (!module) {
+      throw new NotFoundException('Session not found for this course');
+    }
+
+    await this.prisma.course_module.delete({ where: { id: sessionId } });
+
+    return { success: true };
+  }
+
+  async createLesson(
+    courseId: number,
+    sessionId: number,
+    dto: CreateCourseStructureLessonDto,
+  ) {
+    const module = await this.prisma.course_module.findFirst({
+      where: { id: sessionId, course_id: courseId },
+    });
+
+    if (!module) {
+      throw new NotFoundException('Session not found for this course');
+    }
+
+    const nextOrder = await this.nextLessonOrder(sessionId);
+    const mappedType = this.mapUiTypeToDbType(dto.tipo);
+
+    const created = await this.prisma.course_lesson.create({
+      data: {
+        course_module_id: sessionId,
+        title: dto.titulo,
+        description: dto.descricaoPublica ?? null,
+        type: mappedType,
+        duration_seconds: dto.duracao * 60,
+        order: nextOrder,
+        content: this.serializeContent(dto),
+      },
+    });
+
+    await this.syncLessonRelations(created.id, dto);
+
+    return this.getLessonById(created.id);
+  }
+
+  async updateLesson(
+    courseId: number,
+    sessionId: number,
+    lessonId: number,
+    dto: UpdateCourseStructureLessonDto,
+  ) {
+    const lesson = await this.prisma.course_lesson.findFirst({
+      where: {
+        id: lessonId,
+        course_module_id: sessionId,
+        course_module: { course_id: courseId },
+      },
+    });
+
+    if (!lesson) {
+      throw new NotFoundException('Lesson not found for this session');
+    }
+
+    const updated = await this.prisma.course_lesson.update({
+      where: { id: lessonId },
+      data: {
+        ...(dto.titulo !== undefined && { title: dto.titulo }),
+        ...(dto.descricaoPublica !== undefined && {
+          description: dto.descricaoPublica,
+        }),
+        ...(dto.tipo !== undefined && { type: this.mapUiTypeToDbType(dto.tipo) }),
+        ...(dto.duracao !== undefined && {
+          duration_seconds: dto.duracao * 60,
+        }),
+        content: this.serializeContent({
+          tipo: dto.tipo ?? this.mapDbTypeToUiType(lesson.type),
+          videoProvedor: dto.videoProvedor,
+          videoUrl: dto.videoUrl,
+          duracaoAutomatica: dto.duracaoAutomatica,
+          transcricao: dto.transcricao,
+          conteudoPost: dto.conteudoPost,
+          exameVinculado: dto.exameVinculado,
+          descricaoPrivada: dto.descricaoPrivada,
+        }),
+      },
+    });
+
+    await this.syncLessonRelations(lessonId, dto);
+
+    return this.getLessonById(updated.id);
+  }
+
+  async deleteLesson(
+    courseId: number,
+    sessionId: number,
+    lessonId: number,
+  ) {
+    const lesson = await this.prisma.course_lesson.findFirst({
+      where: {
+        id: lessonId,
+        course_module_id: sessionId,
+        course_module: { course_id: courseId },
+      },
+    });
+
+    if (!lesson) {
+      throw new NotFoundException('Lesson not found for this session');
+    }
+
+    await this.prisma.course_lesson.delete({ where: { id: lessonId } });
+
+    return { success: true };
+  }
+
+  private async syncLessonRelations(
+    lessonId: number,
+    dto: Partial<
+      Pick<
+      CreateCourseStructureLessonDto,
+      'tipo' | 'exameVinculado' | 'instructorIds' | 'recursos'
+      >
+    >,
+  ) {
+    const instructorIds = [...new Set(dto.instructorIds ?? [])];
+
+    if (instructorIds.length > 0) {
+      await this.instructorService.assertQualifiedInstructorIds(
+        instructorIds,
+        ['course-lessons'],
+      );
+    }
+
+    await this.prisma.$transaction(async (tx) => {
+      await tx.course_lesson_instructor.deleteMany({
+        where: { course_lesson_id: lessonId },
+      });
+
+      if (instructorIds.length > 0) {
+        await tx.course_lesson_instructor.createMany({
+          data: instructorIds.map((instructorId, index) => ({
+            course_lesson_id: lessonId,
+            instructor_id: instructorId,
+            role: index === 0 ? 'lead' : 'assistant',
+          })),
+        });
+      }
+
+      await tx.course_lesson_file.deleteMany({
+        where: { course_lesson_id: lessonId },
+      });
+
+      const recursos = dto.recursos ?? [];
+      if (recursos.length > 0) {
+        await tx.course_lesson_file.createMany({
+          data: recursos.map((recurso) => ({
+            course_lesson_id: lessonId,
+            title: recurso.nome,
+            file_id: recurso.fileId ?? null,
+          })),
+        });
+      }
+
+      await tx.course_lesson_question.deleteMany({
+        where: { course_lesson_id: lessonId },
+      });
+
+      if (dto.tipo === 'questao' && dto.exameVinculado) {
+        await tx.course_lesson_question.create({
+          data: {
+            course_lesson_id: lessonId,
+            question_id: dto.exameVinculado,
+            order: 1,
+          },
+        });
+      }
+    });
+  }
+
+  private async getLessonById(lessonId: number) {
+    const lesson = await this.prisma.course_lesson.findUnique({
+      where: { id: lessonId },
+      include: {
+        course_module: {
+          select: { id: true },
+        },
+        course_lesson_file: true,
+        course_lesson_question: {
+          orderBy: { order: 'asc' },
+        },
+        course_lesson_instructor: {
+          include: {
+            instructor: {
+              include: {
+                person: {
+                  select: {
+                    name: true,
+                  },
+                },
+              },
+            },
+          },
+          orderBy: { id: 'asc' },
+        },
+      },
+    });
+
+    if (!lesson) {
+      throw new NotFoundException('Lesson not found');
+    }
+
+    const parsedContent = this.parseLessonContent(lesson.content);
+    const tipo = this.mapDbTypeToUiType(lesson.type, parsedContent?.sourceType);
+
+    return {
+      id: String(lesson.id),
+      codigo: this.formatCode('A', lesson.order ?? 0),
+      titulo: lesson.title,
+      descricaoPublica: lesson.description ?? '',
+      descricaoPrivada: parsedContent?.descricaoPrivada ?? '',
+      tipo,
+      duracao: Math.max(1, Math.round((lesson.duration_seconds ?? 0) / 60)),
+      sessaoId: String(lesson.course_module_id),
+      videoProvedor: parsedContent?.videoProvedor,
+      videoUrl: parsedContent?.videoUrl,
+      duracaoAutomatica: parsedContent?.duracaoAutomatica,
+      transcricao: parsedContent?.transcricao,
+      exameVinculado:
+        parsedContent?.exameVinculado != null
+          ? String(parsedContent.exameVinculado)
+          : lesson.course_lesson_question[0]?.question_id != null
+            ? String(lesson.course_lesson_question[0].question_id)
+            : undefined,
+      conteudoPost: parsedContent?.conteudoPost,
+      recursos: lesson.course_lesson_file.map((fileLink) => ({
+        id: String(fileLink.id),
+        nome: fileLink.title,
+        tamanho: '',
+        tipo: '',
+        publico: true,
+      })),
+      instrutores: lesson.course_lesson_instructor.map((item) => ({
+        id: String(item.instructor_id),
+        role: item.role,
+        nome: this.personName(item.instructor?.person),
+      })),
+    };
+  }
+
+  private async ensureCourseExists(courseId: number) {
+    const course = await this.prisma.course.findUnique({
+      where: { id: courseId },
+      select: { id: true },
+    });
+
+    if (!course) {
+      throw new NotFoundException('Course not found');
+    }
+  }
+
+  private async nextModuleOrder(courseId: number) {
+    const last = await this.prisma.course_module.findFirst({
+      where: { course_id: courseId },
+      orderBy: { order: 'desc' },
+      select: { order: true },
+    });
+
+    return (last?.order ?? 0) + 1;
+  }
+
+  private async nextLessonOrder(sessionId: number) {
+    const last = await this.prisma.course_lesson.findFirst({
+      where: { course_module_id: sessionId },
+      orderBy: { order: 'desc' },
+      select: { order: true },
+    });
+
+    return (last?.order ?? 0) + 1;
+  }
+
+  private mapUiTypeToDbType(type: LessonUiType): LessonDbType {
+    if (type === 'video') return 'video';
+    if (type === 'questao') return 'quiz';
+    return 'text';
+  }
+
+  private mapDbTypeToUiType(
+    type: string,
+    sourceType?: string,
+  ): LessonUiType {
+    if (
+      sourceType === 'video' ||
+      sourceType === 'questao' ||
+      sourceType === 'post' ||
+      sourceType === 'exercicio'
+    ) {
+      return sourceType;
+    }
+
+    if (type === 'video') return 'video';
+    if (type === 'quiz') return 'questao';
+    return 'post';
+  }
+
+  private serializeContent(data: {
+    tipo: LessonUiType;
+    videoProvedor?: string;
+    videoUrl?: string;
+    duracaoAutomatica?: boolean;
+    transcricao?: string;
+    conteudoPost?: string;
+    exameVinculado?: number;
+    descricaoPrivada?: string;
+  }) {
+    const payload: Record<string, unknown> = {
+      sourceType: data.tipo,
+      descricaoPrivada: data.descricaoPrivada ?? '',
+    };
+
+    if (data.tipo === 'video') {
+      payload.videoProvedor = data.videoProvedor ?? 'youtube';
+      payload.videoUrl = data.videoUrl ?? '';
+      payload.duracaoAutomatica = data.duracaoAutomatica ?? false;
+      payload.transcricao = data.transcricao ?? '';
+    }
+
+    if (data.tipo === 'post' || data.tipo === 'exercicio') {
+      payload.conteudoPost = data.conteudoPost ?? '';
+    }
+
+    if (data.tipo === 'questao') {
+      payload.exameVinculado = data.exameVinculado ?? null;
+    }
+
+    return JSON.stringify(payload);
+  }
+
+  private parseLessonContent(content?: string | null): any {
+    if (!content) return null;
+
+    try {
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+
+  private personName(person?: {
+    name?: string | null;
+  } | null) {
+    return person?.name?.trim() || 'Instructor';
+  }
+
+  private formatCode(prefix: 'S' | 'A', order: number) {
+    return `${prefix}${String(Math.max(order, 0)).padStart(2, '0')}`;
+  }
+}

package/src/course/course.controller.ts

@@ -0,0 +1,69 @@
+
+import { Role } from '@hed-hog/api';
+import {
+    Body,
+    Controller,
+    Delete,
+    Get,
+    Param,
+    ParseIntPipe,
+    Patch,
+    Post,
+    Query,
+} from '@nestjs/common';
+import { CourseService } from './course.service';
+import { CreateCourseDto } from './dto/create-course.dto';
+import { UpdateCourseDto } from './dto/update-course.dto';
+
+@Role()
+@Controller('lms/courses')
+export class CourseController {
+  constructor(private readonly courseService: CourseService) {}
+
+  @Get()
+  list(
+    @Query('page') page?: string,
+    @Query('pageSize') pageSize?: string,
+    @Query('search') search?: string,
+    @Query('status') status?: string,
+    @Query('level') level?: string,
+    @Query('category') category?: string,
+  ) {
+    return this.courseService.list({
+      page: page ? Number(page) : 1,
+      pageSize: pageSize ? Number(pageSize) : 12,
+      search,
+      status,
+      level,
+      category,
+    });
+  }
+
+  @Get('stats')
+  stats() {
+    return this.courseService.stats();
+  }
+
+  @Get(':id')
+  getById(@Param('id', ParseIntPipe) id: number) {
+    return this.courseService.getById(id);
+  }
+
+  @Post()
+  create(@Body() dto: CreateCourseDto) {
+    return this.courseService.create(dto);
+  }
+
+  @Patch(':id')
+  update(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() dto: UpdateCourseDto,
+  ) {
+    return this.courseService.update(id, dto);
+  }
+
+  @Delete(':id')
+  remove(@Param('id', ParseIntPipe) id: number) {
+    return this.courseService.remove(id);
+  }
+}

package/src/course/course.module.ts

@@ -0,0 +1,15 @@
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { forwardRef, Module } from '@nestjs/common';
+import { CourseStructureController } from './course-structure.controller';
+import { CourseStructureService } from './course-structure.service';
+import { CourseController } from './course.controller';
+import { CourseService } from './course.service';
+import { InstructorModule } from '../instructor/instructor.module';
+
+@Module({
+  imports: [forwardRef(() => PrismaModule), forwardRef(() => InstructorModule)],
+  controllers: [CourseController, CourseStructureController],
+  providers: [CourseService, CourseStructureService],
+  exports: [forwardRef(() => CourseService), forwardRef(() => CourseStructureService)],
+})
+export class CourseModule {}