Yimaru-BackEnd/internal/repository/lms_access.go

package repository

import (
	"context"

	dbgen "Yimaru-Backend/gen/db"
)

func (s *Store) LmsGetPreviousProgram(ctx context.Context, programID int64) (dbgen.Program, error) {
	return s.queries.GetPreviousProgram(ctx, programID)
}

func (s *Store) LmsGetPreviousCourseInProgram(ctx context.Context, courseID int64) (dbgen.Course, error) {
	return s.queries.GetPreviousCourseInProgram(ctx, courseID)
}

func (s *Store) LmsGetPreviousModuleInCourse(ctx context.Context, moduleID int64) (dbgen.Module, error) {
	return s.queries.GetPreviousModuleInCourse(ctx, moduleID)
}

func (s *Store) LmsGetPreviousLessonInModule(ctx context.Context, lessonID int64) (dbgen.Lesson, error) {
	return s.queries.GetPreviousLessonInModule(ctx, lessonID)
}

func (s *Store) LmsUserHasProgramProgress(ctx context.Context, userID, programID int64) (bool, error) {
	return s.queries.UserHasProgramProgress(ctx, dbgen.UserHasProgramProgressParams{UserID: userID, ProgramID: programID})
}

func (s *Store) LmsUserHasCourseProgress(ctx context.Context, userID, courseID int64) (bool, error) {
	return s.queries.UserHasCourseProgress(ctx, dbgen.UserHasCourseProgressParams{UserID: userID, CourseID: courseID})
}

func (s *Store) LmsUserHasModuleProgress(ctx context.Context, userID, moduleID int64) (bool, error) {
	return s.queries.UserHasModuleProgress(ctx, dbgen.UserHasModuleProgressParams{UserID: userID, ModuleID: moduleID})
}

func (s *Store) LmsUserHasLessonProgress(ctx context.Context, userID, lessonID int64) (bool, error) {
	return s.queries.UserHasLessonProgress(ctx, dbgen.UserHasLessonProgressParams{UserID: userID, LessonID: lessonID})
}

// LmsCountPublishedPracticesInLesson returns how many published practices are attached to a lesson.
func (s *Store) LmsCountPublishedPracticesInLesson(ctx context.Context, lessonID int64) (int32, error) {
	return s.queries.CountPublishedPracticesInLesson(ctx, toPgInt8(&lessonID))
}

// LmsCountPublishedPracticesInModule returns published practices in a module (direct + lesson-attached).
func (s *Store) LmsCountPublishedPracticesInModule(ctx context.Context, moduleID int64) (int32, error) {
	return s.queries.CountPublishedPracticesInModule(ctx, toPgInt8(&moduleID))
}

// LmsCountPublishedPracticesInCourse returns published practices in a course (direct + module + lesson scope).
func (s *Store) LmsCountPublishedPracticesInCourse(ctx context.Context, courseID int64) (int32, error) {
	return s.queries.CountPublishedPracticesInCourse(ctx, toPgInt8(&courseID))
}

// LmsUserPracticeProgressInLesson returns published practice completion counts scoped to a lesson.
func (s *Store) LmsUserPracticeProgressInLesson(ctx context.Context, userID, lessonID int64) (completed, total int32, err error) {
	lessonIDPG := toPgInt8(&lessonID)
	total, err = s.queries.CountPublishedPracticesInLesson(ctx, lessonIDPG)
	if err != nil {
		return 0, 0, err
	}
	completed, err = s.queries.CountUserCompletedPublishedPracticesInLesson(ctx, dbgen.CountUserCompletedPublishedPracticesInLessonParams{
		LessonID: lessonIDPG,
		UserID:   userID,
	})
	if err != nil {
		return 0, 0, err
	}
	return completed, total, nil
}

// LmsUserLessonProgressInModule returns published practice completion counts in a module.
func (s *Store) LmsUserLessonProgressInModule(ctx context.Context, userID, moduleID int64) (completed, total int32, err error) {
	total, err = s.queries.CountPublishedPracticesInModule(ctx, toPgInt8(&moduleID))
	if err != nil {
		return 0, 0, err
	}
	completed, err = s.queries.CountUserCompletedPublishedPracticesInModule(ctx, dbgen.CountUserCompletedPublishedPracticesInModuleParams{
		ModuleID: toPgInt8(&moduleID),
		UserID:   userID,
	})
	if err != nil {
		return 0, 0, err
	}
	return completed, total, nil
}

// LmsUserLessonProgressInCourse returns published practice completion counts in a course.
func (s *Store) LmsUserLessonProgressInCourse(ctx context.Context, userID, courseID int64) (completed, total int32, err error) {
	total, err = s.queries.CountPublishedPracticesInCourse(ctx, toPgInt8(&courseID))
	if err != nil {
		return 0, 0, err
	}
	completed, err = s.queries.CountUserCompletedPublishedPracticesInCourse(ctx, dbgen.CountUserCompletedPublishedPracticesInCourseParams{
		CourseID: toPgInt8(&courseID),
		UserID:   userID,
	})
	if err != nil {
		return 0, 0, err
	}
	return completed, total, nil
}

// LmsUserLessonProgressInProgram returns published practice completion counts in a program.
func (s *Store) LmsUserLessonProgressInProgram(ctx context.Context, userID, programID int64) (completed, total int32, err error) {
	total, err = s.queries.CountPublishedPracticesInProgram(ctx, programID)
	if err != nil {
		return 0, 0, err
	}
	completed, err = s.queries.CountUserCompletedPublishedPracticesInProgram(ctx, dbgen.CountUserCompletedPublishedPracticesInProgramParams{
		ProgramID: programID,
		UserID:    userID,
	})
	if err != nil {
		return 0, 0, err
	}
	return completed, total, nil
}

func (s *Store) LmsUserDirectPracticeProgressInModule(ctx context.Context, userID, moduleID int64) (completed, total int32, err error) {
	moduleIDPG := toPgInt8(&moduleID)
	total, err = s.queries.CountPublishedDirectPracticesInModule(ctx, moduleIDPG)
	if err != nil {
		return 0, 0, err
	}
	completed, err = s.queries.CountUserCompletedPublishedDirectPracticesInModule(ctx, dbgen.CountUserCompletedPublishedDirectPracticesInModuleParams{
		ModuleID: moduleIDPG,
		UserID:   userID,
	})
	if err != nil {
		return 0, 0, err
	}
	return completed, total, nil
}

func (s *Store) LmsUserDirectPracticeProgressInCourse(ctx context.Context, userID, courseID int64) (completed, total int32, err error) {
	courseIDPG := toPgInt8(&courseID)
	total, err = s.queries.CountPublishedDirectPracticesInCourse(ctx, courseIDPG)
	if err != nil {
		return 0, 0, err
	}
	completed, err = s.queries.CountUserCompletedPublishedDirectPracticesInCourse(ctx, dbgen.CountUserCompletedPublishedDirectPracticesInCourseParams{
		CourseID: courseIDPG,
		UserID:   userID,
	})
	if err != nil {
		return 0, 0, err
	}
	return completed, total, nil
}