@hed-hog/lms 0.0.304 → 0.0.306

package/src/evaluation/evaluation.controller.ts

@@ -0,0 +1,44 @@
+import { Role } from '@hed-hog/api';
+import { Controller, Get, Query } from '@nestjs/common';
+import { EvaluationService } from './evaluation.service';
+
+@Role()
+@Controller('lms/evaluations')
+export class EvaluationController {
+  constructor(private readonly evaluationService: EvaluationService) {}
+
+  @Get('stats')
+  stats() {
+    return this.evaluationService.stats();
+  }
+
+  @Get('filter-options')
+  filterOptions() {
+    return this.evaluationService.filterOptions();
+  }
+
+  @Get()
+  list(
+    @Query('page') page?: string,
+    @Query('pageSize') pageSize?: string,
+    @Query('search') search?: string,
+    @Query('courseId') courseId?: string,
+    @Query('classId') classId?: string,
+    @Query('instructorId') instructorId?: string,
+    @Query('evaluatorId') evaluatorId?: string,
+    @Query('dateFrom') dateFrom?: string,
+    @Query('dateTo') dateTo?: string,
+  ) {
+    return this.evaluationService.list({
+      page: page ? Number(page) : 1,
+      pageSize: pageSize ? Number(pageSize) : 12,
+      search,
+      courseId: courseId ? Number(courseId) : undefined,
+      classId: classId ? Number(classId) : undefined,
+      instructorId: instructorId ? Number(instructorId) : undefined,
+      evaluatorId: evaluatorId ? Number(evaluatorId) : undefined,
+      dateFrom,
+      dateTo,
+    });
+  }
+}

package/src/evaluation/evaluation.module.ts

@@ -0,0 +1,12 @@
+import { PrismaModule } from '@hed-hog/api-prisma';
+import { forwardRef, Module } from '@nestjs/common';
+import { EvaluationController } from './evaluation.controller';
+import { EvaluationService } from './evaluation.service';
+
+@Module({
+  imports: [forwardRef(() => PrismaModule)],
+  controllers: [EvaluationController],
+  providers: [EvaluationService],
+  exports: [forwardRef(() => EvaluationService)],
+})
+export class EvaluationModule {}

package/src/evaluation/evaluation.service.ts

