@hed-hog/lms 0.0.347 → 0.0.350

package/hedhog/table/course_lesson_discussion_topic.yaml

@@ -0,0 +1,35 @@
+columns:
+  - type: pk
+  - name: course_lesson_id
+    type: fk
+    references:
+      table: course_lesson
+      column: id
+      onDelete: CASCADE
+  - name: person_id
+    type: fk
+    references:
+      table: person
+      column: id
+      onDelete: CASCADE
+  - name: parent_topic_id
+    type: fk
+    isNullable: true
+    references:
+      table: course_lesson_discussion_topic
+      column: id
+      onDelete: CASCADE
+  - name: content
+    type: text
+  - name: player_time_seconds
+    type: int
+    default: 0
+  - type: created_at
+  - type: updated_at
+
+indices:
+  - columns: [course_lesson_id]
+  - columns: [person_id]
+  - columns: [parent_topic_id]
+  - columns: [course_lesson_id, parent_topic_id]
+  - columns: [course_lesson_id, player_time_seconds]

package/hedhog/table/course_lesson_note.yaml

@@ -0,0 +1,34 @@
+columns:
+  - type: pk
+  - name: course_lesson_id
+    type: fk
+    references:
+      table: course_lesson
+      column: id
+      onDelete: CASCADE
+  - name: person_id
+    type: fk
+    references:
+      table: person
+      column: id
+      onDelete: CASCADE
+  - name: description
+    type: text
+  - name: player_time_seconds
+    type: int
+    default: 0
+  - name: frame_file_id
+    type: fk
+    isNullable: true
+    references:
+      table: file
+      column: id
+      onDelete: SET NULL
+  - type: created_at
+  - type: updated_at
+
+indices:
+  - columns: [course_lesson_id]
+  - columns: [person_id]
+  - columns: [course_lesson_id, person_id]
+  - columns: [course_lesson_id, player_time_seconds]

package/hedhog/table/exam.yaml

@@ -26,6 +26,10 @@ columns:
   - name: exam_type
     type: enum
     values: [quiz, test, assignment, project]
+  - name: level
+    type: enum
+    values: [beginner, intermediate, advanced]
+    default: beginner
   - name: status
     type: enum
     values: [draft, published, closed, archived]
@@ -88,4 +92,5 @@ columns:
 indices:
   - columns: [course_id]
   - columns: [course_class_group_id]
+  - columns: [level]
   - columns: [status]

package/hedhog/table/learning_path_enrollment.yaml

@@ -21,9 +21,15 @@ columns:
     default: 0
   - name: enrolled_at
     type: datetime
+  - name: started_at
+    type: datetime
+    isNullable: true
   - name: completed_at
     type: datetime
     isNullable: true
+  - name: ended_at
+    type: datetime
+    isNullable: true
   - type: created_at
   - type: updated_at
 

package/hedhog/table/question.yaml

@@ -1,5 +1,12 @@
 columns:
   - type: pk
+  - name: question_subject_id
+    type: fk
+    isNullable: true
+    references:
+      table: question_subject
+      column: id
+      onDelete: SET NULL
   - name: question_type
     type: enum
     values: [multiple_choice, true_false, essay, fill_blank, matching]
@@ -19,3 +26,6 @@ columns:
     default: 1
   - type: created_at
   - type: updated_at
+
+indices:
+  - columns: [question_subject_id]

package/hedhog/table/question_subject.yaml

@@ -0,0 +1,17 @@
+columns:
+  - type: pk
+  - name: name
+    type: varchar
+    length: 255
+  - name: description
+    type: text
+    isNullable: true
+  - name: is_active
+    type: boolean
+    default: true
+  - type: created_at
+  - type: updated_at
+
+indices:
+  - columns: [name]
+    isUnique: true

package/hedhog/table/student_activity_streak.yaml

@@ -0,0 +1,25 @@
+columns:
+  - type: pk
+  - name: person_id
+    type: fk
+    references:
+      table: person
+      column: id
+      onDelete: CASCADE
+  - name: activity_date_key
+    type: varchar
+  - name: activity_type
+    type: varchar
+    isNullable: true
+  - name: source
+    type: varchar
+    isNullable: true
+  - name: last_activity_at
+    type: datetime
+  - type: created_at
+  - type: updated_at
+
+indices:
+  - columns: [person_id, activity_date_key]
+    isUnique: true
+  - columns: [person_id, last_activity_at]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hed-hog/lms",
-  "version": "0.0.347",
+  "version": "0.0.350",
   "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-locale": "0.0.14",
     "@hed-hog/api-prisma": "0.0.6",
+    "@hed-hog/api-pagination": "0.0.7",
     "@hed-hog/api-types": "0.0.1",
-    "@hed-hog/api-locale": "0.0.14",
     "@hed-hog/api": "0.0.8",
