@hed-hog/lms 0.0.364 → 0.0.365

package/src/enterprise/training/training-student.service.ts

@@ -138,7 +138,7 @@ export class TrainingStudentService {
             orderBy: [{ is_primary: 'desc' }, { order: 'asc' }],
             select: {
               image_type: { select: { slug: true } },
-              file: { select: { location: true } },
+              file: { select: { id: true } },
             },
           },
           course_module: {
@@ -196,7 +196,8 @@ export class TrainingStudentService {
           durationHours: row.duration_hours ?? 0,
           level: row.level,
           lessons,
-          image: banner?.file?.location ?? logo?.file?.location ?? null,
+          image: banner?.file?.id ? `/file/open/${banner.file.id}` : logo?.file?.id ? `/file/open/${logo.file.id}` : null,
+          logoImage: logo?.file?.id ? `/file/open/${logo.file.id}` : null,
           categoryKey: categorySlug,
           categoryLabel: this.formatCategoryLabel(categorySlug),
           enrollmentCount: row._count?.course_enrollment ?? 0,
@@ -214,6 +215,224 @@ export class TrainingStudentService {
     };
   }
 
+  async getPublishedCourseBySlug(slug: string, userId?: number) {
+    const row = await this.prisma.course.findFirst({
+      where: { slug, status: 'published', is_listed: true },
+      select: {
+        id: true,
+        slug: true,
+        title: true,
+        description: true,
+        duration_hours: true,
+        level: true,
+        primary_color: true,
+        course_category: {
+          select: { category: { select: { slug: true } } },
+        },
+        course_image: {
+          where: { image_type: { slug: { in: ['course-banner', 'course-logo'] } } },
+          orderBy: [{ is_primary: 'desc' }, { order: 'asc' }],
+          select: {
+            image_type: { select: { slug: true } },
+            file: { select: { id: true } },
+          },
+        },
+        course_module: {
+          orderBy: { order: 'asc' },
+          select: {
+            id: true,
+            title: true,
+            duration_minutes: true,
+            course_lesson: {
+              where: { published: true },
+              orderBy: { order: 'asc' },
+              select: {
+                id: true,
+                title: true,
+                type: true,
+                duration_seconds: true,
+                course_lesson_file: {
+                  where: {
+                    is_public: true,
+                    file_id: { not: null },
+                    OR: [{ type: null }, { type: { not: { startsWith: 'video' } } }],
+                  },
+                  select: { id: true },
+                  take: 1,
+                },
+                course_lesson_instructor: {
+                  take: 1,
+                  select: {
+                    instructor: {
+                      select: {
+                        person: {
+                          select: {
+                            name: true,
+                            file: { select: { id: true } },
+                          },
+                        },
+                      },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        },
+      },
+    });
+
+    if (!row) throw new NotFoundException(`Course "${slug}" not found`);
+
+    const banner = row.course_image.find((img) => img.image_type?.slug === 'course-banner');
+    const logo = row.course_image.find((img) => img.image_type?.slug === 'course-logo');
+    const categorySlug = row.course_category[0]?.category?.slug ?? null;
+
+    const firstInstructor = row.course_module
+      .flatMap((m) => m.course_lesson)
+      .flatMap((l) => l.course_lesson_instructor)
+      .find((cli) => cli.instructor?.person);
+
+    const instructor = firstInstructor?.instructor?.person
+      ? {
+          name: firstInstructor.instructor.person.name,
+          avatar: firstInstructor.instructor.person.file?.id ? `/file/open/${firstInstructor.instructor.person.file.id}` : null,
+        }
+      : null;
+
+    let completedLessonIds: number[] = [];
+    let progressPercent = 0;
+
+    if (userId) {
+      const personUser = await this.prisma.person_user.findFirst({
+        where: { user_id: userId },
+        select: { person_id: true },
+      });
+      if (personUser) {
+        const enrollment = await this.prisma.course_enrollment.findFirst({
+          where: { person_id: personUser.person_id, course_id: row.id, status: { not: 'cancelled' } },
+          select: { id: true, progress_percent: true },
+        });
+        if (enrollment) {
+          progressPercent = enrollment.progress_percent ?? 0;
+          const completedRows = await this.prisma.course_lesson_progress.findMany({
+            where: { course_enrollment_id: enrollment.id, status: 'completed' },
+            select: { course_lesson_id: true },
+          });
+          completedLessonIds = completedRows.map((r) => r.course_lesson_id);
+        }
+      }
+    }
+
+    return {
+      id: row.id,
+      slug: row.slug,
+      title: row.title,
+      description: row.description ?? '',
+      durationHours: row.duration_hours ?? 0,
+      level: row.level,
+      image: banner?.file?.id ? `/file/open/${banner.file.id}` : logo?.file?.id ? `/file/open/${logo.file.id}` : null,
+      logoImage: logo?.file?.id ? `/file/open/${logo.file.id}` : null,
+      primaryColor: row.primary_color ?? null,
+      categoryKey: categorySlug,
+      categoryLabel: this.formatCategoryLabel(categorySlug),
+      completedLessonIds,
+      progressPercent,
+      modules: row.course_module.map((m) => ({
+        id: m.id,
+        title: m.title,
+        lessonCount: m.course_lesson.length,
+        durationHours: (m.duration_minutes ?? 0) / 60,
+        lessons: m.course_lesson.map((l) => ({
+          id: l.id,
+          title: l.title,
+          type: l.type,
+          durationSeconds: l.duration_seconds,
+          hasResources: l.course_lesson_file.length > 0,
+        })),
+      })),
+      instructor,
+    };
+  }
+
+  async getLessonDetail(lessonId: number) {
+    const lesson = await this.prisma.course_lesson.findFirst({
+      where: { id: lessonId, published: true },
+      select: {
+        id: true,
+        title: true,
+        description: true,
+        type: true,
+        content: true,
+        duration_seconds: true,
+        course_lesson_file: {
+          select: {
+            id: true,
+            title: true,
+            type: true,
+            is_public: true,
+            file: { select: { id: true } },
+          },
+        },
+      },
+    });
+
+    if (!lesson) throw new NotFoundException('Lesson not found');
+
+    const resources = lesson.course_lesson_file.filter(
+      (f) => f.file?.id && f.is_public && !f.type?.startsWith('video'),
+    );
+
+    // HLS takes priority: if a video_hls file exists, use it exclusively
+    const hlsFile = lesson.course_lesson_file.find((f) => f.file?.id && f.type === 'video_hls');
+    if (hlsFile) {
+      return {
+        id: lesson.id,
+        title: lesson.title,
+        description: lesson.description,
+        type: lesson.type,
+        content: lesson.content,
+        durationSeconds: lesson.duration_seconds,
+        videos: [{ type: 'video_hls', label: 'HLS', fileId: hlsFile.file!.id! }],
+        resources: resources.map((r) => ({
+          id: r.id,
+          title: r.title,
+          url: r.file?.id ? `/file/open/${r.file.id}` : null,
+        })),
+      };
+    }
+
+    // Legacy MP4 fallback
+    const videoFiles = lesson.course_lesson_file.filter(
+      (f) => f.file?.id && (f.type === 'video_original' || f.type?.startsWith('video_profile:')),
+    );
+
+    return {
+      id: lesson.id,
+      title: lesson.title,
+      description: lesson.description,
+      type: lesson.type,
+      content: lesson.content,
+      durationSeconds: lesson.duration_seconds,
+      videos: videoFiles.map((f) => {
+        const profileMatch = f.type?.match(/^video_profile:(\d+)$/);
+        const profileId = profileMatch ? Number(profileMatch[1]) : null;
+        const label =
+          f.type === 'video_original'
+            ? 'Original'
+            : profileId !== null
+              ? f.title || `Perfil ${profileId}`
+              : f.title || f.type || 'Vídeo';
+        return { type: f.type!, label, fileId: f.file!.id! };
+      }),
+      resources: resources.map((r) => ({
+        id: r.id,
+        title: r.title,
+        url: r.file?.id ? `/file/open/${r.file.id}` : null,
+      })),
+    };
+  }
+
   async getDashboard(userId: number, enterpriseId?: number) {
     const personUser = await this.prisma.person_user.findFirst({
       where: { user_id: userId },

package/src/evaluation/evaluation.service.ts

@@ -547,4 +547,127 @@ export class EvaluationService {
     await this.prisma.evaluation_topic.delete({ where: { id } });
     return { deleted: true };
   }
+
+  async getCourseLessonTopics(lessonId: number) {
+    const topics = await this.prisma.evaluation_topic.findMany({
+      where: {
+        target_type: 'course_lesson',
+        is_active: true,
+        OR: [
+          { course_lesson_id: lessonId },
+          { course_lesson_id: null },
+        ],
+      },
+      orderBy: { order: 'asc' },
+      select: { id: true, name: true, description: true, order: true },
+    });
+    return topics.map((t) => ({
+      id: t.id,
+      name: t.name,
+      description: t.description ?? null,
+      order: t.order,
+    }));
+  }
+
+  async getMyLessonRatings(lessonId: number, userId: number) {
+    const personUser = await this.prisma.person_user.findFirst({
+      where: { user_id: userId },
+      select: { person_id: true },
+    });
+    if (!personUser) return [];
+
+    const topics = await this.prisma.evaluation_topic.findMany({
+      where: {
+        target_type: 'course_lesson',
+        is_active: true,
+        OR: [{ course_lesson_id: lessonId }, { course_lesson_id: null }],
+      },
+      select: { id: true },
+    });
+    const topicIds = topics.map((t) => t.id);
+    if (topicIds.length === 0) return [];
+
+    const ratings = await this.prisma.evaluation_rating.findMany({
+      where: {
+        evaluation_topic_id: { in: topicIds },
+        evaluator_id: personUser.person_id,
+      },
+      select: { evaluation_topic_id: true, score: true, comment: true },
+    });
+
+    return ratings.map((r) => ({
+      topicId: r.evaluation_topic_id,
+      score: Number(r.score),
+      comment: r.comment ?? null,
+    }));
+  }
+
+  async submitLessonRatings(
+    lessonId: number,
+    userId: number,
+    ratings: Array<{ topicId: number; score: number; comment?: string }>,
+  ) {
+    if (ratings.length === 0) return { saved: 0 };
+
+    const topicIds = ratings.map((r) => r.topicId);
+    const validTopics = await this.prisma.evaluation_topic.findMany({
+      where: {
+        id: { in: topicIds },
+        target_type: 'course_lesson',
+        is_active: true,
+        OR: [
+          { course_lesson_id: lessonId },
+          { course_lesson_id: null },
+        ],
+      },
+      select: { id: true },
+    });
+    const validIds = new Set(validTopics.map((t) => t.id));
+
+    const personUser = await this.prisma.person_user.findFirst({
+      where: { user_id: userId },
+      select: { person_id: true },
+    });
+    const personId = personUser?.person_id ?? null;
+
+    const validRatings = ratings.filter((r) => validIds.has(r.topicId));
+    if (validRatings.length === 0) return { saved: 0 };
+
+    if (personId) {
+      await this.prisma.$transaction(async (tx) => {
+        for (const r of validRatings) {
+          const existing = await tx.evaluation_rating.findFirst({
+            where: { evaluation_topic_id: r.topicId, evaluator_id: personId },
+            select: { id: true },
+          });
+          if (existing) {
+            await tx.evaluation_rating.update({
+              where: { id: existing.id },
+              data: { score: r.score, comment: r.comment ?? null },
+            });
+          } else {
+            await tx.evaluation_rating.create({
+              data: {
+                evaluation_topic_id: r.topicId,
+                evaluator_id: personId,
+                score: r.score,
+                comment: r.comment ?? null,
+              },
+            });
+          }
+        }
+      });
+    } else {
+      await this.prisma.evaluation_rating.createMany({
+        data: validRatings.map((r) => ({
+          evaluation_topic_id: r.topicId,
+          evaluator_id: null,
+          score: r.score,
+          comment: r.comment ?? null,
+        })),
+      });
+    }
+
+    return { saved: validRatings.length };
+  }
 }

package/src/exam/dto/create-standalone-question.dto.ts

@@ -0,0 +1,66 @@
+import { Type } from 'class-transformer';
+import {
+  ArrayMinSize,
+  IsArray,
+  IsBoolean,
+  IsIn,
+  IsInt,
+  IsNotEmpty,
+  IsOptional,
+  IsString,
+  MaxLength,
+  Min,
+  ValidateNested,
+} from 'class-validator';
+import {
+  EXAM_QUESTION_TYPES,
+  ExamQuestionAlternativeDto,
+  FillBlankAnswerDto,
+  MatchingPairDto,
+  type ExamQuestionType,
+} from './create-exam-question.dto';
+
+export class CreateStandaloneQuestionDto {
+  @IsInt()
+  @Min(1)
+  @IsOptional()
+  subjectId?: number;
+
+  @IsString()
+  @IsNotEmpty()
+  statement: string;
+
+  @IsString()
+  @IsOptional()
+  explanation?: string;
+
+  @IsString()
+  @IsIn(EXAM_QUESTION_TYPES)
+  @IsOptional()
+  questionType?: ExamQuestionType;
+
+  @IsInt()
+  @Min(1)
+  @IsOptional()
+  points?: number;
+
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => ExamQuestionAlternativeDto)
+  @IsOptional()
+  alternatives?: ExamQuestionAlternativeDto[];
+
+  @IsArray()
+  @ArrayMinSize(1)
+  @ValidateNested({ each: true })
+  @Type(() => FillBlankAnswerDto)
+  @IsOptional()
+  fillBlankAnswers?: FillBlankAnswerDto[];
+
+  @IsArray()
+  @ArrayMinSize(2)
+  @ValidateNested({ each: true })
+  @Type(() => MatchingPairDto)
+  @IsOptional()
+  matchingPairs?: MatchingPairDto[];
+}

package/src/exam/exam.module.ts

@@ -5,10 +5,11 @@ import { ExamAttemptService } from './exam-attempt.service';
 import { LmsExamMcpTools } from './exam.mcp-tools';
 import { ExamController } from './exam.controller';
 import { ExamService } from './exam.service';
+import { QuestionController } from './question.controller';
 
 @Module({
   imports: [forwardRef(() => PrismaModule)],
-  controllers: [ExamController, ExamAttemptController],
+  controllers: [ExamController, ExamAttemptController, QuestionController],
   providers: [ExamService, ExamAttemptService, LmsExamMcpTools],
   exports: [forwardRef(() => ExamService), forwardRef(() => ExamAttemptService)],
 })

package/src/exam/exam.service.ts

@@ -9,6 +9,7 @@ import {
     OBJECTIVE_EXAM_QUESTION_TYPES,
     type ExamQuestionType,
 } from './dto/create-exam-question.dto';
+import { CreateStandaloneQuestionDto } from './dto/create-standalone-question.dto';
 import { CreateExamDto } from './dto/create-exam.dto';
 import { CreateQuestionSubjectDto } from './dto/create-question-subject.dto';
 import { UpdateExamQuestionDto } from './dto/update-exam-question.dto';
@@ -197,6 +198,91 @@ export class ExamService {
     return this.mapExam(exam, avgScores[id] ?? 0);
   }
 
+  async listAllQuestions(search?: string, page = 1, limit = 50) {
+    const skip = (Math.max(page, 1) - 1) * limit;
+    const where = search?.trim()
+      ? { statement: { contains: search.trim(), mode: 'insensitive' as const } }
+      : {};
+
+    const [data, total] = await Promise.all([
+      this.prisma.question.findMany({
+        where,
+        skip,
+        take: limit,
+        orderBy: { id: 'desc' },
+        select: {
+          id: true,
+          question_type: true,
+          statement: true,
+          points: true,
+          question_subject: { select: { id: true, name: true } },
+        },
+      }),
+      this.prisma.question.count({ where }),
+    ]);
+
+    return {
+      total,
+      page,
+      limit,
+      data: data.map((q) => ({
+        id: q.id,
+        questionType: q.question_type,
+        statement: q.statement,
+        points: q.points,
+        subjectId: q.question_subject?.id ?? null,
+        subjectName: q.question_subject?.name ?? null,
+      })),
+    };
+  }
+
+  async createStandaloneQuestion(dto: CreateStandaloneQuestionDto) {
+    const questionType = this.resolveQuestionType(dto.questionType);
+    const alternatives = this.normalizeAlternatives(questionType, dto.alternatives, true);
+    const fillBlankAnswers = this.normalizeFillBlankAnswers(questionType, dto.fillBlankAnswers, true);
+    const matchingPairs = this.normalizeMatchingPairs(questionType, dto.matchingPairs, true);
+    const specialOptions = this.buildSpecialOptions(questionType, fillBlankAnswers, matchingPairs);
+
+    return this.prisma.$transaction(async (tx) => {
+      const question = await tx.question.create({
+        data: {
+          question_subject_id: dto.subjectId ?? null,
+          question_type: questionType,
+          statement: dto.statement,
+          explanation: dto.explanation ?? null,
+          points: dto.points ?? 1,
+        },
+      });
+
+      const optionsToPersist =
+        alternatives.length > 0
+          ? alternatives.map((a, i) => ({
+              question_id: question.id,
+              option_text: a.text,
+              is_correct: a.isCorrect,
+              position: i,
+            }))
+          : specialOptions.map((o, i) => ({
+              question_id: question.id,
+              option_text: o.optionText,
+              is_correct: true,
+              position: i,
+            }));
+
+      if (optionsToPersist.length > 0) {
+        await tx.exam_option.createMany({ data: optionsToPersist });
+      }
+
+      return {
+        id: question.id,
+        questionType,
+        statement: question.statement,
+        points: question.points,
+        subjectId: question.question_subject_id ?? null,
+      };
+    });
+  }
+
   async listQuestions(examId: number) {
     const exam = await this.prisma.exam.findUnique({
       where: { id: examId },

package/src/exam/question.controller.ts

@@ -0,0 +1,28 @@
+import { Role } from '@hed-hog/api';
+import { Body, Controller, Get, Post, Query } from '@nestjs/common';
+import { CreateStandaloneQuestionDto } from './dto/create-standalone-question.dto';
+import { ExamService } from './exam.service';
+
+@Role()
+@Controller('lms/questions')
+export class QuestionController {
+  constructor(private readonly examService: ExamService) {}
+
+  @Get()
+  listAll(
+    @Query('search') search?: string,
+    @Query('page') page?: string,
+    @Query('limit') limit?: string,
+  ) {
+    return this.examService.listAllQuestions(
+      search,
+      page ? Number(page) : 1,
+      limit ? Number(limit) : 50,
+    );
+  }
+
+  @Post()
+  create(@Body() dto: CreateStandaloneQuestionDto) {
+    return this.examService.createStandaloneQuestion(dto);
+  }
+}