@hed-hog/lms 0.0.361 → 0.0.365

package/src/lesson-xp-map/lesson-xp-segment.service.ts

@@ -0,0 +1,229 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { Injectable, NotFoundException } from '@nestjs/common';
+import {
+  SegmentAreaDto,
+  SegmentLearningTypeDto,
+  SegmentSkillDto,
+  CreateLessonXpSegmentDto,
+} from './dto/create-lesson-xp-segment.dto';
+import { UpdateLessonXpSegmentDto } from './dto/update-lesson-xp-segment.dto';
+
+@Injectable()
+export class LessonXpSegmentService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async listByMap(mapId: number, params: { page?: number; pageSize?: number }) {
+    const page = Math.max(Number(params.page) || 1, 1);
+    const pageSize = Math.max(Number(params.pageSize) || 50, 1);
+    const offset = (page - 1) * pageSize;
+
+    const totalRow = await this.querySingle<{ total: string }>(
+      `SELECT COUNT(*)::text AS total FROM lesson_xp_segment WHERE lesson_xp_map_id = $1`,
+      [mapId],
+    );
+
+    const rows = await this.queryRows<any>(
+      `SELECT
+          s.id,
+          s.lesson_xp_map_id AS "lessonXpMapId",
+          s.start_seconds::float AS "startSeconds",
+          s.end_seconds::float AS "endSeconds",
+          s.xp_value AS "xpValue",
+          s.difficulty::text AS difficulty,
+          s.should_grant_xp AS "shouldGrantXp",
+          s.ai_summary AS "aiSummary",
+          s.ai_confidence::float AS "aiConfidence",
+          s.sort_order AS "sortOrder",
+          s.created_at::text AS "createdAt",
+          s.updated_at::text AS "updatedAt",
+          COALESCE(
+            (SELECT json_agg(json_build_object('xpAreaId', sa.xp_area_id, 'weightPercent', sa.weight_percent::float))
+               FROM lesson_xp_segment_area sa WHERE sa.lesson_xp_segment_id = s.id),
+            '[]'
+          ) AS areas,
+          COALESCE(
+            (SELECT json_agg(json_build_object('xpSkillId', ss.xp_skill_id, 'weightPercent', ss.weight_percent::float))
+               FROM lesson_xp_segment_skill ss WHERE ss.lesson_xp_segment_id = s.id),
+            '[]'
+          ) AS skills,
+          COALESCE(
+            (SELECT json_agg(json_build_object('xpLearningTypeId', sl.xp_learning_type_id, 'weightPercent', sl.weight_percent::float))
+               FROM lesson_xp_segment_learning_type sl WHERE sl.lesson_xp_segment_id = s.id),
+            '[]'
+          ) AS "learningTypes"
+        FROM lesson_xp_segment s
+       WHERE s.lesson_xp_map_id = $1
+       ORDER BY s.sort_order ASC, s.start_seconds ASC
+       LIMIT $2 OFFSET $3`,
+      [mapId, pageSize, offset],
+    );
+
+    const total = Number(totalRow?.total ?? 0);
+    return { data: rows, total, page, pageSize, lastPage: Math.ceil(total / pageSize) };
+  }
+
+  async getById(id: number) {
+    const row = await this.querySingle<any>(
+      `SELECT
+          s.id,
+          s.lesson_xp_map_id AS "lessonXpMapId",
+          s.start_seconds::float AS "startSeconds",
+          s.end_seconds::float AS "endSeconds",
+          s.xp_value AS "xpValue",
+          s.difficulty::text AS difficulty,
+          s.should_grant_xp AS "shouldGrantXp",
+          s.ai_summary AS "aiSummary",
+          s.ai_confidence::float AS "aiConfidence",
+          s.sort_order AS "sortOrder",
+          s.created_at::text AS "createdAt",
+          s.updated_at::text AS "updatedAt"
+        FROM lesson_xp_segment s WHERE s.id = $1`,
+      [id],
+    );
+    if (!row) throw new NotFoundException('Lesson XP segment not found');
+
+    const [areas, skills, learningTypes] = await Promise.all([
+      this.queryRows<any>(`SELECT xp_area_id AS "xpAreaId", weight_percent::float AS "weightPercent" FROM lesson_xp_segment_area WHERE lesson_xp_segment_id = $1`, [id]),
+      this.queryRows<any>(`SELECT xp_skill_id AS "xpSkillId", weight_percent::float AS "weightPercent" FROM lesson_xp_segment_skill WHERE lesson_xp_segment_id = $1`, [id]),
+      this.queryRows<any>(`SELECT xp_learning_type_id AS "xpLearningTypeId", weight_percent::float AS "weightPercent" FROM lesson_xp_segment_learning_type WHERE lesson_xp_segment_id = $1`, [id]),
+    ]);
+
+    return { ...row, areas, skills, learningTypes };
+  }
+
+  async create(mapId: number, dto: CreateLessonXpSegmentDto) {
+    const map = await this.querySingle<{ id: number }>(`SELECT id FROM lesson_xp_map WHERE id = $1`, [mapId]);
+    if (!map) throw new NotFoundException('Lesson XP map not found');
+
+    const created = await this.querySingle<{ id: number }>(
+      `INSERT INTO lesson_xp_segment
+         (lesson_xp_map_id, start_seconds, end_seconds, xp_value, difficulty, should_grant_xp,
+          ai_summary, ai_confidence, sort_order, created_at, updated_at)
+       VALUES ($1, $2, $3, $4, $5::lesson_xp_segment_difficulty_e5f6a7b8c9_enum, $6, $7, $8, $9, NOW(), NOW())
+       RETURNING id`,
+      [
+        mapId, dto.startSeconds, dto.endSeconds, dto.xpValue,
+        dto.difficulty, dto.shouldGrantXp, dto.aiSummary ?? null,
+        dto.aiConfidence ?? null, dto.sortOrder ?? 0,
+      ],
+    );
+
+    await this.syncRelations(created!.id, dto.areas, dto.skills, dto.learningTypes);
+    await this.recalculateTotalXp(mapId);
+    return this.getById(created!.id);
+  }
+
+  async update(id: number, dto: UpdateLessonXpSegmentDto) {
+    const segment = await this.querySingle<{ id: number; lesson_xp_map_id: number }>(
+      `SELECT id, lesson_xp_map_id FROM lesson_xp_segment WHERE id = $1`,
+      [id],
+    );
+    if (!segment) throw new NotFoundException('Lesson XP segment not found');
+
+    const updates: string[] = [];
+    const values: unknown[] = [];
+
+    if (dto.startSeconds !== undefined) updates.push(`start_seconds = ${this.param(values, dto.startSeconds)}`);
+    if (dto.endSeconds !== undefined) updates.push(`end_seconds = ${this.param(values, dto.endSeconds)}`);
+    if (dto.xpValue !== undefined) updates.push(`xp_value = ${this.param(values, dto.xpValue)}`);
+    if (dto.difficulty !== undefined) updates.push(`difficulty = ${this.param(values, dto.difficulty)}::lesson_xp_segment_difficulty_e5f6a7b8c9_enum`);
+    if (dto.shouldGrantXp !== undefined) updates.push(`should_grant_xp = ${this.param(values, dto.shouldGrantXp)}`);
+    if (dto.aiSummary !== undefined) updates.push(`ai_summary = ${this.param(values, dto.aiSummary)}`);
+    if (dto.aiConfidence !== undefined) updates.push(`ai_confidence = ${this.param(values, dto.aiConfidence)}`);
+    if (dto.sortOrder !== undefined) updates.push(`sort_order = ${this.param(values, dto.sortOrder)}`);
+
+    if (updates.length > 0) {
+      values.push(id);
+      await this.prisma.$executeRawUnsafe(
+        `UPDATE lesson_xp_segment SET ${updates.join(', ')}, updated_at = NOW() WHERE id = $${values.length}`,
+        ...values,
+      );
+    }
+
+    if (dto.areas !== undefined || dto.skills !== undefined || dto.learningTypes !== undefined) {
+      await this.syncRelations(id, dto.areas, dto.skills, dto.learningTypes);
+    }
+
+    await this.recalculateTotalXp(segment.lesson_xp_map_id);
+    return this.getById(id);
+  }
+
+  async delete(id: number) {
+    const segment = await this.querySingle<{ id: number; lesson_xp_map_id: number }>(
+      `SELECT id, lesson_xp_map_id FROM lesson_xp_segment WHERE id = $1`,
+      [id],
+    );
+    if (!segment) throw new NotFoundException('Lesson XP segment not found');
+
+    await this.prisma.$executeRawUnsafe(`DELETE FROM lesson_xp_segment WHERE id = $1`, id);
+    await this.recalculateTotalXp(segment.lesson_xp_map_id);
+  }
+
+  private async syncRelations(
+    segmentId: number,
+    areas?: SegmentAreaDto[],
+    skills?: SegmentSkillDto[],
+    learningTypes?: SegmentLearningTypeDto[],
+  ) {
+    if (areas !== undefined) {
+      await this.prisma.$executeRawUnsafe(`DELETE FROM lesson_xp_segment_area WHERE lesson_xp_segment_id = $1`, segmentId);
+      for (const area of areas) {
+        await this.prisma.$executeRawUnsafe(
+          `INSERT INTO lesson_xp_segment_area (lesson_xp_segment_id, xp_area_id, weight_percent, created_at, updated_at)
+           VALUES ($1, $2, $3, NOW(), NOW())`,
+          segmentId, area.xpAreaId, area.weightPercent,
+        );
+      }
+    }
+
+    if (skills !== undefined) {
+      await this.prisma.$executeRawUnsafe(`DELETE FROM lesson_xp_segment_skill WHERE lesson_xp_segment_id = $1`, segmentId);
+      for (const skill of skills) {
+        await this.prisma.$executeRawUnsafe(
+          `INSERT INTO lesson_xp_segment_skill (lesson_xp_segment_id, xp_skill_id, weight_percent, created_at, updated_at)
+           VALUES ($1, $2, $3, NOW(), NOW())`,
+          segmentId, skill.xpSkillId, skill.weightPercent,
+        );
+      }
+    }
+
+    if (learningTypes !== undefined) {
+      await this.prisma.$executeRawUnsafe(`DELETE FROM lesson_xp_segment_learning_type WHERE lesson_xp_segment_id = $1`, segmentId);
+      for (const lt of learningTypes) {
+        await this.prisma.$executeRawUnsafe(
+          `INSERT INTO lesson_xp_segment_learning_type (lesson_xp_segment_id, xp_learning_type_id, weight_percent, created_at, updated_at)
+           VALUES ($1, $2, $3, NOW(), NOW())`,
+          segmentId, lt.xpLearningTypeId, lt.weightPercent,
+        );
+      }
+    }
+  }
+
+  private async recalculateTotalXp(mapId: number) {
+    await this.prisma.$executeRawUnsafe(
+      `UPDATE lesson_xp_map
+          SET total_xp = COALESCE(
+            (SELECT SUM(xp_value) FROM lesson_xp_segment
+              WHERE lesson_xp_map_id = $1 AND should_grant_xp = true),
+            0
+          ),
+          updated_at = NOW()
+        WHERE id = $1`,
+      mapId,
+    );
+  }
+
+  private param(values: unknown[], value: unknown) {
+    values.push(value);
+    return `$${values.length}`;
+  }
+
+  private async queryRows<T>(query: string, values: unknown[] = []) {
+    return this.prisma.$queryRawUnsafe<T[]>(query, ...values);
+  }
+
+  private async querySingle<T>(query: string, values: unknown[] = []) {
+    const rows = await this.prisma.$queryRawUnsafe<T[]>(query, ...values);
+    return rows[0] ?? null;
+  }
+}

