@hed-hog/lms 0.0.306 → 0.0.310

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hed-hog/lms",
-  "version": "0.0.306",
+  "version": "0.0.310",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "dependencies": {
@@ -9,15 +9,15 @@
     "@nestjs/core": "^11",
     "@nestjs/jwt": "^11",
     "@nestjs/mapped-types": "*",
+    "@hed-hog/api-types": "0.0.1",
     "@hed-hog/api-prisma": "0.0.6",
-    "@hed-hog/contact": "0.0.306",
     "@hed-hog/api-pagination": "0.0.7",
-    "@hed-hog/core": "0.0.306",
+    "@hed-hog/api": "0.0.6",
+    "@hed-hog/contact": "0.0.310",
     "@hed-hog/api-locale": "0.0.14",
-    "@hed-hog/api-types": "0.0.1",
-    "@hed-hog/finance": "0.0.306",
-    "@hed-hog/category": "0.0.306",
-    "@hed-hog/api": "0.0.6"
+    "@hed-hog/finance": "0.0.310",
+    "@hed-hog/core": "0.0.310",
+    "@hed-hog/category": "0.0.310"
   },
   "exports": {
     ".": {

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

@@ -12,6 +12,10 @@ import {
 import { CourseStructureService } from './course-structure.service';
 import { CreateCourseStructureLessonDto } from './dto/create-course-structure-lesson.dto';
 import { CreateCourseStructureSessionDto } from './dto/create-course-structure-session.dto';
+import { MoveLessonDto } from './dto/move-lesson.dto';
+import { PasteLessonsDto } from './dto/paste-lessons.dto';
+import { ReorderLessonsDto } from './dto/reorder-lessons.dto';
+import { ReorderSessionsDto } from './dto/reorder-sessions.dto';
 import { UpdateCourseStructureLessonDto } from './dto/update-course-structure-lesson.dto';
 import { UpdateCourseStructureSessionDto } from './dto/update-course-structure-session.dto';
 
@@ -25,6 +29,8 @@ export class CourseStructureController {
     return this.courseStructureService.getStructure(courseId);
   }
 
+  // ── Sessions ──────────────────────────────────────────────────────────────
+
   @Post('sessions')
   createSession(
     @Param('id', ParseIntPipe) courseId: number,
@@ -33,6 +39,15 @@ export class CourseStructureController {
     return this.courseStructureService.createSession(courseId, dto);
   }
 
+  // Static PATCH must come before dynamic PATCH sessions/:sessionId
+  @Patch('sessions/reorder')
+  reorderSessions(
+    @Param('id', ParseIntPipe) courseId: number,
+    @Body() dto: ReorderSessionsDto,
+  ) {
+    return this.courseStructureService.reorderSessions(courseId, dto);
+  }
+
   @Patch('sessions/:sessionId')
   updateSession(
     @Param('id', ParseIntPipe) courseId: number,
@@ -50,6 +65,16 @@ export class CourseStructureController {
     return this.courseStructureService.deleteSession(courseId, sessionId);
   }
 
+  @Post('sessions/:sessionId/duplicate')
+  duplicateSession(
+    @Param('id', ParseIntPipe) courseId: number,
+    @Param('sessionId', ParseIntPipe) sessionId: number,
+  ) {
+    return this.courseStructureService.duplicateSession(courseId, sessionId);
+  }
+
+  // ── Lessons ───────────────────────────────────────────────────────────────
+
   @Post('sessions/:sessionId/lessons')
   createLesson(
     @Param('id', ParseIntPipe) courseId: number,
@@ -59,6 +84,25 @@ export class CourseStructureController {
     return this.courseStructureService.createLesson(courseId, sessionId, dto);
   }
 
+  @Post('sessions/:sessionId/lessons/paste')
+  pasteLessons(
+    @Param('id', ParseIntPipe) courseId: number,
+    @Param('sessionId', ParseIntPipe) sessionId: number,
+    @Body() dto: PasteLessonsDto,
+  ) {
+    return this.courseStructureService.pasteLessons(courseId, sessionId, dto);
+  }
+
+  // Static PATCH must come before dynamic PATCH sessions/:sessionId/lessons/:lessonId
+  @Patch('sessions/:sessionId/lessons/reorder')
+  reorderLessons(
+    @Param('id', ParseIntPipe) courseId: number,
+    @Param('sessionId', ParseIntPipe) sessionId: number,
+    @Body() dto: ReorderLessonsDto,
+  ) {
+    return this.courseStructureService.reorderLessons(courseId, sessionId, dto);
+  }
+
   @Patch('sessions/:sessionId/lessons/:lessonId')
   updateLesson(
     @Param('id', ParseIntPipe) courseId: number,
@@ -74,6 +118,16 @@ export class CourseStructureController {
     );
   }
 
+  @Patch('sessions/:sessionId/lessons/:lessonId/move')
+  moveLesson(
+    @Param('id', ParseIntPipe) courseId: number,
+    @Param('sessionId', ParseIntPipe) sessionId: number,
+    @Param('lessonId', ParseIntPipe) lessonId: number,
+    @Body() dto: MoveLessonDto,
+  ) {
+    return this.courseStructureService.moveLesson(courseId, sessionId, lessonId, dto);
+  }
+
   @Delete('sessions/:sessionId/lessons/:lessonId')
   deleteLesson(
     @Param('id', ParseIntPipe) courseId: number,
@@ -82,4 +136,13 @@ export class CourseStructureController {
   ) {
     return this.courseStructureService.deleteLesson(courseId, sessionId, lessonId);
   }
+
+  @Post('sessions/:sessionId/lessons/:lessonId/duplicate')
+  duplicateLesson(
+    @Param('id', ParseIntPipe) courseId: number,
+    @Param('sessionId', ParseIntPipe) sessionId: number,
+    @Param('lessonId', ParseIntPipe) lessonId: number,
+  ) {
+    return this.courseStructureService.duplicateLesson(courseId, sessionId, lessonId);
+  }
 }

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

@@ -1,10 +1,14 @@
 import { PrismaService } from '@hed-hog/api-prisma';
 import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
+import { InstructorService } from '../instructor/instructor.service';
 import { CreateCourseStructureLessonDto } from './dto/create-course-structure-lesson.dto';
 import { CreateCourseStructureSessionDto } from './dto/create-course-structure-session.dto';
+import { MoveLessonDto } from './dto/move-lesson.dto';
+import { PasteLessonsDto } from './dto/paste-lessons.dto';
+import { ReorderLessonsDto } from './dto/reorder-lessons.dto';
+import { ReorderSessionsDto } from './dto/reorder-sessions.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';
@@ -19,7 +23,7 @@ export class CourseStructureService {
   async getStructure(courseId: number) {
     await this.ensureCourseExists(courseId);
 
-    const [modules, instructors] = await Promise.all([
+    const [modules, instructors, courseRecord] = await Promise.all([
       this.prisma.course_module.findMany({
         where: { course_id: courseId },
         orderBy: { order: 'asc' },
@@ -50,6 +54,10 @@ export class CourseStructureService {
         },
       }),
       this.instructorService.listQualifiedInstructorOptions(['course-lessons']),
+      this.prisma.course.findUnique({
+        where: { id: courseId },
+        select: { id: true, slug: true, title: true, description: true },
+      }),
     ]);
 
     const sessoes = modules.map((module, index) => ({
@@ -108,6 +116,14 @@ export class CourseStructureService {
         id: instructor.id,
         name: instructor.name,
       })),
+      curso: courseRecord
+        ? {
+            id: String(courseRecord.id),
+            slug: courseRecord.slug ?? '',
+            titulo: courseRecord.title,
+            descricao: courseRecord.description ?? '',
+          }
+        : null,
     };
   }
 
@@ -281,8 +297,379 @@ export class CourseStructureService {
     return { success: true };
   }
 
-  private async syncLessonRelations(
+  async reorderSessions(courseId: number, dto: ReorderSessionsDto) {
+    await this.ensureCourseExists(courseId);
+
+    // Validate that all provided IDs belong to the course
+    const existing = await this.prisma.course_module.findMany({
+      where: { course_id: courseId },
+      select: { id: true },
+    });
+    const existingIds = new Set(existing.map((m) => m.id));
+    for (const id of dto.sessionIds) {
+      if (!existingIds.has(id)) {
+        throw new BadRequestException(`Session ${id} does not belong to course ${courseId}`);
+      }
+    }
+
+    await this.prisma.$transaction(
+      dto.sessionIds.map((id, index) =>
+        this.prisma.course_module.update({
+          where: { id },
+          data: { order: index + 1 },
+        }),
+      ),
+    );
+
+    return { success: true };
+  }
+
+  async reorderLessons(courseId: number, sessionId: number, dto: ReorderLessonsDto) {
+    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 existing = await this.prisma.course_lesson.findMany({
+      where: { course_module_id: sessionId },
+      select: { id: true },
+    });
+    const existingIds = new Set(existing.map((l) => l.id));
+    for (const id of dto.lessonIds) {
+      if (!existingIds.has(id)) {
+        throw new BadRequestException(`Lesson ${id} does not belong to session ${sessionId}`);
+      }
+    }
+
+    await this.prisma.$transaction(
+      dto.lessonIds.map((id, index) =>
+        this.prisma.course_lesson.update({
+          where: { id },
+          data: { order: index + 1 },
+        }),
+      ),
+    );
+
+    return { success: true };
+  }
+
+  async moveLesson(
+    courseId: number,
+    sessionId: number,
     lessonId: number,
+    dto: MoveLessonDto,
+  ) {
+    // Ensure the lesson belongs to the source session
+    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');
+    }
+
+    // Ensure the target session belongs to the same course
+    const targetModule = await this.prisma.course_module.findFirst({
+      where: { id: dto.toSessionId, course_id: courseId },
+    });
+
+    if (!targetModule) {
+      throw new NotFoundException('Target session not found for this course');
+    }
+
+    if (dto.toSessionId === sessionId) {
+      // Same session — just reorder
+      const siblings = await this.prisma.course_lesson.findMany({
+        where: { course_module_id: sessionId, id: { not: lessonId } },
+        orderBy: { order: 'asc' },
+        select: { id: true },
+      });
+      const insertAt = Math.min(dto.toIndex ?? siblings.length, siblings.length);
+      const orderedIds = [
+        ...siblings.slice(0, insertAt).map((l) => l.id),
+        lessonId,
+        ...siblings.slice(insertAt).map((l) => l.id),
+      ];
+      await this.prisma.$transaction(
+        orderedIds.map((id, index) =>
+          this.prisma.course_lesson.update({
+            where: { id },
+            data: { order: index + 1 },
+          }),
+        ),
+      );
+    } else {
+      // Move to a different session
+      const siblings = await this.prisma.course_lesson.findMany({
+        where: { course_module_id: dto.toSessionId },
+        orderBy: { order: 'asc' },
+        select: { id: true },
+      });
+      const insertAt = Math.min(dto.toIndex ?? siblings.length, siblings.length);
+      const orderedIds = [
+        ...siblings.slice(0, insertAt).map((l) => l.id),
+        lessonId,
+        ...siblings.slice(insertAt).map((l) => l.id),
+      ];
+
+      await this.prisma.$transaction([
+        this.prisma.course_lesson.update({
+          where: { id: lessonId },
+          data: { course_module_id: dto.toSessionId },
+        }),
+        ...orderedIds.map((id, index) =>
+          this.prisma.course_lesson.update({
+            where: { id },
+            data: { order: index + 1 },
+          }),
+        ),
+      ]);
+    }
+
+    return { success: true };
+  }
+
+  async duplicateSession(courseId: number, sessionId: number) {
+    const sourceModule = await this.prisma.course_module.findFirst({
+      where: { id: sessionId, course_id: courseId },
+      include: {
+        course_lesson: {
+          orderBy: { order: 'asc' },
+          include: {
+            course_lesson_file: true,
+            course_lesson_question: true,
+            course_lesson_instructor: true,
+          },
+        },
+      },
+    });
+
+    if (!sourceModule) {
+      throw new NotFoundException('Session not found for this course');
+    }
+
+    const nextOrder = await this.nextModuleOrder(courseId);
+
+    const newModule = await this.prisma.course_module.create({
+      data: {
+        course_id: courseId,
+        title: `Cópia de ${sourceModule.title}`,
+        description: sourceModule.description,
+        duration_minutes: sourceModule.duration_minutes,
+        order: nextOrder,
+      },
+    });
+
+    const newLessons = [];
+    for (const lesson of sourceModule.course_lesson) {
+      const lessonOrder = await this.nextLessonOrder(newModule.id);
+      const newLesson = await this.prisma.course_lesson.create({
+        data: {
+          course_module_id: newModule.id,
+          title: lesson.title,
+          type: lesson.type,
+          description: lesson.description,
+          duration_seconds: lesson.duration_seconds,
+          content: lesson.content,
+          order: lessonOrder,
+        },
+      });
+
+      if (lesson.course_lesson_file.length > 0) {
+        await this.prisma.course_lesson_file.createMany({
+          data: lesson.course_lesson_file.map((f) => ({
+            course_lesson_id: newLesson.id,
+            title: f.title,
+            file_id: f.file_id,
+          })),
+        });
+      }
+
+      if (lesson.course_lesson_instructor.length > 0) {
+        await this.prisma.course_lesson_instructor.createMany({
+          data: lesson.course_lesson_instructor.map((i) => ({
+            course_lesson_id: newLesson.id,
+            instructor_id: i.instructor_id,
+            role: i.role,
+          })),
+        });
+      }
+
+      if (lesson.course_lesson_question.length > 0) {
+        await this.prisma.course_lesson_question.createMany({
+          data: lesson.course_lesson_question.map((q) => ({
+            course_lesson_id: newLesson.id,
+            question_id: q.question_id,
+            order: q.order,
+          })),
+        });
+      }
+
+      newLessons.push(await this.getLessonById(newLesson.id));
+    }
+
+    return {
+      session: {
+        id: String(newModule.id),
+        codigo: this.formatCode('S', newModule.order ?? nextOrder),
+        titulo: newModule.title,
+        duracao: newModule.duration_minutes ?? 0,
+        collapsed: false,
+      },
+      lessons: newLessons,
+    };
+  }
+
+  async duplicateLesson(courseId: number, sessionId: number, lessonId: number) {
+    const sourceLesson = await this.prisma.course_lesson.findFirst({
+      where: {
+        id: lessonId,
+        course_module_id: sessionId,
+        course_module: { course_id: courseId },
+      },
+      include: {
+        course_lesson_file: true,
+        course_lesson_question: true,
+        course_lesson_instructor: true,
+      },
+    });
+
+    if (!sourceLesson) {
+      throw new NotFoundException('Lesson not found for this session');
+    }
+
+    const nextOrder = await this.nextLessonOrder(sessionId);
+
+    const newLesson = await this.prisma.course_lesson.create({
+      data: {
+        course_module_id: sessionId,
+        title: `Cópia de ${sourceLesson.title}`,
+        type: sourceLesson.type,
+        description: sourceLesson.description,
+        duration_seconds: sourceLesson.duration_seconds,
+        content: sourceLesson.content,
+        order: nextOrder,
+      },
+    });
+
+    if (sourceLesson.course_lesson_file.length > 0) {
+      await this.prisma.course_lesson_file.createMany({
+        data: sourceLesson.course_lesson_file.map((f) => ({
+          course_lesson_id: newLesson.id,
+          title: f.title,
+          file_id: f.file_id,
+        })),
+      });
+    }
+
+    if (sourceLesson.course_lesson_instructor.length > 0) {
+      await this.prisma.course_lesson_instructor.createMany({
+        data: sourceLesson.course_lesson_instructor.map((i) => ({
+          course_lesson_id: newLesson.id,
+          instructor_id: i.instructor_id,
+          role: i.role,
+        })),
+      });
+    }
+
+    if (sourceLesson.course_lesson_question.length > 0) {
+      await this.prisma.course_lesson_question.createMany({
+        data: sourceLesson.course_lesson_question.map((q) => ({
+          course_lesson_id: newLesson.id,
+          question_id: q.question_id,
+          order: q.order,
+        })),
+      });
+    }
+
+    return this.getLessonById(newLesson.id);
+  }
+
+  async pasteLessons(courseId: number, targetSessionId: number, dto: PasteLessonsDto) {
+    const targetModule = await this.prisma.course_module.findFirst({
+      where: { id: targetSessionId, course_id: courseId },
+    });
+
+    if (!targetModule) {
+      throw new NotFoundException('Target session not found for this course');
+    }
+
+    const sourceLessons = await this.prisma.course_lesson.findMany({
+      where: {
+        id: { in: dto.lessonIds },
+        course_module: { course_id: courseId },
+      },
+      orderBy: { order: 'asc' },
+      include: {
+        course_lesson_file: true,
+        course_lesson_question: true,
+        course_lesson_instructor: true,
+      },
+    });
+
+    if (sourceLessons.length !== dto.lessonIds.length) {
+      throw new BadRequestException('Some lessons do not belong to this course');
+    }
+
+    const result = [];
+    for (const lesson of sourceLessons) {
+      const lessonOrder = await this.nextLessonOrder(targetSessionId);
+      const newLesson = await this.prisma.course_lesson.create({
+        data: {
+          course_module_id: targetSessionId,
+          title: `Cópia de ${lesson.title}`,
+          type: lesson.type,
+          description: lesson.description,
+          duration_seconds: lesson.duration_seconds,
+          content: lesson.content,
+          order: lessonOrder,
+        },
+      });
+
+      if (lesson.course_lesson_file.length > 0) {
+        await this.prisma.course_lesson_file.createMany({
+          data: lesson.course_lesson_file.map((f) => ({
+            course_lesson_id: newLesson.id,
+            title: f.title,
+            file_id: f.file_id,
+          })),
+        });
+      }
+
+      if (lesson.course_lesson_instructor.length > 0) {
+        await this.prisma.course_lesson_instructor.createMany({
+          data: lesson.course_lesson_instructor.map((i) => ({
+            course_lesson_id: newLesson.id,
+            instructor_id: i.instructor_id,
+            role: i.role,
+          })),
+        });
+      }
+
+      if (lesson.course_lesson_question.length > 0) {
+        await this.prisma.course_lesson_question.createMany({
+          data: lesson.course_lesson_question.map((q) => ({
+            course_lesson_id: newLesson.id,
+            question_id: q.question_id,
+            order: q.order,
+          })),
+        });
+      }
+
+      result.push(await this.getLessonById(newLesson.id));
+    }
+
+    return { lessons: result };
+  }
+
+  private async syncLessonRelations(    lessonId: number,
     dto: Partial<
       Pick<
       CreateCourseStructureLessonDto,