@hed-hog/lms 0.0.349 → 0.0.350

package/src/course/course-operations-integration.service.ts

@@ -0,0 +1,520 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { BadRequestException, Injectable } from '@nestjs/common';
+
+type PrismaClientLike = any;
+
+type CourseProjectLink = {
+  projectId: number | null;
+  projectCode: string | null;
+  projectName: string | null;
+};
+
+type LessonTaskLink = {
+  taskId: number | null;
+  taskName: string | null;
+  taskStatus: string | null;
+  projectId: number | null;
+};
+
+@Injectable()
+export class CourseOperationsIntegrationService {
+  private operationsAvailability: boolean | null = null;
+
+  constructor(private readonly prisma: PrismaService) {}
+
+  async isOperationsModuleAvailable(client: PrismaClientLike = this.prisma) {
+    if (this.operationsAvailability !== null) {
+      return this.operationsAvailability;
+    }
+
+    try {
+      const rows = (await client.$queryRawUnsafe(`
+        SELECT table_name
+        FROM information_schema.tables
+        WHERE table_schema = current_schema()
+          AND table_name IN (
+            'operations_project',
+            'operations_task',
+            'operations_task_activity'
+          )
+      `)) as Array<{ table_name: string }>;
+
+      const availableTables = new Set(rows.map((row) => row.table_name));
+      this.operationsAvailability =
+        availableTables.has('operations_project') &&
+        availableTables.has('operations_task') &&
+        availableTables.has('operations_task_activity');
+    } catch {
+      this.operationsAvailability = false;
+    }
+
+    return this.operationsAvailability;
+  }
+
+  async resolveOperationsProjectId(
+    value?: number | null,
+    client: PrismaClientLike = this.prisma,
+  ) {
+    if (value === undefined) {
+      return undefined;
+    }
+
+    if (value === null) {
+      return null;
+    }
+
+    const normalizedId = Number(value);
+    if (!Number.isInteger(normalizedId) || normalizedId <= 0) {
+      throw new BadRequestException('Invalid operations project id');
+    }
+
+    if (!(await this.isOperationsModuleAvailable(client))) {
+      return normalizedId;
+    }
+
+    const rows = (await client.$queryRawUnsafe(
+      `
+        SELECT id
+        FROM operations_project
+        WHERE id = $1
+          AND deleted_at IS NULL
+        LIMIT 1
+      `,
+      normalizedId,
+    )) as Array<{ id: number }>;
+
+    if (!rows[0]?.id) {
+      throw new BadRequestException('Operations project not found');
+    }
+
+    return normalizedId;
+  }
+
+  async persistCourseProjectLink(
+    courseId: number,
+    projectId: number | null,
+    client: PrismaClientLike = this.prisma,
+  ) {
+    try {
+      await client.$executeRawUnsafe(
+        `
+          UPDATE course
+          SET operations_project_id = $1
+          WHERE id = $2
+        `,
+        projectId,
+        courseId,
+      );
+    } catch {
+      // Ignore while environments are catching up with the schema.
+    }
+  }
+
+  async getCourseProjectLinks(
+    courseIds: number[],
+    client: PrismaClientLike = this.prisma,
+  ) {
+    const links = new Map<number, CourseProjectLink>();
+    const normalizedIds = this.normalizeIds(courseIds);
+
+    if (normalizedIds.length === 0) {
+      return links;
+    }
+
+    const idsCsv = normalizedIds.join(',');
+
+    try {
+      if (await this.isOperationsModuleAvailable(client)) {
+        const rows = (await client.$queryRawUnsafe(`
+          SELECT c.id,
+                 c.operations_project_id AS "projectId",
+                 p.code AS "projectCode",
+                 p.name AS "projectName"
+          FROM course c
+          LEFT JOIN operations_project p
+            ON p.id = c.operations_project_id
+           AND p.deleted_at IS NULL
+          WHERE c.id IN (${idsCsv})
+        `)) as Array<{
+          id: number;
+          projectId: number | null;
+          projectCode: string | null;
+          projectName: string | null;
+        }>;
+
+        for (const row of rows) {
+          links.set(row.id, {
+            projectId: row.projectId,
+            projectCode: row.projectCode,
+            projectName: row.projectName,
+          });
+        }
+
+        return links;
+      }
+
+      const rows = (await client.$queryRawUnsafe(`
+        SELECT c.id,
+               c.operations_project_id AS "projectId"
+        FROM course c
+        WHERE c.id IN (${idsCsv})
+      `)) as Array<{
+        id: number;
+        projectId: number | null;
+      }>;
+
+      for (const row of rows) {
+        links.set(row.id, {
+          projectId: row.projectId,
+          projectCode: null,
+          projectName: null,
+        });
+      }
+    } catch {
+      return links;
+    }
+
+    return links;
+  }
+
+  async getLessonTaskLinks(
+    lessonIds: number[],
+    client: PrismaClientLike = this.prisma,
+  ) {
+    const links = new Map<number, LessonTaskLink>();
+    const normalizedIds = this.normalizeIds(lessonIds);
+
+    if (normalizedIds.length === 0) {
+      return links;
+    }
+
+    const idsCsv = normalizedIds.join(',');
+
+    try {
+      if (await this.isOperationsModuleAvailable(client)) {
+        const rows = (await client.$queryRawUnsafe(`
+          SELECT l.id,
+                 l.operations_task_id AS "taskId",
+                 t.name AS "taskName",
+                 t.status AS "taskStatus",
+                 t.project_id AS "projectId"
+          FROM course_lesson l
+          LEFT JOIN operations_task t
+            ON t.id = l.operations_task_id
+          WHERE l.id IN (${idsCsv})
+        `)) as Array<{
+          id: number;
+          taskId: number | null;
+          taskName: string | null;
+          taskStatus: string | null;
+          projectId: number | null;
+        }>;
+
+        for (const row of rows) {
+          links.set(row.id, {
+            taskId: row.taskId,
+            taskName: row.taskName,
+            taskStatus: row.taskStatus,
+            projectId: row.projectId,
+          });
+        }
+
+        return links;
+      }
+
+      const rows = (await client.$queryRawUnsafe(`
+        SELECT l.id,
+               l.operations_task_id AS "taskId"
+        FROM course_lesson l
+        WHERE l.id IN (${idsCsv})
+      `)) as Array<{
+        id: number;
+        taskId: number | null;
+      }>;
+
+      for (const row of rows) {
+        links.set(row.id, {
+          taskId: row.taskId,
+          taskName: null,
+          taskStatus: null,
+          projectId: null,
+        });
+      }
+    } catch {
+      return links;
+    }
+
+    return links;
+  }
+
+  async createTaskForLesson(
+    client: PrismaClientLike,
+    input: {
+      courseId: number;
+      lessonId: number;
+      projectId?: number | null;
+      courseTitle?: string | null;
+      sessionTitle?: string | null;
+      lessonTitle: string;
+      lessonDescription?: string | null;
+    },
+  ) {
+    const projectId = Number(input.projectId ?? 0);
+    if (!Number.isInteger(projectId) || projectId <= 0) {
+      return null;
+    }
+
+    if (!(await this.isOperationsModuleAvailable(client))) {
+      return null;
+    }
+
+    const projectRows = (await client.$queryRawUnsafe(
+      `
+        SELECT id
+        FROM operations_project
+        WHERE id = $1
+          AND deleted_at IS NULL
+        LIMIT 1
+      `,
+      projectId,
+    )) as Array<{ id: number }>;
+
+    if (!projectRows[0]?.id) {
+      throw new BadRequestException('Operations project not found');
+    }
+
+    const maxPositionRows = (await client.$queryRawUnsafe(
+      `
+        SELECT MAX(position) AS max_position
+        FROM operations_task
+        WHERE project_id = $1
+          AND status = 'todo'
+          AND deleted_at IS NULL
+      `,
+      projectId,
+    )) as Array<{ max_position: number | null }>;
+
+    const nextPosition = Number(maxPositionRows[0]?.max_position ?? -1) + 1;
+    const taskName = this.buildTaskName(input.lessonTitle);
+    const taskDescription = this.buildTaskDescription({
+      courseTitle: input.courseTitle,
+      sessionTitle: input.sessionTitle,
+      lessonDescription: input.lessonDescription,
+    });
+
+    const createdRows = (await client.$queryRawUnsafe(
+      `
+        INSERT INTO operations_task (
+          project_id,
+          name,
+          description,
+          priority,
+          status,
+          position,
+          tags,
+          total_doing_minutes,
+          created_at,
+          updated_at
+        )
+        VALUES (
+          $1,
+          $2,
+          $3,
+          'medium',
+          'todo',
+          $4,
+          $5,
+          0,
+          NOW(),
+          NOW()
+        )
+        RETURNING id
+      `,
+      projectId,
+      taskName,
+      taskDescription,
+      nextPosition,
+      `lms,course-${input.courseId},lesson-${input.lessonId}`,
+    )) as Array<{ id: number }>;
+
+    const taskId = createdRows[0]?.id ?? null;
+    if (!taskId) {
+      return null;
+    }
+
+    await client.$executeRawUnsafe(
+      `
+        INSERT INTO operations_task_activity (
+          task_id,
+          actor_collaborator_id,
+          action,
+          created_at
+        )
+        VALUES (
+          $1,
+          NULL,
+          'task_created',
+          NOW()
+        )
+      `,
+      taskId,
+    );
+
+    await client.$executeRawUnsafe(
+      `
+        UPDATE course_lesson
+        SET operations_task_id = $1
+        WHERE id = $2
+      `,
+      taskId,
+      input.lessonId,
+    );
+
+    return taskId;
+  }
+
+  async syncTaskForLesson(
+    lessonId: number,
+    client: PrismaClientLike = this.prisma,
+  ) {
+    if (!(await this.isOperationsModuleAvailable(client))) {
+      return;
+    }
+
+    const rows = (await client.$queryRawUnsafe(
+      `
+        SELECT l.operations_task_id AS "taskId",
+               l.title AS "lessonTitle",
+               l.description AS "lessonDescription",
+               m.title AS "sessionTitle",
+               c.title AS "courseTitle"
+        FROM course_lesson l
+        JOIN course_module m
+          ON m.id = l.course_module_id
+        JOIN course c
+          ON c.id = m.course_id
+        WHERE l.id = $1
+        LIMIT 1
+      `,
+      lessonId,
+    )) as Array<{
+      taskId: number | null;
+      lessonTitle: string;
+      lessonDescription: string | null;
+      sessionTitle: string | null;
+      courseTitle: string | null;
+    }>;
+
+    const row = rows[0];
+    if (!row?.taskId) {
+      return;
+    }
+
+    await client.$executeRawUnsafe(
+      `
+        UPDATE operations_task
+        SET name = $1,
+            description = $2,
+            updated_at = NOW()
+        WHERE id = $3
+          AND deleted_at IS NULL
+      `,
+      this.buildTaskName(row.lessonTitle),
+      this.buildTaskDescription({
+        courseTitle: row.courseTitle,
+        sessionTitle: row.sessionTitle,
+        lessonDescription: row.lessonDescription,
+      }),
+      row.taskId,
+    );
+  }
+
+  async createMissingTasksForCourseLessons(
+    courseId: number,
+    client: PrismaClientLike = this.prisma,
+  ) {
+    const projectLinks = await this.getCourseProjectLinks([courseId], client);
+    const projectId = projectLinks.get(courseId)?.projectId ?? null;
+
+    if (!projectId || !(await this.isOperationsModuleAvailable(client))) {
+      return 0;
+    }
+
+    const rows = (await client.$queryRawUnsafe(
+      `
+        SELECT l.id,
+               l.title AS "lessonTitle",
+               l.description AS "lessonDescription",
+               m.title AS "sessionTitle",
+               c.title AS "courseTitle"
+        FROM course_lesson l
+        JOIN course_module m
+          ON m.id = l.course_module_id
+        JOIN course c
+          ON c.id = m.course_id
+        WHERE c.id = $1
+          AND l.operations_task_id IS NULL
+        ORDER BY m."order" ASC, l."order" ASC, l.id ASC
+      `,
+      courseId,
+    )) as Array<{
+      id: number;
+      lessonTitle: string;
+      lessonDescription: string | null;
+      sessionTitle: string | null;
+      courseTitle: string | null;
+    }>;
+
+    let createdCount = 0;
+
+    for (const row of rows) {
+      const taskId = await this.createTaskForLesson(client, {
+        courseId,
+        lessonId: row.id,
+        projectId,
+        courseTitle: row.courseTitle,
+        sessionTitle: row.sessionTitle,
+        lessonTitle: row.lessonTitle,
+        lessonDescription: row.lessonDescription,
+      });
+
+      if (taskId) {
+        createdCount += 1;
+      }
+    }
+
+    return createdCount;
+  }
+
+  private normalizeIds(ids: number[]) {
+    return [...new Set(ids)]
+      .map((id) => Number(id))
+      .filter((id) => Number.isInteger(id) && id > 0);
+  }
+
+  private buildTaskName(lessonTitle: string) {
+    const normalizedTitle = this.normalizeOptionalText(lessonTitle) ?? 'Lesson';
+    return normalizedTitle.slice(0, 180);
+  }
+
+  private buildTaskDescription(input: {
+    courseTitle?: string | null;
+    sessionTitle?: string | null;
+    lessonDescription?: string | null;
+  }) {
+    const parts = [
+      input.courseTitle ? `Course: ${input.courseTitle}` : null,
+      input.sessionTitle ? `Session: ${input.sessionTitle}` : null,
+      input.lessonDescription
+        ? `Lesson summary:\n${input.lessonDescription}`
+        : null,
+    ].filter(Boolean);
+
+    return parts.length > 0 ? parts.join('\n\n') : null;
+  }
+
+  private normalizeOptionalText(value?: string | null) {
+    const normalized = value?.trim();
+    return normalized ? normalized : undefined;
+  }
+}