@@ -0,0 +1,394 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class EvaluationService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  async list(params: {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+    courseId?: number;
+    classId?: number;
+    instructorId?: number;
+    evaluatorId?: number;
+    dateFrom?: string;
+    dateTo?: string;
+  }) {
+    const page = Math.max(Number(params.page) || 1, 1);
+    const pageSize = Math.max(Number(params.pageSize) || 12, 1);
+    const skip = (page - 1) * pageSize;
+
+    const where: any = {};
+
+    if (params.evaluatorId) {
+      where.evaluator_id = params.evaluatorId;
+    }
+
+    if (params.dateFrom || params.dateTo) {
+      where.created_at = {};
+      if (params.dateFrom) {
+        where.created_at.gte = new Date(params.dateFrom);
+      }
+      if (params.dateTo) {
+        const to = new Date(params.dateTo);
+        to.setHours(23, 59, 59, 999);
+        where.created_at.lte = to;
+      }
+    }
+
+    if (params.search) {
+      where.OR = [
+        { comment: { contains: params.search, mode: 'insensitive' } },
+        {
+          evaluation_topic: {
+            name: { contains: params.search, mode: 'insensitive' },
+          },
+        },
+        {
+          evaluation_topic: {
+            course: { title: { contains: params.search, mode: 'insensitive' } },
+          },
+        },
+        {
+          evaluation_topic: {
+            course_lesson: {
+              title: { contains: params.search, mode: 'insensitive' },
+            },
+          },
+        },
+        {
+          evaluation_topic: {
+            course_class_session: {
+              title: { contains: params.search, mode: 'insensitive' },
+            },
+          },
+        },
+        {
+          evaluation_topic: {
+            exam: { title: { contains: params.search, mode: 'insensitive' } },
+          },
+        },
+        {
+          evaluation_topic: {
+            question: {
+              statement: { contains: params.search, mode: 'insensitive' },
+            },
+          },
+        },
+      ];
+    }
+
+    // Build evaluation_topic nested filter
+    const topicWhere: Record<string, any> = {};
+
+    if (params.courseId) {
+      topicWhere.OR = [
+        { course_id: params.courseId },
+        {
+          course_lesson: {
+            course_module: { course_id: params.courseId },
+          },
+        },
+        {
+          course_class_session: {
+            course_class_group: { course_id: params.courseId },
+          },
+        },
+        { exam: { course_id: params.courseId } },
+      ];
+    }
+
+    const sessionWhere: Record<string, any> = {};
+    if (params.classId) {
+      sessionWhere.course_class_group_id = params.classId;
+    }
+    if (params.instructorId) {
+      sessionWhere.course_class_group = { instructor_id: params.instructorId };
+    }
+    if (Object.keys(sessionWhere).length > 0) {
+      topicWhere.course_class_session = sessionWhere;
+    }
+
+    if (Object.keys(topicWhere).length > 0) {
+      where.evaluation_topic = topicWhere;
+    }
+
+    const include = {
+      evaluation_topic: {
+        include: {
+          course: { select: { id: true, title: true } },
+          course_lesson: {
+            select: {
+              id: true,
+              title: true,
+              course_module: {
+                select: {
+                  course: { select: { id: true, title: true } },
+                },
+              },
+            },
+          },
+          course_class_session: {
+            select: {
+              id: true,
+              title: true,
+              course_class_group: {
+                select: {
+                  id: true,
+                  title: true,
+                  course: { select: { id: true, title: true } },
+                  instructor: {
+                    select: {
+                      id: true,
+                      person: { select: { id: true, name: true } },
+                    },
+                  },
+                },
+              },
+            },
+          },
+          question: { select: { id: true, statement: true } },
+          exam: {
+            select: {
+              id: true,
+              title: true,
+              course: { select: { id: true, title: true } },
+            },
+          },
+        },
+      },
+      person: { select: { id: true, name: true } },
+    } as const;
+
+    const [ratings, total] = await Promise.all([
+      this.prisma.evaluation_rating.findMany({
+        where,
+        skip,
+        take: pageSize,
+        orderBy: { created_at: 'desc' },
+        include,
+      }),
+      this.prisma.evaluation_rating.count({ where }),
+    ]);
+
+    // Compute per-topic aggregates for comparison bars in the detail sheet
+    const topicIds = [...new Set(ratings.map((r) => r.evaluation_topic_id))];
+    const topicAggregates =
+      topicIds.length > 0
+        ? await this.prisma.evaluation_rating.groupBy({
+            by: ['evaluation_topic_id'],
+            where: { evaluation_topic_id: { in: topicIds } },
+            _avg: { score: true },
+            _count: { id: true },
+          })
+        : [];
+
+    const aggregateMap = new Map(
+      topicAggregates.map((a) => [
+        a.evaluation_topic_id,
+        {
+          avg: Math.round(Number(a._avg.score ?? 0) * 10) / 10,
+          count: a._count.id,
+        },
+      ]),
+    );
+
+    return {
+      total,
+      page,
+      pageSize,
+      lastPage: Math.max(1, Math.ceil(total / pageSize)),
+      data: ratings.map((r) => this.mapRating(r, aggregateMap.get(r.evaluation_topic_id))),
+    };
+  }
+
+  private mapRating(r: any, topicAggregate?: { avg: number; count: number }) {
+    const topic = r.evaluation_topic;
+    const targetType: string = topic.target_type;
+
+    let targetName = '';
+    let courseName: string | null = null;
+    let courseId: number | null = null;
+    let className: string | null = null;
+    let classId: number | null = null;
+    let instructorName: string | null = null;
+    let instructorId: number | null = null;
+
+    if (targetType === 'course' && topic.course) {
+      targetName = topic.course.title;
+      courseName = topic.course.title;
+      courseId = topic.course.id;
+    } else if (targetType === 'course_lesson' && topic.course_lesson) {
+      targetName = topic.course_lesson.title;
+      const c = topic.course_lesson.course_module?.course;
+      if (c) {
+        courseName = c.title;
+        courseId = c.id;
+      }
+    } else if (
+      targetType === 'course_class_session' &&
+      topic.course_class_session
+    ) {
+      const session = topic.course_class_session;
+      targetName = session.title;
+      const group = session.course_class_group;
+      if (group) {
+        className = group.title;
+        classId = group.id;
+        if (group.course) {
+          courseName = group.course.title;
+          courseId = group.course.id;
+        }
+        if (group.instructor?.person) {
+          instructorName = group.instructor.person.name;
+          instructorId = group.instructor.person.id;
+        }
+      }
+    } else if (targetType === 'question' && topic.question) {
+      targetName = topic.question.statement;
+    } else if (targetType === 'exam' && topic.exam) {
+      targetName = topic.exam.title;
+      if (topic.exam.course) {
+        courseName = topic.exam.course.title;
+        courseId = topic.exam.course.id;
+      }
+    }
+
+    const score = Number(r.score);
+
+    return {
+      id: r.id,
+      topicName: topic.name,
+      topicDescription: topic.description ?? null,
+      targetType,
+      targetName,
+      score,
+      comment: r.comment ?? null,
+      evaluatorName: r.person?.name ?? null,
+      evaluatorId: r.evaluator_id ?? null,
+      courseName,
+      courseId,
+      className,
+      classId,
+      instructorName,
+      instructorId,
+      createdAt: r.created_at,
+      topicAvgScore: topicAggregate?.avg ?? score,
+      topicRatingCount: topicAggregate?.count ?? 1,
+    };
+  }
+
+  async stats() {
+    const [totalEvaluations, avgResult, topicsEvaluated, evaluatorGroups] =
+      await Promise.all([
+        this.prisma.evaluation_rating.count(),
+        this.prisma.evaluation_rating.aggregate({ _avg: { score: true } }),
+        this.prisma.evaluation_topic.count({
+          where: { evaluation_rating: { some: {} } },
+        }),
+        this.prisma.evaluation_rating.groupBy({
+          by: ['evaluator_id'],
+          where: { evaluator_id: { not: null } },
+        }),
+      ]);
+
+    return {
+      totalEvaluations,
+      averageScore: Math.round(Number(avgResult._avg.score ?? 0) * 10) / 10,
+      topicsEvaluated,
+      totalEvaluators: evaluatorGroups.length,
+    };
+  }
+
+  async filterOptions() {
+    const topics = await this.prisma.evaluation_topic.findMany({
+      where: { evaluation_rating: { some: {} } },
+      select: {
+        course: { select: { id: true, title: true } },
+        course_lesson: {
+          select: {
+            course_module: {
+              select: {
+                course: { select: { id: true, title: true } },
+              },
+            },
+          },
+        },
+        course_class_session: {
+          select: {
+            course_class_group: {
+              select: {
+                id: true,
+                title: true,
+                course: { select: { id: true, title: true } },
+                instructor: {
+                  select: {
+                    id: true,
+                    person: { select: { id: true, name: true } },
+                  },
+                },
+              },
+            },
+          },
+        },
+        exam: {
+          select: { course: { select: { id: true, title: true } } },
+        },
+      },
+    });
+
+    const coursesMap = new Map<number, string>();
+    const classesMap = new Map<number, string>();
+    const instructorsMap = new Map<number, string>(); // key = instructor.id
+
+    for (const topic of topics) {
+      if (topic.course) {
+        coursesMap.set(topic.course.id, topic.course.title);
+      }
+      const lessonCourse = topic.course_lesson?.course_module?.course;
+      if (lessonCourse) {
+        coursesMap.set(lessonCourse.id, lessonCourse.title);
+      }
+      const group = topic.course_class_session?.course_class_group;
+      if (group) {
+        classesMap.set(group.id, group.title);
+        if (group.course) {
+          coursesMap.set(group.course.id, group.course.title);
+        }
+        if (group.instructor?.person) {
+          instructorsMap.set(group.instructor.id, group.instructor.person.name);
+        }
+      }
+      const examCourse = topic.exam?.course;
+      if (examCourse) {
+        coursesMap.set(examCourse.id, examCourse.title);
+      }
+    }
+
+    const evaluatorRatings = await this.prisma.evaluation_rating.findMany({
+      where: { evaluator_id: { not: null } },
+      select: { person: { select: { id: true, name: true } } },
+      distinct: ['evaluator_id'],
+      orderBy: { evaluator_id: 'asc' },
+    });
+
+    return {
+      courses: Array.from(coursesMap.entries()).map(([id, label]) => ({
+        id,
+        label,
+      })),
+      classes: Array.from(classesMap.entries()).map(([id, label]) => ({
+        id,
+        label,
+      })),
+      instructors: Array.from(instructorsMap.entries()).map(
+        ([id, label]) => ({ id, label }),
+      ),
+      evaluators: evaluatorRatings
+        .filter((r) => r.person)
+        .map((r) => ({ id: r.person!.id, label: r.person!.name })),
+    };
+  }
+}