-    "@hed-hog/api-pagination": "0.0.7",
-    "@hed-hog/category": "0.0.347",
-    "@hed-hog/contact": "0.0.347",
-    "@hed-hog/finance": "0.0.347",
-    "@hed-hog/core": "0.0.347"
+    "@hed-hog/core": "0.0.350",
+    "@hed-hog/category": "0.0.350",
+    "@hed-hog/finance": "0.0.350",
+    "@hed-hog/contact": "0.0.350"
   },
   "exports": {
     ".": {

package/src/achievement/achievement.controller.ts

@@ -0,0 +1,60 @@
+import { Role } from '@hed-hog/api';
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Param,
+  ParseIntPipe,
+  Patch,
+  Post,
+  Query,
+} from '@nestjs/common';
+import { AchievementService } from './achievement.service';
+import { CreateAchievementDto } from './dto/create-achievement.dto';
+import { UpdateAchievementDto } from './dto/update-achievement.dto';
+
+@Role()
+@Controller('lms/achievements')
+export class AchievementController {
+  constructor(private readonly achievementService: AchievementService) {}
+
+  @Get()
+  list(
+    @Query('page') page?: string,
+    @Query('pageSize') pageSize?: string,
+    @Query('search') search?: string
+  ) {
+    return this.achievementService.list({
+      page: page ? Number(page) : 1,
+      pageSize: pageSize ? Number(pageSize) : 20,
+      search,
+    });
+  }
+
+  @Get(':id')
+  getById(@Param('id', ParseIntPipe) id: number) {
+    return this.achievementService.getById(id);
+  }
+
+  @Post()
+  create(@Body() dto: CreateAchievementDto) {
+    return this.achievementService.create(dto);
+  }
+
+  @Patch(':id')
+  update(
+    @Param('id', ParseIntPipe) id: number,
+    @Body() dto: UpdateAchievementDto
+  ) {
+    return this.achievementService.update(id, dto);
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  remove(@Param('id', ParseIntPipe) id: number) {
+    return this.achievementService.delete(id);
+  }
+}

package/src/achievement/achievement.mcp-tools.ts

@@ -0,0 +1,108 @@
+import { McpContext, McpTool } from '@hed-hog/core';
+import { Injectable } from '@nestjs/common';
+import { AchievementService } from './achievement.service';
+
+@Injectable()
+export class LmsAchievementsMcpTools {
+  constructor(private readonly achievementService: AchievementService) {}
+
+  @McpTool({
+    name: 'lms.achievements.list',
+    description: 'Lists LMS achievements with optional pagination and search.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        page: { type: 'number', description: 'Page number (default: 1)' },
+        pageSize: { type: 'number', description: 'Items per page (default: 20)' },
+        search: { type: 'string', description: 'Search term (name, description, type)' },
+      },
+    },
+    readOnly: true,
+  })
+  async listAchievements(args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.achievementService.list(args);
+  }
+
+  @McpTool({
+    name: 'lms.achievements.get',
+    description: 'Returns a single LMS achievement by ID.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Achievement ID' },
+      },
+      required: ['id'],
+    },
+    readOnly: true,
+  })
+  async getAchievement(args: { id: number }, _context: McpContext): Promise<any> {
+    return this.achievementService.getById(args.id);
+  }
+
+  @McpTool({
+    name: 'lms.achievements.create',
+    description: 'Creates a new LMS achievement.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Achievement name (required)' },
+        description: { type: 'string', description: 'Description' },
+        iconFileId: { type: 'number', description: 'Icon file ID' },
+        mainImageFileId: { type: 'number', description: 'Main image file ID' },
+        type: {
+          type: 'string',
+          description: 'Achievement type (required)',
+          enum: ['course_completion', 'learning_path_completion', 'exam_approval', 'attendance', 'engagement', 'custom'],
+        },
+        bitCodesValue: { type: 'number', description: 'BitCodes value awarded (required, min 0)' },
+        canReceiveMultipleTimes: { type: 'boolean', description: 'Whether the student can receive this achievement multiple times (required)' },
+      },
+      required: ['name', 'type', 'bitCodesValue', 'canReceiveMultipleTimes'],
+    },
+  })
+  async createAchievement(args: Record<string, any>, _context: McpContext): Promise<any> {
+    return this.achievementService.create(args as any);
+  }
+
+  @McpTool({
+    name: 'lms.achievements.update',
+    description: 'Updates an existing LMS achievement.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Achievement ID' },
+        name: { type: 'string', description: 'Achievement name' },
+        description: { type: 'string', description: 'Description' },
+        iconFileId: { type: 'number', description: 'Icon file ID' },
+        mainImageFileId: { type: 'number', description: 'Main image file ID' },
+        type: {
+          type: 'string',
+          description: 'Achievement type',
+          enum: ['course_completion', 'learning_path_completion', 'exam_approval', 'attendance', 'engagement', 'custom'],
+        },
+        bitCodesValue: { type: 'number', description: 'BitCodes value' },
+        canReceiveMultipleTimes: { type: 'boolean', description: 'Whether the student can receive this achievement multiple times' },
+      },
+      required: ['id'],
+    },
+  })
+  async updateAchievement(args: { id: number; [key: string]: any }, _context: McpContext): Promise<any> {
+    const { id, ...dto } = args;
+    return this.achievementService.update(id, dto as any);
+  }
+
+  @McpTool({
+    name: 'lms.achievements.delete',
+    description: 'Deletes an LMS achievement by ID.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        id: { type: 'number', description: 'Achievement ID' },
+      },
+      required: ['id'],
+    },
+  })
+  async deleteAchievement(args: { id: number }, _context: McpContext): Promise<any> {
+    return this.achievementService.delete(args.id);
+  }
+}