package/src/lms-commerce-access.subscriber.ts

@@ -0,0 +1,88 @@
+import { IntegrationDeveloperApiService } from '@hed-hog/core';
+import { Injectable, Logger, OnModuleInit } from '@nestjs/common';
+
+type SubscriptionActivatedPayload = {
+  subscription_id?: number | null;
+  customer_id?: number | null;
+  user_id?: number | null;
+  product_id?: number | null;
+  plan_version_id?: number | null;
+  price_id?: number | null;
+  current_period_start?: string | null;
+  current_period_end?: string | null;
+};
+
+type SubscriptionCanceledPayload = {
+  subscription_id?: number | null;
+  reason?: string | null;
+  canceled_at?: string | null;
+  entitlement_revoked?: boolean | null;
+};
+
+@Injectable()
+export class LmsCommerceAccessSubscriber implements OnModuleInit {
+  private readonly logger = new Logger(LmsCommerceAccessSubscriber.name);
+
+  constructor(
+    private readonly integrationApi: IntegrationDeveloperApiService,
+  ) {}
+
+  onModuleInit(): void {
+    this.integrationApi.subscribeMany([
+      {
+        eventName: 'commerce.subscription.activated',
+        consumerName: 'lms.commerce-subscription-activated',
+        priority: 0,
+        handler: async (event) => this.onSubscriptionActivated(event),
+      },
+      {
+        eventName: 'commerce.subscription.canceled',
+        consumerName: 'lms.commerce-subscription-canceled',
+        priority: 0,
+        handler: async (event) => this.onSubscriptionCanceled(event),
+      },
+    ]);
+  }
+
+  private async onSubscriptionActivated(event: any): Promise<void> {
+    const payload = (event.payload ?? {}) as SubscriptionActivatedPayload;
+    const userId = Number(payload.user_id ?? 0);
+    const productId = Number(payload.product_id ?? 0);
+    const subscriptionId = Number(payload.subscription_id ?? 0);
+
+    if (!userId || !productId) {
+      this.logger.warn(
+        `commerce.subscription.activated: missing user_id or product_id (subscription ${subscriptionId}) — skipping LMS side effects`,
+      );
+      return;
+    }
+
+    this.logger.log(
+      `LMS access granted: subscription ${subscriptionId} activated for user ${userId} / product ${productId}`,
+    );
+
+    // Extension point: look up integration links product_id → lms course/plan
+    // and auto-enroll the student in the corresponding class group.
+    // Example shape of what would go here:
+    //
+    // const links = await this.integrationApi.findLinksBySource({
+    //   module: 'commerce',
+    //   entityType: 'product',
+    //   entityId: String(productId),
+    // });
+    // for (const link of links.filter(l => l.targetModule === 'lms' && l.targetEntityType === 'course')) {
+    //   await this.classGroupService.enrollStudent(Number(link.targetEntityId), userId);
+    // }
+  }
+
+  private async onSubscriptionCanceled(event: any): Promise<void> {
+    const payload = (event.payload ?? {}) as SubscriptionCanceledPayload;
+    const subscriptionId = Number(payload.subscription_id ?? 0);
+
+    this.logger.log(
+      `LMS access revoked: subscription ${subscriptionId} canceled (reason: ${payload.reason ?? 'none'}, entitlement_revoked: ${payload.entitlement_revoked})`,
+    );
+
+    // Extension point: remove student from active class groups linked to this subscription.
+  }
+}