package/src/course/course-structure.controller.ts

@@ -1,13 +1,13 @@
 import { Role } from '@hed-hog/api';
 import {
-  Body,
-  Controller,
-  Delete,
-  Get,
-  Param,
-  ParseIntPipe,
-  Patch,
-  Post,
+    Body,
+    Controller,
+    Delete,
+    Get,
+    Param,
+    ParseIntPipe,
+    Patch,
+    Post,
 } from '@nestjs/common';
 import { CourseStructureService } from './course-structure.service';
 import { CreateCourseStructureLessonDto } from './dto/create-course-structure-lesson.dto';
@@ -16,6 +16,7 @@ import { MoveLessonDto } from './dto/move-lesson.dto';
 import { PasteLessonsDto } from './dto/paste-lessons.dto';
 import { ReorderLessonsDto } from './dto/reorder-lessons.dto';
 import { ReorderSessionsDto } from './dto/reorder-sessions.dto';
+import { UpdateCourseResourcesDto } from './dto/update-course-resources.dto';
 import { UpdateCourseStructureLessonDto } from './dto/update-course-structure-lesson.dto';
 import { UpdateCourseStructureSessionDto } from './dto/update-course-structure-session.dto';
 
@@ -29,6 +30,19 @@ export class CourseStructureController {
     return this.courseStructureService.getStructure(courseId);
   }
 
+  @Get('resources')
+  getCourseResources(@Param('id', ParseIntPipe) courseId: number) {
+    return this.courseStructureService.getCourseResources(courseId);
+  }
+
+  @Patch('resources')
+  updateCourseResources(
+    @Param('id', ParseIntPipe) courseId: number,
+    @Body() dto: UpdateCourseResourcesDto,
+  ) {
+    return this.courseStructureService.updateCourseResources(courseId, dto);
+  }
+
   // ── Sessions ──────────────────────────────────────────────────────────────
 
   @Post('sessions')