package/src/exam/dto/create-exam-question.dto.ts

@@ -0,0 +1,103 @@
+import { Type } from 'class-transformer';
+import {
+    ArrayMinSize,
+    IsArray,
+    IsBoolean,
+    IsIn,
+    IsInt,
+    IsNotEmpty,
+    IsOptional,
+    IsString,
+    MaxLength,
+    Min,
+    ValidateNested,
+} from 'class-validator';
+
+export const EXAM_QUESTION_TYPES = [
+  'multiple_choice',
+  'true_false',
+  'essay',
+  'fill_blank',
+  'matching',
+] as const;
+
+export type ExamQuestionType = (typeof EXAM_QUESTION_TYPES)[number];
+
+export const OBJECTIVE_EXAM_QUESTION_TYPES: ExamQuestionType[] = [
+  'multiple_choice',
+  'true_false',
+];
+
+export class ExamQuestionAlternativeDto {
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(2000)
+  text: string;
+
+  @IsBoolean()
+  isCorrect: boolean;
+}
+
+export class FillBlankAnswerDto {
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(2000)
+  answer: string;
+
+  @IsArray()
+  @IsString({ each: true })
+  @IsOptional()
+  alternatives?: string[];
+}
+
+export class MatchingPairDto {
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(100)
+  id: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(2000)
+  leftText: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(2000)
+  rightText: string;
+}
+
+export class CreateExamQuestionDto {
+  @IsString()
+  @IsNotEmpty()
+  statement: string;
+
+  @IsString()
+  @IsIn(EXAM_QUESTION_TYPES)
+  @IsOptional()
+  questionType?: ExamQuestionType;
+
+  @IsInt()
+  @Min(1)
+  points: number;
+
+  @IsArray()
+  @ValidateNested({ each: true })
+  @Type(() => ExamQuestionAlternativeDto)
+  @IsOptional()
+  alternatives?: ExamQuestionAlternativeDto[];
+
+  @IsArray()
+  @ArrayMinSize(1)
+  @ValidateNested({ each: true })
+  @Type(() => FillBlankAnswerDto)
+  @IsOptional()
+  fillBlankAnswers?: FillBlankAnswerDto[];
+
+  @IsArray()
+  @ArrayMinSize(2)
+  @ValidateNested({ each: true })
+  @Type(() => MatchingPairDto)
+  @IsOptional()
+  matchingPairs?: MatchingPairDto[];
+}

