@hed-hog/lms 0.0.364 → 0.0.366

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

@@ -0,0 +1,346 @@
+import { FileService } from '@hed-hog/core';
+import { PrismaService } from '@hed-hog/api-prisma';
+import {
+  forwardRef,
+  Inject,
+  Injectable,
+  Logger,
+  NotFoundException,
+  UnauthorizedException,
+} from '@nestjs/common';
+import { JwtService } from '@nestjs/jwt';
+import type { Request, Response } from 'express';
+
+@Injectable()
+export class PlatformaVideoService {
+  private readonly logger = new Logger(PlatformaVideoService.name);
+  constructor(
+    @Inject(forwardRef(() => PrismaService))
+    private readonly prisma: PrismaService,
+    @Inject(forwardRef(() => FileService))
+    private readonly fileService: FileService,
+    @Inject(forwardRef(() => JwtService))
+    private readonly jwtService: JwtService,
+  ) {}
+
+  async getVideoOptions(lessonId: number) {
+    const lesson = await this.prisma.course_lesson.findFirst({
+      where: { id: lessonId, published: true },
+      select: {
+        id: true,
+        course_lesson_file: {
+          where: { file_id: { not: null } },
+          select: { id: true, title: true, type: true, file: { select: { id: true } } },
+        },
+      },
+    });
+
+    if (!lesson) throw new NotFoundException('Lesson not found');
+
+    // HLS takes priority over legacy MP4 profiles
+    const hlsFile = lesson.course_lesson_file.find((f) => f.type === 'video_hls' && f.file?.id);
+    if (hlsFile) {
+      return [{ type: 'video_hls', label: 'HLS', fileId: hlsFile.file!.id! }];
+    }
+
+    const videoFiles = lesson.course_lesson_file.filter(
+      (f) => f.type === 'video_original' || f.type?.startsWith('video_profile:'),
+    );
+
+    if (videoFiles.length === 0) return [];
+
+    return videoFiles
+      .filter((f) => f.file?.id)
+      .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! };
+      });
+  }
+
+  async generateVideoToken(lessonId: number, quality?: string) {
+    const options = await this.getVideoOptions(lessonId);
+    if (options.length === 0) throw new NotFoundException('No video available for this lesson');
+
+    const selected = quality
+      ? (options.find((o) => o.type === quality) ?? options[0])
+      : options[0];
+
+    const token = this.jwtService.sign(
+      { fileId: selected.fileId, lessonId },
+      { secret: process.env.JWT_SECRET, expiresIn: '4h' },
+    );
+
+    return { token, label: selected.label, type: selected.type, expiresIn: 14400 };
+  }
+
+  async streamVideo(token: string, req: Request, res: Response) {
+    let fileId: number;
+    try {
+      const payload = this.jwtService.verify<{ fileId: number }>(token, {
+        secret: process.env.JWT_SECRET,
+      });
+      fileId = payload.fileId;
+    } catch {
+      throw new UnauthorizedException('Invalid or expired video token');
+    }
+
+    const rangeHeader = req.headers['range'];
+    let start: number | undefined;
+    let end: number | undefined;
+
+    if (rangeHeader) {
+      const match = rangeHeader.match(/bytes=(\d+)-(\d*)/);
+      if (match) {
+        start = parseInt(match[1], 10);
+        end = match[2] ? parseInt(match[2], 10) : undefined;
+      }
+    }
+
+    const result = await this.fileService.openReadStreamWithRange(fileId, start, end);
+    if (!result) throw new NotFoundException('Video file not found');
+
+    const { stream, totalSize, start: resolvedStart, end: resolvedEnd, contentLength, mimetype } = result;
+
+    const headers: Record<string, string | number> = {
+      'Content-Type': mimetype,
+      'Content-Disposition': 'inline',
+      'Accept-Ranges': 'bytes',
+      'Cache-Control': 'no-store',
+    };
+
+    if (start !== undefined) {
+      headers['Content-Range'] = `bytes ${resolvedStart}-${resolvedEnd ?? totalSize - 1}/${totalSize || '*'}`;
+      headers['Content-Length'] = contentLength;
+      res.writeHead(206, headers);
+    } else {
+      if (totalSize > 0) headers['Content-Length'] = totalSize;
+      res.writeHead(200, headers);
+    }
+
+    stream.pipe(res);
+  }
+
+  // ---------------------------------------------------------------------------
+  // HLS endpoints
+  // ---------------------------------------------------------------------------
+
+  async generateHlsToken(lessonId: number) {
+    const lesson = await this.prisma.course_lesson.findFirst({
+      where: { id: lessonId, published: true },
+      select: {
+        id: true,
+        course_lesson_file: {
+          where: { type: 'video_hls', file_id: { not: null } },
+          select: { id: true },
+        },
+      },
+    });
+
+    if (!lesson) throw new NotFoundException('Lesson not found');
+    if (lesson.course_lesson_file.length === 0) throw new NotFoundException('No HLS stream available for this lesson');
+
+    const token = this.jwtService.sign(
+      { lessonId },
+      { secret: process.env.JWT_SECRET, expiresIn: '4h' },
+    );
+
+    return { token, expiresIn: 14400 };
+  }
+
+  private verifyHlsToken(token: string): { lessonId: number } {
+    try {
+      return this.jwtService.verify<{ lessonId: number }>(token, {
+        secret: process.env.JWT_SECRET,
+      });
+    } catch {
+      throw new UnauthorizedException('Invalid or expired HLS token');
+    }
+  }
+
+  async serveHlsMasterManifest(token: string, req: Request, res: Response) {
+    const { lessonId } = this.verifyHlsToken(token);
+
+    const manifestFile = await (this.prisma as any).file.findFirst({
+      where: {
+        location: `lms/lessons/hls/${lessonId}`,
+        filename: 'master.m3u8',
+      },
+      select: { id: true },
+    });
+
+    if (!manifestFile) throw new NotFoundException('HLS master manifest not found');
+
+    const { stream } = await this.fileService.openReadStreamById(manifestFile.id);
+
+    const chunks: Buffer[] = [];
+    await new Promise<void>((resolve, reject) => {
+      stream.on('data', (chunk: Buffer) => chunks.push(chunk));
+      stream.on('end', resolve);
+      stream.on('error', reject);
+    });
+
+    const baseUrl = `${req.protocol}://${req.get('host')}`;
+    const content = Buffer.concat(chunks).toString('utf8');
+
+    // Rewrite relative variant playlist paths to absolute authenticated URLs
+    const rewritten = content.replace(
+      /^(stream_\d+\/playlist\.m3u8)$/gm,
+      (_, variantPath) => `${baseUrl}/lms/platforma/hls/${token}/${variantPath}`,
+    );
+
+    res.set({
+      'Content-Type': 'application/x-mpegURL',
+      'Cache-Control': 'no-store',
+      'Access-Control-Allow-Origin': '*',
+    });
+    res.send(rewritten);
+  }
+
+  async serveHlsVariantPlaylist(token: string, variant: string, req: Request, res: Response) {
+    const { lessonId } = this.verifyHlsToken(token);
+
+    const playlistFile = await (this.prisma as any).file.findFirst({
+      where: {
+        location: `lms/lessons/hls/${lessonId}/${variant}`,
+        filename: 'playlist.m3u8',
+      },
+      select: { id: true },
+    });
+
+    if (!playlistFile) throw new NotFoundException('HLS variant playlist not found');
+
+    const { stream } = await this.fileService.openReadStreamById(playlistFile.id);
+
+    const chunks: Buffer[] = [];
+    await new Promise<void>((resolve, reject) => {
+      stream.on('data', (chunk: Buffer) => chunks.push(chunk));
+      stream.on('end', resolve);
+      stream.on('error', reject);
+    });
+
+    const baseUrl = `${req.protocol}://${req.get('host')}`;
+    const content = Buffer.concat(chunks).toString('utf8');
+
+    // Rewrite relative segment paths to absolute authenticated URLs
+    const rewritten = content.replace(
+      /^(seg\d+\.ts)$/gm,
+      (_, segName) => `${baseUrl}/lms/platforma/hls/${token}/${variant}/${segName}`,
+    );
+
+    res.set({
+      'Content-Type': 'application/x-mpegURL',
+      'Cache-Control': 'no-store',
+      'Access-Control-Allow-Origin': '*',
+    });
+    res.send(rewritten);
+  }
+
+  async serveHlsSegment(token: string, variant: string, segment: string, res: Response) {
+    const { lessonId } = this.verifyHlsToken(token);
+
+    if (!/^seg\d+\.ts$/.test(segment)) {
+      throw new NotFoundException('Invalid segment name');
+    }
+
+    const segmentFile = await (this.prisma as any).file.findFirst({
+      where: {
+        location: `lms/lessons/hls/${lessonId}/${variant}`,
+        filename: segment,
+      },
+      select: { id: true },
+    });
+
+    if (!segmentFile) throw new NotFoundException('HLS segment not found');
+
+    const { stream } = await this.fileService.openReadStreamById(segmentFile.id);
+
+    res.set({
+      'Content-Type': 'video/MP2T',
+      'Cache-Control': 'public, max-age=31536000, immutable',
+      'Access-Control-Allow-Origin': '*',
+    });
+
+    stream.pipe(res);
+  }
+
+  // ---------------------------------------------------------------------------
+  // Subtitle (VTT) endpoints
+  // ---------------------------------------------------------------------------
+
+  async generateSubtitlesToken(lessonId: number) {
+    const lesson = await this.prisma.course_lesson.findFirst({
+      where: { id: lessonId, published: true },
+      select: { id: true },
+    });
+
+    if (!lesson) throw new NotFoundException('Lesson not found');
+
+    const count = await (this.prisma as any).course_lesson_transcription_segment.count({
+      where: { course_lesson_id: lessonId },
+    });
+
+    if (count === 0) throw new NotFoundException('No subtitles available for this lesson');
+
+    const token = this.jwtService.sign(
+      { lessonId, type: 'subtitles' },
+      { secret: process.env.JWT_SECRET, expiresIn: '4h' },
+    );
+
+    return { token, expiresIn: 14400 };
+  }
+
+  async serveSubtitles(token: string, res: Response) {
+    let lessonId: number;
+    try {
+      const payload = this.jwtService.verify<{ lessonId: number; type: string }>(token, {
+        secret: process.env.JWT_SECRET,
+      });
+      if (payload.type !== 'subtitles') throw new Error('Wrong token type');
+      lessonId = payload.lessonId;
+    } catch {
+      throw new UnauthorizedException('Invalid or expired subtitles token');
+    }
+
+    const segments = await (this.prisma as any).course_lesson_transcription_segment.findMany({
+      where: { course_lesson_id: lessonId },
+      orderBy: { start_seconds: 'asc' },
+      select: { start_seconds: true, end_seconds: true, text: true },
+    });
+
+    const vtt = this.buildVtt(segments);
+
+    res.set({
+      'Content-Type': 'text/vtt; charset=utf-8',
+      'Cache-Control': 'no-store',
+      'Access-Control-Allow-Origin': '*',
+    });
+    res.send(vtt);
+  }
+
+  private secondsToVttTime(seconds: number): string {
+    const s = Number(seconds);
+    const h = Math.floor(s / 3600);
+    const m = Math.floor((s % 3600) / 60);
+    const sec = Math.floor(s % 60);
+    const ms = Math.round((s % 1) * 1000);
+    return `${String(h).padStart(2, '0')}:${String(m).padStart(2, '0')}:${String(sec).padStart(2, '0')}.${String(ms).padStart(3, '0')}`;
+  }
+
+  private buildVtt(segments: { start_seconds: any; end_seconds: any; text: string }[]): string {
+    if (segments.length === 0) return 'WEBVTT\n';
+    const cues = segments.map((seg, i) => {
+      const start = this.secondsToVttTime(seg.start_seconds);
+      const end = this.secondsToVttTime(seg.end_seconds);
+      return `${i + 1}\n${start} --> ${end}\n${seg.text}`;
+    });
+    return `WEBVTT\n\n${cues.join('\n\n')}\n`;
+  }
+}