package/src/achievement/achievement.module.ts

@@ -0,0 +1,13 @@
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { forwardRef, Module } from '@nestjs/common';
+import { AchievementController } from './achievement.controller';
+import { LmsAchievementsMcpTools } from './achievement.mcp-tools';
+import { AchievementService } from './achievement.service';
+
+@Module({
+  imports: [forwardRef(() => PrismaModule)],
+  controllers: [AchievementController],
+  providers: [AchievementService, LmsAchievementsMcpTools],
+  exports: [AchievementService],
+})
+export class AchievementModule {}

package/src/achievement/achievement.service.ts

@@ -0,0 +1,252 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { CreateAchievementDto } from './dto/create-achievement.dto';
+import { UpdateAchievementDto } from './dto/update-achievement.dto';
+
+type AchievementRow = {
+  id: number;
+  name: string;
+  description: string | null;
+  iconFileId: number | null;
+  mainImageFileId: number | null;
+  type: string;
+  bitCodesValue: number;
+  canReceiveMultipleTimes: boolean;
+  createdAt: string | null;
+  updatedAt: string | null;
+};
+
+@Injectable()
+export class AchievementService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async list(params: { page?: number; pageSize?: number; search?: string }) {
+    const page = Math.max(Number(params.page) || 1, 1);
+    const pageSize = Math.max(Number(params.pageSize) || 20, 1);
+    const offset = (page - 1) * pageSize;
+    const search = params.search?.trim();
+
+    const values: unknown[] = [];
+    const where = ['1 = 1'];
+
+    if (search) {
+      const placeholder = this.param(values, `%${search}%`);
+      where.push(`(
+        a.name ILIKE ${placeholder}
+        OR COALESCE(a.description, '') ILIKE ${placeholder}
+        OR a.type::text ILIKE ${placeholder}
+      )`);
+    }
+
+    const whereClause = where.join(' AND ');
+    const totalRow = await this.querySingle<{ total: string }>(
+      `SELECT COUNT(*)::text AS total
+         FROM achievement a
+        WHERE ${whereClause}`,
+      values
+    );
+
+    const queryValues = [...values];
+    const limitPlaceholder = this.param(queryValues, pageSize);
+    const offsetPlaceholder = this.param(queryValues, offset);
+
+    const rows = await this.queryRows<AchievementRow>(
+      `SELECT
+          a.id,
+          a.name,
+          a.description,
+          a.icon_file_id AS "iconFileId",
+          a.main_image_file_id AS "mainImageFileId",
+          a.type::text AS type,
+          a.bitcodes_value AS "bitCodesValue",
+          a.can_receive_multiple_times AS "canReceiveMultipleTimes",
+          a.created_at::text AS "createdAt",
+          a.updated_at::text AS "updatedAt"
+        FROM achievement a
+       WHERE ${whereClause}
+       ORDER BY a.name ASC, a.id ASC
+       LIMIT ${limitPlaceholder}
+      OFFSET ${offsetPlaceholder}`,
+      queryValues
+    );
+
+    return {
+      data: rows.map((row) => this.mapRow(row)),
+      total: Number(totalRow?.total ?? 0),
+      page,
+      pageSize,
+    };
+  }
+
+  async create(dto: CreateAchievementDto) {
+    const created = await this.querySingle<{ id: number }>(
+      `INSERT INTO achievement (
+          name,
+          description,
+          icon_file_id,
+          main_image_file_id,
+          type,
+          bitcodes_value,
+          can_receive_multiple_times,
+          created_at,
+          updated_at
+        ) VALUES (
+          $1,
+          $2,
+          $3,
+          $4,
+          $5::achievement_type_6ee0f922f6_enum,
+          $6,
+          $7,
+          NOW(),
+          NOW()
+        )
+        RETURNING id`,
+      [
+        dto.name.trim(),
+        this.normalizeOptionalText(dto.description),
+        dto.iconFileId ?? null,
+        dto.mainImageFileId ?? null,
+        dto.type,
+        Number(dto.bitCodesValue ?? 0),
+        Boolean(dto.canReceiveMultipleTimes),
+      ]
+    );
+
+    return this.getById(created.id);
+  }
+
+  async update(id: number, dto: UpdateAchievementDto) {
+    await this.ensureExists(id);
+
+    const updates: string[] = [];
+    const values: unknown[] = [];
+
+    if (dto.name !== undefined) {
+      updates.push(`name = ${this.param(values, dto.name.trim())}`);
+    }
+
+    if (dto.description !== undefined) {
+      updates.push(
+        `description = ${this.param(values, this.normalizeOptionalText(dto.description))}`
+      );
+    }
+
+    if (dto.iconFileId !== undefined) {
+      updates.push(`icon_file_id = ${this.param(values, dto.iconFileId ?? null)}`);
+    }
+
+    if (dto.mainImageFileId !== undefined) {
+      updates.push(
+        `main_image_file_id = ${this.param(values, dto.mainImageFileId ?? null)}`
+      );
+    }
+
+    if (dto.type !== undefined) {
+      updates.push(
+        `type = ${this.param(values, dto.type)}::achievement_type_6ee0f922f6_enum`
+      );
+    }
+
+    if (dto.bitCodesValue !== undefined) {
+      updates.push(`bitcodes_value = ${this.param(values, Number(dto.bitCodesValue))}`);
+    }
+
+    if (dto.canReceiveMultipleTimes !== undefined) {
+      updates.push(
+        `can_receive_multiple_times = ${this.param(
+          values,
+          Boolean(dto.canReceiveMultipleTimes)
+        )}`
+      );
+    }
+
+    if (updates.length > 0) {
+      values.push(id);
+      await this.prisma.$executeRawUnsafe(
+        `UPDATE achievement
+            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 achievement WHERE id = $1`, id);
+  }
+
+  async getById(id: number) {
+    const row = await this.querySingle<AchievementRow>(
+      `SELECT
+          a.id,
+          a.name,
+          a.description,
+          a.icon_file_id AS "iconFileId",
+          a.main_image_file_id AS "mainImageFileId",
+          a.type::text AS type,
+          a.bitcodes_value AS "bitCodesValue",
+          a.can_receive_multiple_times AS "canReceiveMultipleTimes",
+          a.created_at::text AS "createdAt",
+          a.updated_at::text AS "updatedAt"
+        FROM achievement a
+       WHERE a.id = $1`,
+      [id]
+    );
+
+    if (!row) {
+      throw new NotFoundException('Achievement not found');
+    }
+
+    return this.mapRow(row);
+  }
+
+  private async ensureExists(id: number) {
+    const row = await this.querySingle<{ id: number }>(
+      `SELECT id FROM achievement WHERE id = $1`,
+      [id]
+    );
+
+    if (!row) {
+      throw new NotFoundException('Achievement not found');
+    }
+  }
+
+  private mapRow(row: AchievementRow) {
+    return {
+      id: row.id,
+      name: row.name,
+      description: row.description,
+      iconFileId: row.iconFileId,
+      mainImageFileId: row.mainImageFileId,
+      type: row.type,
+      bitCodesValue: Number(row.bitCodesValue ?? 0),
+      canReceiveMultipleTimes: Boolean(row.canReceiveMultipleTimes),
+      createdAt: row.createdAt,
+      updatedAt: row.updatedAt,
+    };
+  }
+
+  private normalizeOptionalText(value?: string | null) {
+    const normalized = value?.trim();
+    return normalized ? normalized : null;
+  }
+
+  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/achievement/dto/create-achievement.dto.ts

@@ -0,0 +1,50 @@
+import {
+  IsBoolean,
+  IsEnum,
+  IsInt,
+  IsOptional,
+  IsString,
+  MaxLength,
+  Min,
+} from 'class-validator';
+
+export const ACHIEVEMENT_TYPE_VALUES = [
+  'course_completion',
+  'learning_path_completion',
+  'exam_approval',
+  'attendance',
+  'engagement',
+  'custom',
+] as const;
+
+export type AchievementType = (typeof ACHIEVEMENT_TYPE_VALUES)[number];
+
+export class CreateAchievementDto {
+  @IsString()
+  @MaxLength(255)
+  name: string;
+
+  @IsOptional()
+  @IsString()
+  description?: string | null;
+
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  iconFileId?: number | null;
+
+  @IsOptional()
+  @IsInt()
+  @Min(1)
+  mainImageFileId?: number | null;
+
+  @IsEnum(ACHIEVEMENT_TYPE_VALUES)
+  type: AchievementType;
+
+  @IsInt()
+  @Min(0)
+  bitCodesValue: number;
+
+  @IsBoolean()
+  canReceiveMultipleTimes: boolean;
+}