package/src/exam/dto/create-exam.dto.ts

@@ -0,0 +1,41 @@
+import { IsBoolean, IsEnum, IsNotEmpty, IsNumber, IsOptional, IsString, MaxLength, Min } from 'class-validator';
+
+export class CreateExamDto {
+  @IsString()
+  @IsOptional()
+  @MaxLength(32)
+  code?: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(255)
+  title: string;
+
+  @IsNumber()
+  @Min(0)
+  @IsOptional()
+  minScore?: number;
+
+  @IsNumber()
+  @Min(1)
+  @IsOptional()
+  timeLimit?: number;
+
+  @IsBoolean()
+  @IsOptional()
+  shuffle?: boolean;
+
+  @IsEnum(['draft', 'published', 'closed', 'archived'])
+  @IsOptional()
+  status?: 'draft' | 'published' | 'closed' | 'archived';
+
+  @IsString()
+  @IsOptional()
+  @MaxLength(32)
+  primaryColor?: string;
+
+  @IsString()
+  @IsOptional()
+  @MaxLength(32)
+  secondaryColor?: string;
+}

package/src/exam/dto/reorder-exam-questions.dto.ts

@@ -0,0 +1,8 @@
+import { ArrayMinSize, IsArray, IsInt } from 'class-validator';
+
+export class ReorderExamQuestionsDto {
+  @IsArray()
+  @ArrayMinSize(1)
+  @IsInt({ each: true })
+  questionIds: number[];
+}