package/src/platforma/platforma.controller.ts

@@ -1,12 +1,18 @@
-import { NoRole, User } from '@hed-hog/api';
+import { NoRole, Public, User } from '@hed-hog/api';
 import { NotificationService } from '@hed-hog/core';
 import { Body, Controller, Delete, Get, Param, ParseIntPipe, Patch, Post, Put, Query, Req, Res } from '@nestjs/common';
 import type { Request, Response } from 'express';
 import { BitcodeWalletService } from '../bitcode-wallet/bitcode-wallet.service';
 import { CreateCurrentBitcodeWalletTransactionDto } from '../bitcode-wallet/dto/create-current-bitcode-wallet-transaction.dto';
+import { EvaluationService } from '../evaluation/evaluation.service';
 import { TrainingStudentService } from '../enterprise/training/training-student.service';
+import { HeartbeatDto } from './dto/heartbeat.dto';
 import { UpdatePlatformaProfileDto } from './dto/update-profile.dto';
+import { PlatformaHeartbeatService } from './platforma-heartbeat.service';
+import { PlatformaPerformanceService } from './platforma-performance.service';
 import { PlatformaService } from './platforma.service';
+import { PlatformaSearchService } from './platforma-search.service';
+import { PlatformaVideoService } from './platforma-video.service';
 
 @NoRole()
 @Controller('lms/platforma')
