@hed-hog/lms 0.0.304 → 0.0.306

package/src/course/course.service.ts

@@ -0,0 +1,920 @@
+import { PrismaService } from '@hed-hog/api-prisma';
+import { BadRequestException, Injectable } from '@nestjs/common';
+import { CreateCourseDto } from './dto/create-course.dto';
+import { UpdateCourseDto } from './dto/update-course.dto';
+
+type CourseImageTypeSlug = 'course-logo' | 'course-banner';
+
+type CourseExtraFields = {
+  code?: string | null;
+  is_featured?: boolean | null;
+  has_certificate?: boolean | null;
+  is_listed?: boolean | null;
+  offering_type?: 'scheduled' | 'on_demand' | 'blended' | null;
+};
+
+type PersistCourseExtrasInput = {
+  code?: string;
+  isFeatured?: boolean;
+  hasCertificate?: boolean;
+  isListed?: boolean;
+  offeringType?: 'scheduled' | 'on_demand' | 'blended';
+};
+
+@Injectable()
+export class CourseService {
+  constructor(private readonly prisma: PrismaService) {}
+
+  private normalizeLevel(value?: string | null) {
+    if (!value) return undefined;
+    const normalized = String(value).trim().toLowerCase();
+    if (normalized === 'beginner' || normalized === 'iniciante') {
+      return 'beginner';
+    }
+    if (normalized === 'intermediate' || normalized === 'intermediario') {
+      return 'intermediate';
+    }
+    if (normalized === 'advanced' || normalized === 'avancado') {
+      return 'advanced';
+    }
+    return undefined;
+  }
+
+  private normalizeStatus(value?: string | null) {
+    if (!value) return undefined;
+    const normalized = String(value).trim().toLowerCase();
+    if (
+      normalized === 'published' ||
+      normalized === 'active' ||
+      normalized === 'ativo'
+    ) {
+      return 'published';
+    }
+    if (normalized === 'draft' || normalized === 'rascunho') {
+      return 'draft';
+    }
+    if (normalized === 'archived' || normalized === 'arquivado') {
+      return 'archived';
+    }
+    return undefined;
+  }
+
+  private normalizeOfferingType(value?: string | null) {
+    if (!value) return undefined;
+
+    const normalized = String(value).trim().toLowerCase();
+    if (normalized === 'scheduled') {
+      return 'scheduled';
+    }
+    if (
+      normalized === 'on_demand' ||
+      normalized === 'ondemand' ||
+      normalized === 'on-demand'
+    ) {
+      return 'on_demand';
+    }
+    if (normalized === 'blended') {
+      return 'blended';
+    }
+
+    return undefined;
+  }
+
+  private normalizeOptionalText(value?: string | null) {
+    const normalized = value?.trim();
+    return normalized ? normalized : undefined;
+  }
+
+  private resolveCourseTitle(title: string | undefined, slug: string) {
+    return this.normalizeOptionalText(title) ?? slug;
+  }
+
+  async list(params: {
+    page?: number;
+    pageSize?: number;
+    search?: string;
+    status?: string;
+    level?: string;
+    category?: 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 = {};
+
+    const normalizedStatus = this.normalizeStatus(params.status);
+    const normalizedLevel = this.normalizeLevel(params.level);
+
+    if (normalizedStatus) {
+      where.status = normalizedStatus;
+    }
+    if (normalizedLevel) {
+      where.level = normalizedLevel;
+    }
+    if (params.search) {
+      where.OR = [
+        { title: { contains: params.search, mode: 'insensitive' } },
+        { slug: { contains: params.search, mode: 'insensitive' } },
+      ];
+    }
+    if (params.category) {
+      where.course_category = {
+        some: { category: { slug: params.category } },
+      };
+    }
+
+    const [courses, total] = await Promise.all([
+      this.prisma.course.findMany({
+        skip,
+        take: pageSize,
+        where,
+        orderBy: { created_at: 'desc' },
+        include: {
+          course_category: {
+            include: {
+              category: {
+                select: { id: true, slug: true },
+              },
+            },
+          },
+          course_image: {
+            where: {
+              image_type: {
+                slug: { in: ['course-logo', 'course-banner'] },
+              },
+            },
+            include: {
+              image_type: {
+                select: { slug: true },
+              },
+              file: {
+                select: { id: true, filename: true },
+              },
+            },
+            orderBy: [{ is_primary: 'desc' }, { order: 'asc' }],
+          },
+          _count: {
+            select: { course_enrollment: true, course_class_group: true },
+          },
+        },
+      }),
+      this.prisma.course.count({ where }),
+    ]);
+
+    const extrasById = await this.getCourseExtras(
+      courses.map((course) => course.id),
+    );
+
+    return {
+      total,
+      page,
+      pageSize,
+      lastPage: Math.max(1, Math.ceil(total / pageSize)),
+      data: courses.map((c) => this.mapCourse(c, undefined, extrasById.get(c.id))),
+    };
+  }
+
+  async stats() {
+    const [total, published, totalStudents] = await Promise.all([
+      this.prisma.course.count(),
+      this.prisma.course.count({ where: { status: 'published' } }),
+      this.prisma.course_enrollment.count(),
+    ]);
+
+    const featured = await this.getFeaturedCoursesCount();
+
+    return {
+      totalCourses: total,
+      publishedCourses: published,
+      featuredCourses: featured,
+      totalStudents,
+    };
+  }
+
+  async getById(id: number) {
+    const c = await this.prisma.course.findUnique({
+      where: { id },
+      include: {
+        course_category: {
+          include: {
+            category: { select: { id: true, slug: true } },
+          },
+        },
+        course_image: {
+          where: {
+            image_type: {
+              slug: { in: ['course-logo', 'course-banner'] },
+            },
+          },
+          include: {
+            image_type: {
+              select: { slug: true },
+            },
+            file: {
+              select: { id: true, filename: true },
+            },
+          },
+          orderBy: [{ is_primary: 'desc' }, { order: 'asc' }],
+        },
+        course_instructor: {
+          include: {
+            instructor: {
+              select: {
+                id: true,
+                person: {
+                  select: {
+                    id: true,
+                    name: true,
+                    avatar_id: true,
+                  },
+                },
+              },
+            },
+          },
+        },
+        _count: {
+          select: {
+            course_enrollment: true,
+            course_module: true,
+            course_class_group: true,
+            certificate: true,
+          },
+        },
+      },
+    });
+
+    if (!c) return null;
+
+    const extrasById = await this.getCourseExtras([id]);
+
+    const [lessonCount, sessionCount, certificatesIssued, avgProgress, modules] =
+      await Promise.all([
+        this.prisma.course_lesson.count({
+          where: { course_module: { course_id: id } },
+        }),
+        this.prisma.course_class_session.count({
+          where: { course_class_group: { course_id: id } },
+        }),
+        this.prisma.certificate.count({
+          where: { course_id: id },
+        }),
+        this.prisma.course_enrollment.aggregate({
+          where: { course_id: id },
+          _avg: { progress_percent: true },
+        }),
+        this.prisma.course_module.findMany({
+          where: { course_id: id },
+          orderBy: { order: 'asc' },
+          select: {
+            id: true,
+            title: true,
+            course_lesson: {
+              select: {
+                course_lesson_progress: {
+                  select: { progress_percent: true },
+                },
+              },
+            },
+          },
+        }),
+      ]);
+
+    const progressByModule = modules.map((module) => {
+      const values = module.course_lesson.flatMap((lesson) =>
+        lesson.course_lesson_progress.map((progress) => progress.progress_percent),
+      );
+
+      const average =
+        values.length > 0
+          ? Math.round(values.reduce((sum, value) => sum + value, 0) / values.length)
+          : 0;
+
+      return {
+        moduleId: module.id,
+        moduleTitle: module.title,
+        progress: average,
+      };
+    });
+
+    return this.mapCourse(c, {
+      lessonCount,
+      sessionCount,
+      certificatesIssued,
+      averageCompletion: avgProgress._avg.progress_percent ?? 0,
+      progressByModule,
+    }, extrasById.get(id));
+  }
+
+  async create(dto: CreateCourseDto) {
+    const { categorySlugs, logoFileId, bannerFileId, instructorIds, ...data } = dto;
+    const normalizedSlug = data.slug.trim();
+    const resolvedCode = this.normalizeCourseCode(data.code ?? normalizedSlug);
+    const resolvedTitle = this.resolveCourseTitle(data.title, normalizedSlug);
+
+    const categories = categorySlugs?.length
+      ? await this.prisma.category.findMany({
+          where: { slug: { in: categorySlugs } },
+          select: { id: true },
+        })
+      : [];
+
+    // Validate instructor IDs if provided
+    let validInstructorIds: number[] = [];
+    if (instructorIds?.length) {
+      const instructors = await this.prisma.instructor.findMany({
+        where: { id: { in: instructorIds } },
+        select: { id: true },
+      });
+      const validIds = new Set(instructors.map((i) => i.id));
+      validInstructorIds = instructorIds.filter((id) => validIds.has(id));
+    }
+
+    const c = await this.prisma.course.create({
+      data: {
+        slug: normalizedSlug,
+        title: resolvedTitle,
+        ...(data.description !== undefined && {
+          description: data.description,
+        }),
+        level: this.normalizeLevel(data.level) ?? 'beginner',
+        status: this.normalizeStatus(data.status) ?? 'draft',
+        ...(data.requirements !== undefined && {
+          requirements: data.requirements,
+        }),
+        ...(data.objectives !== undefined && {
+          objectives: data.objectives,
+        }),
+        ...(data.targetAudience !== undefined && {
+          target_audience: data.targetAudience,
+        }),
+        ...(data.durationHours !== undefined && {
+          duration_hours: data.durationHours,
+        }),
+        ...(data.certificateWorkload !== undefined && {
+          certificate_workload: data.certificateWorkload,
+        }),
+        ...(data.primaryColor !== undefined && {
+          primary_color: data.primaryColor,
+        }),
+        ...(data.primaryContrastColor !== undefined && {
+          primary_contrast_color: data.primaryContrastColor,
+        }),
+        ...(data.secondaryColor !== undefined && {
+          secondary_color: data.secondaryColor,
+        }),
+        ...(data.secondaryContrastColor !== undefined && {
+          secondary_contrast_color: data.secondaryContrastColor,
+        }),
+        ...(categories.length > 0 && {
+          course_category: {
+            create: categories.map((item) => ({ category_id: item.id })),
+          },
+        }),
+        ...(validInstructorIds.length > 0 && {
+          course_instructor: {
+            create: validInstructorIds.map((instructorId) => ({
+              instructor_id: instructorId,
+              role: 'lead',
+            })),
+          },
+        }),
+      },
+      include: {
+        course_category: {
+          include: { category: { select: { id: true, slug: true } } },
+        },
+        course_image: {
+          where: {
+            image_type: {
+              slug: { in: ['course-logo', 'course-banner'] },
+            },
+          },
+          include: {
+            image_type: {
+              select: { slug: true },
+            },
+            file: {
+              select: { id: true, filename: true },
+            },
+          },
+          orderBy: [{ is_primary: 'desc' }, { order: 'asc' }],
+        },
+        course_instructor: {
+          include: {
+            instructor: {
+              select: {
+                id: true,
+                person: {
+                  select: {
+                    id: true,
+                    name: true,
+                    avatar_id: true,
+                  },
+                },
+              },
+            },
+          },
+        },
+        _count: { select: { course_enrollment: true } },
+      },
+    });
+
+    await this.syncCourseImages(c.id, {
+      logoFileId,
+      bannerFileId,
+    });
+
+    await this.persistCourseExtras(c.id, {
+      ...data,
+      ...(resolvedCode && { code: resolvedCode }),
+      offeringType: this.normalizeOfferingType(data.offeringType) ?? 'on_demand',
+    });
+
+    const extrasById = await this.getCourseExtras([c.id]);
+
+    return this.mapCourse(c, undefined, extrasById.get(c.id));
+  }
+
+  async update(id: number, dto: UpdateCourseDto) {
+    const { categorySlugs, logoFileId, bannerFileId, instructorIds, ...data } = dto;
+    let existingSlug: string | undefined;
+
+    if (
+      data.title !== undefined &&
+      this.normalizeOptionalText(data.title) === undefined &&
+      data.slug === undefined
+    ) {
+      const currentCourse = await this.prisma.course.findUnique({
+        where: { id },
+        select: { slug: true },
+      });
+
+      existingSlug = currentCourse?.slug;
+    }
+
+    const resolvedSlug = data.slug !== undefined ? data.slug.trim() : undefined;
+    const resolvedTitle =
+      data.title !== undefined
+        ? this.resolveCourseTitle(data.title, resolvedSlug ?? existingSlug ?? '')
+        : undefined;
+
+    const categories = categorySlugs?.length
+      ? await this.prisma.category.findMany({
+          where: { slug: { in: categorySlugs } },
+          select: { id: true },
+        })
+      : [];
+
+    // Validate instructor IDs if provided
+    let validInstructorIds: number[] | undefined;
+    if (instructorIds !== undefined) {
+      if (instructorIds.length === 0) {
+        validInstructorIds = [];
+      } else {
+        const instructors = await this.prisma.instructor.findMany({
+          where: { id: { in: instructorIds } },
+          select: { id: true },
+        });
+        const validIds = new Set(instructors.map((i) => i.id));
+        validInstructorIds = instructorIds.filter((id) => validIds.has(id));
+      }
+    }
+
+    if (categorySlugs !== undefined) {
+      await this.prisma.course_category.deleteMany({
+        where: { course_id: id },
+      });
+    }
+
+    const c = await this.prisma.course.update({
+      where: { id },
+      data: {
+        ...(resolvedSlug !== undefined && { slug: resolvedSlug }),
+        ...(resolvedTitle !== undefined && { title: resolvedTitle }),
+        ...(data.description !== undefined && { description: data.description }),
+        ...(data.level !== undefined && {
+          level: this.normalizeLevel(data.level),
+        }),
+        ...(data.status !== undefined && {
+          status: this.normalizeStatus(data.status),
+        }),
+        ...(data.requirements !== undefined && {
+          requirements: data.requirements,
+        }),
+        ...(data.objectives !== undefined && {
+          objectives: data.objectives,
+        }),
+        ...(data.targetAudience !== undefined && {
+          target_audience: data.targetAudience,
+        }),
+        ...(data.durationHours !== undefined && {
+          duration_hours: data.durationHours,
+        }),
+        ...(data.certificateWorkload !== undefined && {
+          certificate_workload: data.certificateWorkload,
+        }),
+        ...(data.primaryColor !== undefined && {
+          primary_color: data.primaryColor,
+        }),
+        ...(data.primaryContrastColor !== undefined && {
+          primary_contrast_color: data.primaryContrastColor,
+        }),
+        ...(data.secondaryColor !== undefined && {
+          secondary_color: data.secondaryColor,
+        }),
+        ...(data.secondaryContrastColor !== undefined && {
+          secondary_contrast_color: data.secondaryContrastColor,
+        }),
+        ...(categories.length > 0 && {
+          course_category: {
+            create: categories.map((item) => ({ category_id: item.id })),
+          },
+        }),
+      },
+      include: {
+        course_category: {
+          include: { category: { select: { id: true, slug: true } } },
+        },
+        course_image: {
+          where: {
+            image_type: {
+              slug: { in: ['course-logo', 'course-banner'] },
+            },
+          },
+          include: {
+            image_type: {
+              select: { slug: true },
+            },
+            file: {
+              select: { id: true, filename: true },
+            },
+          },
+          orderBy: [{ is_primary: 'desc' }, { order: 'asc' }],
+        },
+        course_instructor: {
+          include: {
+            instructor: {
+              select: {
+                id: true,
+                person: {
+                  select: {
+                    id: true,
+                    name: true,
+                    avatar_id: true,
+                  },
+                },
+              },
+            },
+          },
+        },
+        _count: { select: { course_enrollment: true } },
+      },
+    });
+
+    // Handle instructor relationships
+    if (validInstructorIds !== undefined) {
+      await this.prisma.course_instructor.deleteMany({
+        where: { course_id: id },
+      });
+
+      if (validInstructorIds.length > 0) {
+        await this.prisma.course_instructor.createMany({
+          data: validInstructorIds.map((instructorId) => ({
+            course_id: id,
+            instructor_id: instructorId,
+            role: 'lead',
+          })),
+        });
+      }
+    }
+
+    await this.syncCourseImages(id, {
+      logoFileId,
+      bannerFileId,
+    });
+
+    await this.persistCourseExtras(id, data);
+
+    const extrasById = await this.getCourseExtras([id]);
+
+    return this.mapCourse(c, undefined, extrasById.get(id));
+  }
+
+  async remove(id: number) {
+    await this.prisma.course.delete({ where: { id } });
+    return { success: true };
+  }
+
+  private mapCourse(
+    c: any,
+    metrics?: {
+      lessonCount?: number;
+      sessionCount?: number;
+      certificatesIssued?: number;
+      averageCompletion?: number;
+      progressByModule?: {
+        moduleId: number;
+        moduleTitle: string;
+        progress: number;
+      }[];
+    },
+    extras?: CourseExtraFields,
+  ) {
+    const rawCode = extras?.code ?? c.code ?? c.slug;
+    const resolvedTitle = this.normalizeOptionalText(c.title) ?? c.slug;
+    const courseImages = Array.isArray(c.course_image) ? c.course_image : [];
+    const classCount = c._count?.course_class_group ?? 0;
+    const offeringType =
+      this.normalizeOfferingType(extras?.offering_type) ??
+      (classCount > 0 ? 'scheduled' : 'on_demand');
+
+    const logoImage = courseImages.find(
+      (courseImage: any) => courseImage.image_type?.slug === 'course-logo',
+    );
+    const bannerImage = courseImages.find(
+      (courseImage: any) => courseImage.image_type?.slug === 'course-banner',
+    );
+
+    return {
+      id: c.id,
+      code:
+        rawCode?.toUpperCase().replace(/[^A-Z0-9-]+/g, '-').slice(0, 32) ??
+        '',
+      slug: c.slug,
+      title: resolvedTitle,
+      description: c.description ?? '',
+      level: c.level,
+      status: c.status,
+      durationHours: c.duration_hours ?? 0,
+      certificateWorkload: c.certificate_workload,
+      requirements: c.requirements ?? '',
+      objectives: c.objectives ?? '',
+      targetAudience: c.target_audience ?? '',
+      primaryColor: c.primary_color ?? null,
+      primaryContrastColor: c.primary_contrast_color ?? null,
+      secondaryColor: c.secondary_color ?? null,
+      secondaryContrastColor: c.secondary_contrast_color ?? null,
+      logoFileId: logoImage?.file?.id ?? logoImage?.file_id ?? null,
+      logoFilename: logoImage?.file?.filename ?? null,
+      bannerFileId: bannerImage?.file?.id ?? bannerImage?.file_id ?? null,
+      bannerFilename: bannerImage?.file?.filename ?? null,
+      categories: (c.course_category ?? []).map(
+        (cc: any) => cc.category?.slug ?? '',
+      ),
+      categoryIds: (c.course_category ?? []).map(
+        (cc: any) => cc.category?.id ?? 0,
+      ),
+      isFeatured: extras?.is_featured ?? c.is_featured ?? false,
+      hasCertificate: extras?.has_certificate ?? c.has_certificate ?? false,
+      isListed: extras?.is_listed ?? c.is_listed ?? false,
+      offeringType,
+      enrollmentCount: c._count?.course_enrollment ?? 0,
+      moduleCount: c._count?.course_module ?? 0,
+      classCount,
+      lessonCount: metrics?.lessonCount ?? 0,
+      sessionCount: metrics?.sessionCount ?? 0,
+      averageCompletion: Math.round(metrics?.averageCompletion ?? 0),
+      certificatesIssued:
+        metrics?.certificatesIssued ?? c._count?.certificate ?? 0,
+      progressByModule: metrics?.progressByModule ?? [],
+      instructors: (c.course_instructor ?? []).map((ci: any) => ({
+        id: ci.instructor_id,
+        name: ci.instructor?.person?.name ?? `Instructor #${ci.instructor_id}`,
+        avatarId: ci.instructor?.person?.avatar_id ?? null,
+      })),
+      instructorIds: (c.course_instructor ?? []).map(
+        (ci: any) => ci.instructor_id,
+      ),
+      createdAt: c.created_at,
+    };
+  }
+
+  private async getFeaturedCoursesCount() {
+    try {
+      const rows = (await this.prisma.$queryRawUnsafe(
+        'SELECT COUNT(*) AS value FROM course WHERE is_featured = true',
+      )) as Array<{ value: number | string }>;
+
+      return Number(rows[0]?.value ?? 0);
+    } catch {
+      return 0;
+    }
+  }
+
+  private async getCourseExtras(ids: number[]) {
+    const extrasById = new Map<number, CourseExtraFields>();
+
+    if (ids.length === 0) {
+      return extrasById;
+    }
+
+    const normalizedIds = ids
+      .map((id) => Number(id))
+      .filter((id) => Number.isInteger(id) && id > 0);
+
+    if (normalizedIds.length === 0) {
+      return extrasById;
+    }
+
+    try {
+      const idsCsv = normalizedIds.join(',');
+      const rows = (await this.prisma.$queryRawUnsafe(
+        `
+          SELECT id, code, is_featured, has_certificate, is_listed, offering_type
+          FROM course
+          WHERE id IN (${idsCsv})
+        `,
+      )) as Array<{
+        id: number;
+        code: string | null;
+        is_featured: boolean | null;
+        has_certificate: boolean | null;
+        is_listed: boolean | null;
+        offering_type: 'scheduled' | 'on_demand' | 'blended' | null;
+      }>;
+
+      for (const row of rows) {
+        extrasById.set(row.id, {
+          code: row.code,
+          is_featured: row.is_featured,
+          has_certificate: row.has_certificate,
+          is_listed: row.is_listed,
+          offering_type: row.offering_type,
+        });
+      }
+    } catch {
+      return extrasById;
+    }
+
+    return extrasById;
+  }
+
+  private async persistCourseExtras(
+    id: number,
+    data: PersistCourseExtrasInput,
+  ) {
+    const sets: string[] = [];
+    const params: Array<string | boolean | number> = [];
+
+    if (data.code !== undefined) {
+      params.push(data.code);
+      sets.push(`code = $${params.length}`);
+    }
+
+    if (data.isFeatured !== undefined) {
+      params.push(data.isFeatured);
+      sets.push(`is_featured = $${params.length}`);
+    }
+
+    if (data.hasCertificate !== undefined) {
+      params.push(data.hasCertificate);
+      sets.push(`has_certificate = $${params.length}`);
+    }
+
+    if (data.isListed !== undefined) {
+      params.push(data.isListed);
+      sets.push(`is_listed = $${params.length}`);
+    }
+
+    if (data.offeringType !== undefined) {
+      params.push(data.offeringType);
+      sets.push(`offering_type = $${params.length}`);
+    }
+
+    if (sets.length === 0) {
+      return;
+    }
+
+    params.push(id);
+
+    try {
+      await this.prisma.$executeRawUnsafe(
+        `
+          UPDATE course
+          SET ${sets.join(', ')}, updated_at = NOW()
+          WHERE id = $${params.length}
+        `,
+        ...params,
+      );
+    } catch {
+      // Columns may not exist yet in environments with outdated schema.
+    }
+  }
+
+  private normalizeCourseCode(value?: string | null) {
+    const normalized = String(value ?? '')
+      .trim()
+      .toUpperCase()
+      .replace(/[^A-Z0-9-]+/g, '-')
+      .replace(/-+/g, '-')
+      .replace(/^-+|-+$/g, '')
+      .slice(0, 32);
+
+    return normalized || undefined;
+  }
+
+  private async syncCourseImages(
+    courseId: number,
+    data: {
+      logoFileId?: number;
+      bannerFileId?: number;
+    },
+  ) {
+    if (data.logoFileId !== undefined) {
+      await this.upsertCourseImage(courseId, data.logoFileId, 'course-logo');
+    }
+
+    if (data.bannerFileId !== undefined) {
+      await this.upsertCourseImage(
+        courseId,
+        data.bannerFileId,
+        'course-banner',
+      );
+    }
+  }
+
+  private async upsertCourseImage(
+    courseId: number,
+    fileId: number,
+    imageTypeSlug: CourseImageTypeSlug,
+  ) {
+    const normalizedFileId = Number(fileId);
+
+    if (!Number.isInteger(normalizedFileId) || normalizedFileId <= 0) {
+      throw new BadRequestException('Invalid file id for course image');
+    }
+
+    const file = await this.prisma.file.findUnique({
+      where: { id: normalizedFileId },
+      select: { id: true },
+    });
+
+    if (!file) {
+      throw new BadRequestException('File not found');
+    }
+
+    const imageType = await this.getOrCreateCourseImageType(imageTypeSlug);
+    const courseImages = await this.prisma.course_image.findMany({
+      where: {
+        course_id: courseId,
+        image_type_id: imageType.id,
+      },
+      orderBy: [{ is_primary: 'desc' }, { order: 'asc' }],
+      select: { id: true, order: true },
+    });
+
+    if (courseImages.length > 0) {
+      const [primaryImage, ...duplicates] = courseImages;
+
+      await this.prisma.course_image.update({
+        where: { id: primaryImage.id },
+        data: {
+          file_id: normalizedFileId,
+          is_primary: true,
+        },
+      });
+
+      if (duplicates.length > 0) {
+        await this.prisma.course_image.deleteMany({
+          where: { id: { in: duplicates.map((item) => item.id) } },
+        });
+      }
+
+      return;
+    }
+
+    await this.prisma.course_image.create({
+      data: {
+        course_id: courseId,
+        file_id: normalizedFileId,
+        image_type_id: imageType.id,
+        order: 0,
+        is_primary: true,
+      },
+    });
+  }
+
+  private async getOrCreateCourseImageType(imageTypeSlug: CourseImageTypeSlug) {
+    const existing = await this.prisma.image_type.findFirst({
+      where: {
+        slug: imageTypeSlug,
+        applies_to_course: true,
+      },
+      select: { id: true },
+    });
+
+    if (existing) {
+      return existing;
+    }
+
+    return this.prisma.image_type.create({
+      data: {
+        name: imageTypeSlug === 'course-logo' ? 'Course Logo' : 'Course Banner',
+        slug: imageTypeSlug,
+        applies_to_course: true,
+      },
+      select: { id: true },
+    });
+  }
+}