package/src/exam/dto/save-exam-attempt-answers.dto.ts

@@ -0,0 +1,55 @@
+import { Type } from 'class-transformer';
+import {
+    ArrayMinSize,
+    IsArray,
+    IsInt,
+    IsNotEmpty,
+    IsOptional,
+    IsString,
+    MaxLength,
+    Min,
+    ValidateNested,
+} from 'class-validator';
+
+export class SaveExamAttemptMatchingPairDto {
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(100)
+  leftId: string;
+
+  @IsString()
+  @IsNotEmpty()
+  @MaxLength(100)
+  rightId: string;
+}
+
+export class SaveExamAttemptAnswerDto {
+  @IsInt()
+  @Min(1)
+  questionId: number;
+
+  @IsInt()
+  @Min(1)
+  @IsOptional()
+  examOptionId?: number | null;
+
+  @IsString()
+  @MaxLength(10000)
+  @IsOptional()
+  answerText?: string | null;
+
+  @IsArray()
+  @ArrayMinSize(0)
+  @ValidateNested({ each: true })
+  @Type(() => SaveExamAttemptMatchingPairDto)
+  @IsOptional()
+  matchingPairs?: SaveExamAttemptMatchingPairDto[];
+}
+
+export class SaveExamAttemptAnswersDto {
+  @IsArray()
+  @ArrayMinSize(0)
+  @ValidateNested({ each: true })
+  @Type(() => SaveExamAttemptAnswerDto)
+  answers: SaveExamAttemptAnswerDto[];
+}

package/src/exam/dto/start-exam-attempt.dto.ts

@@ -0,0 +1,8 @@
+import { IsInt, IsOptional, Min } from 'class-validator';
+
+export class StartExamAttemptDto {
+  @IsInt()
+  @Min(1)
+  @IsOptional()
+  studentId?: number;
+}

package/src/exam/dto/submit-exam-attempt.dto.ts

@@ -0,0 +1,8 @@
+import { IsBoolean, IsOptional } from 'class-validator';
+import { SaveExamAttemptAnswersDto } from './save-exam-attempt-answers.dto';
+
+export class SubmitExamAttemptDto extends SaveExamAttemptAnswersDto {
+  @IsBoolean()
+  @IsOptional()
+  force?: boolean;
+}

package/src/exam/dto/update-exam-question.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateExamQuestionDto } from './create-exam-question.dto';
+
+export class UpdateExamQuestionDto extends PartialType(CreateExamQuestionDto) {}

package/src/exam/dto/update-exam.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/mapped-types';
+import { CreateExamDto } from './create-exam.dto';
+
+export class UpdateExamDto extends PartialType(CreateExamDto) {}