package/src/lms.module.ts

@@ -2,6 +2,7 @@ import { LocaleModule } from '@hed-hog/api-locale';
 import { PaginationModule } from '@hed-hog/api-pagination';
 import { PrismaModule } from '@hed-hog/api-prisma';
 import { CoreModule } from '@hed-hog/core';
+import { CommerceModule } from '@hed-hog/commerce';
 import { QueueModule } from '@hed-hog/queue';
 import { forwardRef, Module } from '@nestjs/common';
 import { ConfigModule } from '@nestjs/config';
@@ -11,6 +12,7 @@ import { LmsCertificateModule } from './certificate/certificate.module';
 import { ClassGroupModule } from './class-group/class-group.module';
 import { CourseLessonDiscussionModule } from './course-lesson-discussion/course-lesson-discussion.module';
 import { CourseLessonNoteModule } from './course-lesson-note/course-lesson-note.module';
+import { LmsCommerceAccessSubscriber } from './lms-commerce-access.subscriber';
 import { CourseAudioTranscriptionService } from './course/course-audio-transcription.service';
 import { CourseModule } from './course/course.module';
 import { LmsDashboardModule } from './dashboard/dashboard.module';
@@ -19,11 +21,15 @@ import { EnterpriseTrainingModule } from './enterprise/training/enterprise-train
 import { EvaluationModule } from './evaluation/evaluation.module';
 import { ExamModule } from './exam/exam.module';
 import { InstructorModule } from './instructor/instructor.module';
