@hed-hog/lms 0.0.358 → 0.0.364

package/src/lesson-xp-map/lesson-xp-map.controller.ts

@@ -0,0 +1,116 @@
+import { Role } from '@hed-hog/api';
+import {
+    Body,
+    Controller,
+    Delete,
+    Get,
+    HttpCode,
+    HttpStatus,
+    Param,
+    ParseIntPipe,
+    Patch,
+    Post,
+    Query,
+    Request,
+} from '@nestjs/common';
+import { CreateLessonXpMapDto } from './dto/create-lesson-xp-map.dto';
+import { CreateLessonXpSegmentDto } from './dto/create-lesson-xp-segment.dto';
+import { RejectLessonXpMapDto } from './dto/review-lesson-xp-map.dto';
+import { UpdateLessonXpMapDto } from './dto/update-lesson-xp-map.dto';
+import { LessonXpAiCalculationService } from './lesson-xp-ai-calculation.service';
+import { LessonXpMapService } from './lesson-xp-map.service';
+import { LessonXpSegmentService } from './lesson-xp-segment.service';
+
+@Role()
+@Controller('lms/xp/lesson-maps')
+export class LessonXpMapController {
+  constructor(
+    private readonly lessonXpMapService: LessonXpMapService,
+    private readonly lessonXpSegmentService: LessonXpSegmentService,
+    private readonly lessonXpAiCalculationService: LessonXpAiCalculationService,
+  ) {}
+
+  @Get()
+  list(
+    @Query('page') page?: string,
+    @Query('pageSize') pageSize?: string,
+    @Query('search') search?: string,
+    @Query('status') status?: string,
+    @Query('courseLessonId') courseLessonId?: string,
+  ) {
+    return this.lessonXpMapService.list({
+      page: Number(page) || 1,
+      pageSize: Number(pageSize) || 20,
+      search,
+      status,
+      courseLessonId: courseLessonId ? Number(courseLessonId) : undefined,
+    });
+  }
+
+  @Post()
+  create(@Body() dto: CreateLessonXpMapDto) {
+    return this.lessonXpMapService.create(dto);
+  }
+
+  @Get('lesson/:lessonId')
+  getByLesson(@Param('lessonId', ParseIntPipe) lessonId: number) {
+    return this.lessonXpMapService.getByLessonId(lessonId);
+  }
+
+  @Get('course/:courseId/overview')
+  getCourseOverview(@Param('courseId', ParseIntPipe) courseId: number) {
+    return this.lessonXpMapService.getCourseOverview(courseId);
+  }
+
+  @Post('lesson/:lessonId/recalculate')
+  recalculate(@Param('lessonId', ParseIntPipe) lessonId: number, @Request() req: any) {
+    return this.lessonXpAiCalculationService.triggerCalculation(lessonId, req.user?.id ?? 0);
+  }
+
+  @Get(':id')
+  getById(@Param('id', ParseIntPipe) id: number) {
+    return this.lessonXpMapService.getById(id);
+  }
+
+  @Patch(':id')
+  update(@Param('id', ParseIntPipe) id: number, @Body() dto: UpdateLessonXpMapDto) {
+    return this.lessonXpMapService.update(id, dto);
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  remove(@Param('id', ParseIntPipe) id: number) {
+    return this.lessonXpMapService.delete(id);
+  }
+
+  @Post(':id/approve')
+  approve(@Param('id', ParseIntPipe) id: number, @Request() req: any) {
+    const reviewerPersonId: number = req.user?.personId ?? req.user?.id ?? 0;
+    return this.lessonXpMapService.approve(id, reviewerPersonId);
+  }
+
+  @Post(':id/reject')
+  reject(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() dto: RejectLessonXpMapDto,
+    @Request() req: any,
+  ) {
+    const reviewerPersonId: number = req.user?.personId ?? req.user?.id ?? 0;
+    return this.lessonXpMapService.reject(id, reviewerPersonId, dto.reviewNotes);
+  }
+
+  // Segment sub-resource
+  @Get(':id/segments')
+  listSegments(
+    @Param('id', ParseIntPipe) id: number,
+    @Query('page') page?: string,
+    @Query('pageSize') pageSize?: string,
+  ) {
+    return this.lessonXpSegmentService.listByMap(id, { page: Number(page) || 1, pageSize: Number(pageSize) || 50 });
+  }
+
+  @Post(':id/segments')
+  createSegment(@Param('id', ParseIntPipe) id: number, @Body() dto: CreateLessonXpSegmentDto) {
+    return this.lessonXpSegmentService.create(id, dto);
+  }
+}

package/src/lesson-xp-map/lesson-xp-map.module.ts

@@ -0,0 +1,21 @@
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { CoreModule } from '@hed-hog/core';
+import { QueueModule } from '@hed-hog/queue';
+import { forwardRef, Module } from '@nestjs/common';
+import { LessonXpAiCalculationService } from './lesson-xp-ai-calculation.service';
+import { LessonXpMapController } from './lesson-xp-map.controller';
+import { LessonXpMapService } from './lesson-xp-map.service';
+import { LessonXpSegmentController } from './lesson-xp-segment.controller';
+import { LessonXpSegmentService } from './lesson-xp-segment.service';
+
+@Module({
+  imports: [
+    forwardRef(() => PrismaModule),
+    forwardRef(() => CoreModule),
+    forwardRef(() => QueueModule),
+  ],
+  controllers: [LessonXpMapController, LessonXpSegmentController],
+  providers: [LessonXpMapService, LessonXpSegmentService, LessonXpAiCalculationService],
+  exports: [LessonXpMapService, LessonXpSegmentService, LessonXpAiCalculationService],
+})
+export class LessonXpMapModule {}

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

@@ -0,0 +1,442 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { CreateLessonXpMapDto } from './dto/create-lesson-xp-map.dto';
+import { UpdateLessonXpMapDto } from './dto/update-lesson-xp-map.dto';
+
+@Injectable()
+export class LessonXpMapService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async list(params: {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+    status?: string;
+    courseLessonId?: number;
+  }) {
+    const page = Math.max(Number(params.page) || 1, 1);
+    const pageSize = Math.max(Number(params.pageSize) || 20, 1);
+    const offset = (page - 1) * pageSize;
+
+    const values: unknown[] = [];
+    const where: string[] = ['1 = 1'];
+
+    if (params.search?.trim()) {
+      const p = this.param(values, `%${params.search.trim()}%`);
+      where.push(`cl.title ILIKE ${p}`);
+    }
+    if (params.status?.trim()) {
+      where.push(`m.status::text = ${this.param(values, params.status.trim())}`);
+    }
+    if (params.courseLessonId) {
+      where.push(`m.course_lesson_id = ${this.param(values, params.courseLessonId)}`);
+    }
+
+    const whereClause = where.join(' AND ');
+
+    const totalRow = await this.querySingle<{ total: string }>(
+      `SELECT COUNT(*)::text AS total
+         FROM lesson_xp_map m
+         JOIN course_lesson cl ON cl.id = m.course_lesson_id
+        WHERE ${whereClause}`,
+      values,
+    );
+
+    const q = [...values];
+    const rows = await this.queryRows<any>(
+      `SELECT
+          m.id,
+          m.course_lesson_id AS "courseLessonId",
+          cl.title AS "lessonTitle",
+          m.version,
+          m.total_xp AS "totalXp",
+          m.status::text AS status,
+          m.generated_at::text AS "generatedAt",
+          m.reviewed_at::text AS "reviewedAt",
+          m.reviewed_by_person_id AS "reviewedByPersonId",
+          m.review_notes AS "reviewNotes",
+          m.ai_model_version AS "aiModelVersion",
+          m.processing_error AS "processingError",
+          m.created_at::text AS "createdAt",
+          m.updated_at::text AS "updatedAt",
+          (SELECT COUNT(*) FROM lesson_xp_segment s WHERE s.lesson_xp_map_id = m.id)::int AS "segmentCount"
+        FROM lesson_xp_map m
+        JOIN course_lesson cl ON cl.id = m.course_lesson_id
+       WHERE ${whereClause}
+       ORDER BY m.updated_at DESC
+       LIMIT ${this.param(q, pageSize)} OFFSET ${this.param(q, offset)}`,
+      q,
+    );
+
+    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
+          m.id,
+          m.course_lesson_id AS "courseLessonId",
+          cl.title AS "lessonTitle",
+          m.version,
+          m.total_xp AS "totalXp",
+          m.status::text AS status,
+          m.generated_at::text AS "generatedAt",
+          m.reviewed_at::text AS "reviewedAt",
+          m.reviewed_by_person_id AS "reviewedByPersonId",
+          m.review_notes AS "reviewNotes",
+          m.ai_model_version AS "aiModelVersion",
+          m.processing_error AS "processingError",
+          m.created_at::text AS "createdAt",
+          m.updated_at::text AS "updatedAt"
+        FROM lesson_xp_map m
+        JOIN course_lesson cl ON cl.id = m.course_lesson_id
+       WHERE m.id = $1`,
+      [id],
+    );
+    if (!row) throw new NotFoundException('Lesson XP map not found');
+
+    const segments = await this.queryRows<any>(
+      `SELECT
+          s.id,
+          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",
+          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,
+                        'slug', lt.slug,
+                        'name', COALESCE(lt_pt.name, lt_en.name, lt.slug),
+                        'multiplier', lt.multiplier::float
+                      )
+                    )
+               FROM lesson_xp_segment_learning_type sl
+               JOIN xp_learning_type lt ON lt.id = sl.xp_learning_type_id
+          LEFT JOIN xp_learning_type_locale lt_pt
+                 ON lt_pt.xp_learning_type_id = lt.id
+                AND COALESCE(
+                      (SELECT code FROM locale WHERE id = NULLIF(to_jsonb(lt_pt)->>'locale_id', '')::int),
+                      to_jsonb(lt_pt)->>'locale'
+                    ) = 'pt'
+          LEFT JOIN xp_learning_type_locale lt_en
+                 ON lt_en.xp_learning_type_id = lt.id
+                AND COALESCE(
+                      (SELECT code FROM locale WHERE id = NULLIF(to_jsonb(lt_en)->>'locale_id', '')::int),
+                      to_jsonb(lt_en)->>'locale'
+                    ) = 'en'
+              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`,
+      [id],
+    );
+
+    return { ...row, segments };
+  }
+
+  async getByLessonId(lessonId: number) {
+    const row = await this.querySingle<{ id: number }>(
+      `SELECT id FROM lesson_xp_map WHERE course_lesson_id = $1`,
+      [lessonId],
+    );
+    if (!row) return null;
+    return this.getById(row.id);
+  }
+
+  async getCourseOverview(courseId: number) {
+    const lessons = await this.queryRows<{
+      courseLessonId: number;
+      lessonCode: string | null;
+      lessonTitle: string;
+      totalXp: number;
+      status: string;
+      segmentCount: number;
+      hasMap: boolean;
+    }>(
+      `SELECT
+          l.id AS "courseLessonId",
+          l.id::text AS "lessonCode",
+          l.title AS "lessonTitle",
+          COALESCE(lm.total_xp, 0)::int AS "totalXp",
+          COALESCE(lm.status::text, 'pending') AS status,
+          COALESCE(
+            (SELECT COUNT(*)::int
+               FROM lesson_xp_segment s
+              WHERE s.lesson_xp_map_id = lm.id
+                AND s.should_grant_xp = true),
+            0
+          )::int AS "segmentCount",
+          (lm.id IS NOT NULL) AS "hasMap"
+        FROM course_lesson l
+        JOIN course_module cm ON cm.id = l.course_module_id
+   LEFT JOIN lesson_xp_map lm ON lm.course_lesson_id = l.id
+       WHERE cm.course_id = $1
+       ORDER BY l.id ASC`,
+      [courseId],
+    );
+
+    const areas = await this.queryRows<{
+      xpAreaId: number;
+      slug: string;
+      name: string;
+      xp: number;
+      lessonCount: number;
+      segmentCount: number;
+    }>(
+      `SELECT
+          a.id AS "xpAreaId",
+          a.slug,
+          COALESCE(a_pt.name, a_en.name, a.slug) AS name,
+          SUM(ROUND(s.xp_value * (sa.weight_percent::numeric / 100)))::int AS xp,
+          COUNT(DISTINCT lm.course_lesson_id)::int AS "lessonCount",
+          COUNT(*)::int AS "segmentCount"
+        FROM lesson_xp_map lm
+        JOIN course_lesson l ON l.id = lm.course_lesson_id
+        JOIN course_module cm ON cm.id = l.course_module_id
+        JOIN lesson_xp_segment s
+          ON s.lesson_xp_map_id = lm.id
+         AND s.should_grant_xp = true
+        JOIN lesson_xp_segment_area sa ON sa.lesson_xp_segment_id = s.id
+        JOIN xp_area a ON a.id = sa.xp_area_id
+   LEFT JOIN xp_area_locale a_pt
+          ON a_pt.xp_area_id = a.id
+         AND a_pt.locale_id = (SELECT id FROM locale WHERE code = 'pt')
+   LEFT JOIN xp_area_locale a_en
+          ON a_en.xp_area_id = a.id
+         AND a_en.locale_id = (SELECT id FROM locale WHERE code = 'en')
+       WHERE cm.course_id = $1
+       GROUP BY a.id, a.slug, a_pt.name, a_en.name
+       ORDER BY xp DESC, name ASC`,
+      [courseId],
+    );
+
+    const skills = await this.queryRows<{
+      xpSkillId: number;
+      slug: string;
+      name: string;
+      xp: number;
+      lessonCount: number;
+      segmentCount: number;
+    }>(
+      `SELECT
+          sk.id AS "xpSkillId",
+          sk.slug,
+          COALESCE(sk_pt.name, sk_en.name, sk.slug) AS name,
+          SUM(ROUND(s.xp_value * (ss.weight_percent::numeric / 100)))::int AS xp,
+          COUNT(DISTINCT lm.course_lesson_id)::int AS "lessonCount",
+          COUNT(*)::int AS "segmentCount"
+        FROM lesson_xp_map lm
+        JOIN course_lesson l ON l.id = lm.course_lesson_id
+        JOIN course_module cm ON cm.id = l.course_module_id
+        JOIN lesson_xp_segment s
+          ON s.lesson_xp_map_id = lm.id
+         AND s.should_grant_xp = true
+        JOIN lesson_xp_segment_skill ss ON ss.lesson_xp_segment_id = s.id
+        JOIN xp_skill sk ON sk.id = ss.xp_skill_id
+   LEFT JOIN xp_skill_locale sk_pt
+          ON sk_pt.xp_skill_id = sk.id
+         AND sk_pt.locale_id = (SELECT id FROM locale WHERE code = 'pt')
+   LEFT JOIN xp_skill_locale sk_en
+          ON sk_en.xp_skill_id = sk.id
+         AND sk_en.locale_id = (SELECT id FROM locale WHERE code = 'en')
+       WHERE cm.course_id = $1
+       GROUP BY sk.id, sk.slug, sk_pt.name, sk_en.name
+       ORDER BY xp DESC, name ASC`,
+      [courseId],
+    );
+
+    const learningTypes = await this.queryRows<{
+      xpLearningTypeId: number;
+      slug: string;
+      name: string;
+      multiplier: number;
+      xp: number;
+      lessonCount: number;
+      segmentCount: number;
+    }>(
+      `SELECT
+          lt.id AS "xpLearningTypeId",
+          lt.slug,
+          COALESCE(lt_pt.name, lt_en.name, lt.slug) AS name,
+          lt.multiplier::float AS multiplier,
+          SUM(ROUND(s.xp_value * (sl.weight_percent::numeric / 100)))::int AS xp,
+          COUNT(DISTINCT lm.course_lesson_id)::int AS "lessonCount",
+          COUNT(*)::int AS "segmentCount"
+        FROM lesson_xp_map lm
+        JOIN course_lesson l ON l.id = lm.course_lesson_id
+        JOIN course_module cm ON cm.id = l.course_module_id
+        JOIN lesson_xp_segment s
+          ON s.lesson_xp_map_id = lm.id
+         AND s.should_grant_xp = true
+        JOIN lesson_xp_segment_learning_type sl ON sl.lesson_xp_segment_id = s.id
+        JOIN xp_learning_type lt ON lt.id = sl.xp_learning_type_id
+   LEFT JOIN xp_learning_type_locale lt_pt
+          ON lt_pt.xp_learning_type_id = lt.id
+         AND COALESCE(
+               (SELECT code FROM locale WHERE id = NULLIF(to_jsonb(lt_pt)->>'locale_id', '')::int),
+               to_jsonb(lt_pt)->>'locale'
+             ) = 'pt'
+   LEFT JOIN xp_learning_type_locale lt_en
+          ON lt_en.xp_learning_type_id = lt.id
+         AND COALESCE(
+               (SELECT code FROM locale WHERE id = NULLIF(to_jsonb(lt_en)->>'locale_id', '')::int),
+               to_jsonb(lt_en)->>'locale'
+             ) = 'en'
+       WHERE cm.course_id = $1
+       GROUP BY lt.id, lt.slug, lt.multiplier, lt_pt.name, lt_en.name
+       ORDER BY xp DESC, name ASC`,
+      [courseId],
+    );
+
+    const totalXp = lessons.reduce((sum, lesson) => sum + Number(lesson.totalXp || 0), 0);
+    const mappedLessons = lessons.filter((lesson) => lesson.hasMap).length;
+    const totalSegments = lessons.reduce((sum, lesson) => sum + Number(lesson.segmentCount || 0), 0);
+
+    return {
+      summary: {
+        totalLessons: lessons.length,
+        mappedLessons,
+        unmappedLessons: Math.max(lessons.length - mappedLessons, 0),
+        totalXp,
+        totalSegments,
+        averageXpPerMappedLesson: mappedLessons > 0 ? totalXp / mappedLessons : 0,
+      },
+      lessons,
+      areas: this.withShare(areas, totalXp),
+      skills: this.withShare(skills, totalXp),
+      learningTypes: this.withShare(learningTypes, totalXp),
+    };
+  }
+
+  async create(dto: CreateLessonXpMapDto) {
+    const existing = await this.querySingle<{ id: number }>(
+      `SELECT id FROM lesson_xp_map WHERE course_lesson_id = $1`,
+      [dto.courseLessonId],
+    );
+    if (existing) throw new NotFoundException(`A lesson XP map already exists for lesson ${dto.courseLessonId}. Use PATCH to update it.`);
+
+    const created = await this.querySingle<{ id: number }>(
+      `INSERT INTO lesson_xp_map (course_lesson_id, version, total_xp, status, ai_model_version, created_at, updated_at)
+       VALUES ($1, $2, 0, 'pending'::lesson_xp_map_status_d4e5f6a7b8_enum, $3, NOW(), NOW())
+       RETURNING id`,
+      [dto.courseLessonId, dto.version ?? 1, dto.aiModelVersion ?? null],
+    );
+    return this.getById(created!.id);
+  }
+
+  async update(id: number, dto: UpdateLessonXpMapDto) {
+    await this.ensureExists(id);
+
+    const updates: string[] = [];
+    const values: unknown[] = [];
+
+    if (dto.status !== undefined) updates.push(`status = ${this.param(values, dto.status)}::lesson_xp_map_status_d4e5f6a7b8_enum`);
+    if (dto.reviewNotes !== undefined) updates.push(`review_notes = ${this.param(values, dto.reviewNotes)}`);
+    if (dto.aiModelVersion !== undefined) updates.push(`ai_model_version = ${this.param(values, dto.aiModelVersion)}`);
+    if (dto.processingError !== undefined) updates.push(`processing_error = ${this.param(values, dto.processingError)}`);
+    if (dto.totalXp !== undefined) updates.push(`total_xp = ${this.param(values, dto.totalXp)}`);
+
+    if (updates.length > 0) {
+      values.push(id);
+      await this.prisma.$executeRawUnsafe(
+        `UPDATE lesson_xp_map SET ${updates.join(', ')}, updated_at = NOW() WHERE id = $${values.length}`,
+        ...values,
+      );
+    }
+
+    return this.getById(id);
+  }
+
+  async delete(id: number) {
+    await this.ensureExists(id);
+    await this.prisma.$executeRawUnsafe(`DELETE FROM lesson_xp_map WHERE id = $1`, id);
+  }
+
+  async approve(id: number, reviewerPersonId: number) {
+    await this.ensureExists(id);
+    await this.prisma.$executeRawUnsafe(
+      `UPDATE lesson_xp_map
+          SET status = 'approved'::lesson_xp_map_status_d4e5f6a7b8_enum,
+              reviewed_at = NOW(),
+              reviewed_by_person_id = $1,
+              updated_at = NOW()
+        WHERE id = $2`,
+      reviewerPersonId, id,
+    );
+    return this.getById(id);
+  }
+
+  async reject(id: number, reviewerPersonId: number, notes?: string) {
+    await this.ensureExists(id);
+    await this.prisma.$executeRawUnsafe(
+      `UPDATE lesson_xp_map
+          SET status = 'rejected'::lesson_xp_map_status_d4e5f6a7b8_enum,
+              reviewed_at = NOW(),
+              reviewed_by_person_id = $1,
+              review_notes = $2,
+              updated_at = NOW()
+        WHERE id = $3`,
+      reviewerPersonId, notes ?? null, id,
+    );
+    return this.getById(id);
+  }
+
+  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 async ensureExists(id: number) {
+    const row = await this.querySingle<{ id: number }>(`SELECT id FROM lesson_xp_map WHERE id = $1`, [id]);
+    if (!row) throw new NotFoundException('Lesson XP map not found');
+  }
+
+  private param(values: unknown[], value: unknown) {
+    values.push(value);
+    return `$${values.length}`;
+  }
+
+  private withShare<T extends { xp: number }>(items: T[], totalXp: number) {
+    return items.map((item) => ({
+      ...item,
+      sharePercent: totalXp > 0 ? Number(((item.xp / totalXp) * 100).toFixed(2)) : 0,
+    }));
+  }
+
+  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/lesson-xp-map/lesson-xp-segment.controller.ts

@@ -0,0 +1,36 @@
+import { Role } from '@hed-hog/api';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Param,
+  ParseIntPipe,
+  Patch,
+} from '@nestjs/common';
+import { UpdateLessonXpSegmentDto } from './dto/update-lesson-xp-segment.dto';
+import { LessonXpSegmentService } from './lesson-xp-segment.service';
+
+@Role()
+@Controller('lms/xp/segments')
+export class LessonXpSegmentController {
+  constructor(private readonly lessonXpSegmentService: LessonXpSegmentService) {}
+
+  @Get(':id')
+  getById(@Param('id', ParseIntPipe) id: number) {
+    return this.lessonXpSegmentService.getById(id);
+  }
+
+  @Patch(':id')
+  update(@Param('id', ParseIntPipe) id: number, @Body() dto: UpdateLessonXpSegmentDto) {
+    return this.lessonXpSegmentService.update(id, dto);
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  remove(@Param('id', ParseIntPipe) id: number) {
+    return this.lessonXpSegmentService.delete(id);
+  }
+}