@@ -16,6 +22,11 @@ export class PlataformaController {
     private readonly notificationService: NotificationService,
     private readonly platforma: PlatformaService,
     private readonly bitcodeWalletService: BitcodeWalletService,
+    private readonly platformaVideoService: PlatformaVideoService,
+    private readonly evaluationService: EvaluationService,
+    private readonly heartbeatService: PlatformaHeartbeatService,
+    private readonly performanceService: PlatformaPerformanceService,
+    private readonly searchService: PlatformaSearchService,
   ) {}
 
   @Get()
@@ -45,6 +56,109 @@ export class PlataformaController {
     });
   }
 
+  @Get('courses/:slug')
+  getCourseBySlug(@Param('slug') slug: string, @User('id') userId?: number) {
+    return this.trainingStudentService.getPublishedCourseBySlug(slug, userId);
+  }
+
+  @Get('search')
+  search(
+    @Query('q') q = '',
+    @Query('types') types?: string,
+    @Query('pageSize') pageSize?: string,
+  ) {
+    return this.searchService.search(
+      q,
+      types ? types.split(',').filter(Boolean) : [],
+      pageSize ? Math.max(1, Number(pageSize)) : 5,
+    );
+  }
+
+  @Get('lessons/:lessonId')
+  getLessonDetail(@Param('lessonId', ParseIntPipe) lessonId: number) {
+    return this.trainingStudentService.getLessonDetail(lessonId);
+  }
+
+  @Get('lessons/:lessonId/video-token')
+  getVideoToken(
+    @Param('lessonId', ParseIntPipe) lessonId: number,
+    @Query('quality') quality?: string,
+  ) {
+    return this.platformaVideoService.generateVideoToken(lessonId, quality);
+  }
+
+  @Get('lessons/:lessonId/hls-token')
+  getHlsToken(@Param('lessonId', ParseIntPipe) lessonId: number) {
+    return this.platformaVideoService.generateHlsToken(lessonId);
+  }
+
+  @Public()
+  @Get('video/:token')
+  streamVideo(@Param('token') token: string, @Req() req: Request, @Res() res: Response) {
+    return this.platformaVideoService.streamVideo(token, req, res);
+  }
+
+  @Public()
+  @Get('hls/:token/master.m3u8')
+  serveHlsMaster(@Param('token') token: string, @Req() req: Request, @Res() res: Response) {
+    return this.platformaVideoService.serveHlsMasterManifest(token, req, res);
+  }
+
+  @Public()
+  @Get('hls/:token/:variant/playlist.m3u8')
+  serveHlsVariant(
+    @Param('token') token: string,
+    @Param('variant') variant: string,
+    @Req() req: Request,
+    @Res() res: Response,
+  ) {
+    return this.platformaVideoService.serveHlsVariantPlaylist(token, variant, req, res);
+  }
+
+  @Public()
+  @Get('hls/:token/:variant/:segment')
+  serveHlsSegment(
+    @Param('token') token: string,
+    @Param('variant') variant: string,
+    @Param('segment') segment: string,
+    @Res() res: Response,
+  ) {
+    return this.platformaVideoService.serveHlsSegment(token, variant, segment, res);
+  }
+
+  @Get('lessons/:lessonId/subtitles-token')
+  getSubtitlesToken(@Param('lessonId', ParseIntPipe) lessonId: number) {
+    return this.platformaVideoService.generateSubtitlesToken(lessonId);
+  }
+
+  @Get('lessons/:lessonId/evaluation-topics')
+  getCourseLessonEvaluationTopics(@Param('lessonId', ParseIntPipe) lessonId: number) {
+    return this.evaluationService.getCourseLessonTopics(lessonId);
+  }
+
+  @Get('lessons/:lessonId/my-evaluation')
+  getMyLessonEvaluation(
+    @Param('lessonId', ParseIntPipe) lessonId: number,
+    @User('id') userId: number,
+  ) {
+    return this.evaluationService.getMyLessonRatings(lessonId, userId);
+  }
+
+  @Post('lessons/:lessonId/evaluate')
+  submitLessonEvaluation(
+    @Param('lessonId', ParseIntPipe) lessonId: number,
+    @User('id') userId: number,
+    @Body() body: { ratings: Array<{ topicId: number; score: number; comment?: string }> },
+  ) {
+    return this.evaluationService.submitLessonRatings(lessonId, userId, body.ratings ?? []);
+  }
+
+  @Public()
+  @Get('subtitles/:token/captions.vtt')
+  serveSubtitles(@Param('token') token: string, @Res() res: Response) {
+    return this.platformaVideoService.serveSubtitles(token, res);
+  }
+
   @Get('notifications')
   listNotifications(
     @User('id') userId: number,
@@ -132,6 +246,28 @@ export class PlataformaController {
     return this.bitcodeWalletService.createCurrentUserTransaction(userId, dto);
   }
 
+  @Get('performance/summary')
+  getPerformanceSummary(
+    @User('id') userId: number,
+    @Query('period') period?: string,
+  ) {
+    return this.performanceService.getSummary(userId, period ?? '30d');
+  }
+
+  @Post('heartbeat')
+  heartbeat(
+    @User('id') userId: number,
+    @Body() dto: HeartbeatDto,
+    @Req() req: Request,
+  ) {
+    const ip =
+      (req.headers['x-forwarded-for'] as string)?.split(',')[0]?.trim() ??
+      req.socket?.remoteAddress ??
+      '';
+    const userAgent = (req.headers['user-agent'] as string) ?? '';
+    return this.heartbeatService.enqueue(userId, ip, userAgent, dto);
+  }
+
   @Get('profile')
   getProfile(@User('id') userId: number) {
     return this.platforma.getProfile(userId);