+import { LessonXpMapModule } from './lesson-xp-map/lesson-xp-map.module';
+import { PlataformaController } from './platforma/platforma.controller';
+import { PlatformaVideoService } from './platforma/platforma-video.service';
+import { StudentXpModule } from './student-xp/student-xp.module';
+import { XpCatalogModule } from './xp-catalog/xp-catalog.module';
+import { PlatformaService } from './platforma/platforma.service';
 import { LmsRealtimeModule } from './realtime/lms-realtime.module';
 import { LmsReportsModule } from './reports/reports.module';
-import { PlataformaController } from './platforma/platforma.controller';
 import { TrainingModule } from './training/training.module';
-import { VideoResolutionProfileModule } from './video-resolution-profile/video-resolution-profile.module';
 
 @Module({
   imports: [
@@ -32,6 +38,7 @@ import { VideoResolutionProfileModule } from './video-resolution-profile/video-r
     forwardRef(() => PrismaModule),
     forwardRef(() => CoreModule),
     forwardRef(() => QueueModule),
+    forwardRef(() => CommerceModule),
     forwardRef(() => LocaleModule),
     forwardRef(() => AchievementModule),
     forwardRef(() => BitcodeWalletModule),
@@ -49,10 +56,17 @@ import { VideoResolutionProfileModule } from './video-resolution-profile/video-r
     forwardRef(() => LmsRealtimeModule),
     forwardRef(() => LmsReportsModule),
     forwardRef(() => TrainingModule),
-    forwardRef(() => VideoResolutionProfileModule),
+    forwardRef(() => XpCatalogModule),
+    forwardRef(() => LessonXpMapModule),
+    forwardRef(() => StudentXpModule),
   ],
   controllers: [PlataformaController],
-  providers: [CourseAudioTranscriptionService],
+  providers: [
+    CourseAudioTranscriptionService,
+    PlatformaService,
+    PlatformaVideoService,
+    LmsCommerceAccessSubscriber,
+  ],
   exports: [
     forwardRef(() => AchievementModule),
     forwardRef(() => BitcodeWalletModule),
@@ -70,7 +84,9 @@ import { VideoResolutionProfileModule } from './video-resolution-profile/video-r
     forwardRef(() => LmsRealtimeModule),
     forwardRef(() => LmsReportsModule),
     forwardRef(() => TrainingModule),
-    forwardRef(() => VideoResolutionProfileModule),
+    forwardRef(() => XpCatalogModule),
+    forwardRef(() => LessonXpMapModule),
+    forwardRef(() => StudentXpModule),
   ],
 })
 export class LmsModule {}

package/src/platforma/dto/update-profile.dto.ts

@@ -0,0 +1,59 @@
+import { IsOptional, IsString } from 'class-validator';
+
+export class UpdatePlatformaProfileDto {
+  @IsOptional()
+  @IsString()
+  name?: string;
+
+  @IsOptional()
+  @IsString()
+  cpf?: string;
+
+  @IsOptional()
+  @IsString()
+  dob?: string;
+
+  @IsOptional()
+  @IsString()
+  gender?: string;
+
+  @IsOptional()
+  @IsString()
+  country?: string;
+
+  @IsOptional()
+  @IsString()
+  city?: string;
+
+  @IsOptional()
+  @IsString()
+  state?: string;
+
+  @IsOptional()
+  @IsString()
+  neighborhood?: string;
+
+  @IsOptional()
+  @IsString()
+  street?: string;
+
+  @IsOptional()
+  @IsString()
+  number?: string;
+
+  @IsOptional()
+  @IsString()
+  complement?: string;
+
+  @IsOptional()
+  @IsString()
+  zip?: string;
+
+  @IsOptional()
+  @IsString()
+  phone?: string;
+
+  @IsOptional()
+  @IsString()
+  profession?: string;
+}