Deploy files from GitHub repository

main.go

@@ -1,7 +1,6 @@
 package main
 
 import (
-	"fmt"
 	"log/slog"
 	"net"
 	"strconv"
@@ -32,9 +31,6 @@ func main() {
 	err := config.LoadConfig()
 	utils.FatalIfErr("failed to load config", err)
 
-	// print the all config loaded
-	fmt.Printf("config: %+v", config.GlobalConfig)
-
 	// setup validator for validation request
 	validator, err := validation.New(config.DB)
 	utils.FatalIfErr("failed to setup validator", err)

pkg/storage/local.go

@@ -1,67 +1,69 @@
 package storage
 
 import (
-    "context"
-    "fmt"
-    "io"
-    "os"
-    "path/filepath"
-    "strings"
+	"context"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
 )
 
 type LocalStorage struct {
-    *BaseStorage
-    basePath string
-    baseURL  string
+	*BaseStorage
+	basePath string
+	baseURL  string
 }
 
 func NewLocalStorage(basePath, baseURL string) *LocalStorage {
-    return &LocalStorage{
-        BaseStorage: NewBaseStorage(),
-        basePath:    basePath,
-        baseURL:     baseURL,
-    }
+	return &LocalStorage{
+		BaseStorage: NewBaseStorage(),
+		basePath:    basePath,
+		baseURL:     baseURL,
+	}
 }
 
 func (s *LocalStorage) Upload(ctx context.Context, file io.ReadSeeker, path string) error {
-    fullPath := filepath.Join(s.basePath, path)
+	fullPath := filepath.Join(s.basePath, path)
 
-    dir := filepath.Dir(fullPath)
-    if err := os.MkdirAll(dir, 0755); err != nil {
-        return err
-    }
+	dir := filepath.Dir(fullPath)
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return err
+	}
 
-    dst, err := os.Create(fullPath)
-    if err != nil {
-        return err
-    }
-    defer dst.Close()
+	dst, err := os.Create(fullPath)
+	if err != nil {
+		return err
+	}
+	defer dst.Close()
 
-    if _, err := io.Copy(dst, file); err != nil {
-        return err
-    }
-    return nil
+	if _, err := io.Copy(dst, file); err != nil {
+		return err
+	}
+	return nil
 }
 
 func (s *LocalStorage) GetURL(path string) string {
-    return filepath.Join(s.baseURL, path)
+	urlBuilder := strings.Builder{}
+	urlBuilder.Write([]byte(s.baseURL))
+	urlBuilder.Write([]byte(path))
+
+	return urlBuilder.String()
 }
 
 func (s *LocalStorage) Delete(ctx context.Context, path string) error {
-    // Contoh input: "http://localhost:8080/storage/users/5/profile/filename.png"
+	// Contoh input: "http://localhost:8080/storage/users/5/profile/filename.png"
 
-    // Ambil bagian setelah "/storage/"
-    const prefix = "/storage/"
-    idx := strings.Index(path, prefix)
-    if idx == -1 {
-        return os.ErrNotExist
-    }
+	// Ambil bagian setelah "/storage/"
+	const prefix = "/storage/"
+	idx := strings.Index(path, prefix)
+	if idx == -1 {
+		return os.ErrNotExist
+	}
 
-    relativePath := path[idx+len(prefix):]
+	relativePath := path[idx+len(prefix):]
 
-    // Gabungkan dengan basePath
-    fullPath := filepath.Join(s.basePath, relativePath)
-    fmt.Println(fullPath)
+	// Gabungkan dengan basePath
+	fullPath := filepath.Join(s.basePath, relativePath)
 
-    return os.Remove(fullPath)
+	return os.Remove(fullPath)
 }

response/api_response_v2.go

@@ -50,7 +50,8 @@ func HandleError(c *gin.Context, err error) {
 			responseError(c, http.StatusBadRequest, exception)
 		case exception.AcademyNotFinished:
 			responseError(c, http.StatusBadRequest, exception)
-
+		case exception.QuizAlreadyPassed:
+			responseError(c, http.StatusBadRequest, exception)
 		case exception.ValidationError:
 			responseValidationError(c, http.StatusUnprocessableEntity, exception.ValidationErrorFields)
 		default:

services/forgot_password_service.go

@@ -41,7 +41,7 @@ func (s *ForgotPasswordService) Create(email string) {
 		return
 	}
 
-	remainingTime := time.Duration(config.GlobalConfig.App.EmailVerificationDuration) * time.Hour
+	remainingTime := time.Duration(config.GlobalConfig.App.EmailVerificationDuration) * time.Minute
 	dueTime := CalculateDueTime(remainingTime)
 
 	s.Constructor.UUID = uuid.NewV4()

space/config/config.go

@@ -1,66 +1,236 @@
 package config
 
 import (
+	"fmt"
+	"log"
 	"os"
 	"strconv"
 	"time"
 
+	"api.qobiltu.id/models"
 	"github.com/joho/godotenv"
+	"gorm.io/driver/postgres"
+	"gorm.io/gorm"
 )
 
-var ENV string
-var TCP_ADDRESS string
-var LOG_PATH string
-
-var HOST_ADDRESS string
-var HOST_PORT string
-var EMAIL_VERIFICATION_DURATION int
-
-var SMTP_SENDER_EMAIL string
-var SMTP_SENDER_PASSWORD string
-var SMTP_HOST string
-var SMTP_PORT string
-
-var REDIS_HOST string
-var REDIS_PORT int
-var REDIS_PASSWORD string
-var REDIS_DB int
-var REDIS_MIN_IDLE_CONNS int
-var REDIS_POOL_SIZE int
-var REDIS_POOL_TIMEOUT time.Duration
-
-var APP_URL string
-
-func init() {
-	godotenv.Load()
-	ENV = os.Getenv("ENV")
-	HOST_ADDRESS = os.Getenv("HOST_ADDRESS")
-	HOST_PORT = os.Getenv("HOST_PORT")
-	TCP_ADDRESS = HOST_ADDRESS + ":" + HOST_PORT
-	LOG_PATH = os.Getenv("LOG_PATH")
-	EMAIL_VERIFICATION_DURATION, _ = strconv.Atoi(os.Getenv("EMAIL_VERIFICATION_DURATION"))
-	SMTP_SENDER_EMAIL = os.Getenv("SMTP_SENDER_EMAIL")
-	SMTP_SENDER_PASSWORD = os.Getenv("SMTP_SENDER_PASSWORD")
-	SMTP_HOST = os.Getenv("SMTP_HOST")
-	SMTP_PORT = os.Getenv("SMTP_PORT")
-
-	REDIS_HOST = getValue(os.Getenv("REDIS_HOST"), "redis", func(s string) (string, error) { return s, nil })
-	REDIS_PORT = getValue(os.Getenv("REDIS_PORT"), 6379, func(s string) (int, error) { return strconv.Atoi(s) })
-	REDIS_PASSWORD = getValue(os.Getenv("REDIS_PASSWORD"), "qobiltu", func(s string) (string, error) { return s, nil })
-	REDIS_DB = getValue(os.Getenv("REDIS_DB"), 0, func(s string) (int, error) { return strconv.Atoi(s) })
-	REDIS_POOL_SIZE = getValue(os.Getenv("REDIS_POOL_SIZE"), 10, func(s string) (int, error) { return strconv.Atoi(s) })
-	REDIS_MIN_IDLE_CONNS = getValue(os.Getenv("REDIS_MIN_IDLE_CONNS"), 10, func(s string) (int, error) { return strconv.Atoi(s) })
-	REDIS_POOL_TIMEOUT = getValue(os.Getenv("REDIS_POOL_TIMEOUT"), time.Second*30, func(s string) (time.Duration, error) { return time.ParseDuration(s) })
-	APP_URL = getValue(os.Getenv("APP_URL"), "http://localhost:3000", func(s string) (string, error) { return s, nil })
+// Config holds all configuration settings for the application.
+type Config struct {
+	Database DatabaseConfig
+	SMTP     SMTPConfig
+	Redis    RedisConfig
+	App      AppConfig
 }
 
+// DatabaseConfig holds database connection settings.
+type DatabaseConfig struct {
+	Host     string
+	Port     string
+	User     string
+	Password string
+	Name     string
+	DB       *gorm.DB
+}
+
+// SMTPConfig holds SMTP settings for email services.
+type SMTPConfig struct {
+	SenderEmail string
+	Password    string
+	Host        string
+	Port        string
+}
+
+// RedisConfig holds Redis connection settings.
+type RedisConfig struct {
+	Host         string
+	Port         int
+	Password     string
+	DB           int
+	MinIdleConns int
+	PoolSize     int
+	PoolTimeout  time.Duration
+}
+
+// AppConfig holds general application settings.
+type AppConfig struct {
+	Env                       string
+	HostAddress               string
+	HostPort                  string
+	TCPAddress                string
+	LogPath                   string
+	EmailVerificationDuration int
+	AppURL                    string
+	Salt                      string
+}
+
+// GlobalConfig is the global configuration instance.
+var GlobalConfig *Config
+var DB *gorm.DB // Global DB instance for compatibility
+
+// LoadConfig initializes the application configuration.
+func LoadConfig() error {
+	// Load environment variables from .env file
+	if err := godotenv.Load(); err != nil {
+		log.Printf("Failed to load .env file: %v", err)
+		// Continue with defaults if .env file is not found
+	}
+
+	// Set timezone
+	if err := os.Setenv("TZ", "Asia/Jakarta"); err != nil {
+		return fmt.Errorf("failed to set timezone: %w", err)
+	}
+
+	cfg := &Config{
+		Database: DatabaseConfig{
+			Host:     getValue(os.Getenv("DB_HOST"), "localhost", stringConverter),
+			Port:     getValue(os.Getenv("DB_PORT"), "5432", stringConverter),
+			User:     getValue(os.Getenv("DB_USER"), "postgres", stringConverter),
+			Password: getValue(os.Getenv("DB_PASSWORD"), "", stringConverter),
+			Name:     getValue(os.Getenv("DB_NAME"), "qobiltu", stringConverter),
+		},
+		SMTP: SMTPConfig{
+			SenderEmail: getValue(os.Getenv("SMTP_SENDER_EMAIL"), "", stringConverter),
+			Password:    getValue(os.Getenv("SMTP_SENDER_PASSWORD"), "", stringConverter),
+			Host:        getValue(os.Getenv("SMTP_HOST"), "", stringConverter),
+			Port:        getValue(os.Getenv("SMTP_PORT"), "", stringConverter),
+		},
+		Redis: RedisConfig{
+			Host:         getValue(os.Getenv("REDIS_HOST"), "redis", stringConverter),
+			Port:         getValue(os.Getenv("REDIS_PORT"), 6379, intConverter),
+			Password:     getValue(os.Getenv("REDIS_PASSWORD"), "qobiltu", stringConverter),
+			DB:           getValue(os.Getenv("REDIS_DB"), 0, intConverter),
+			MinIdleConns: getValue(os.Getenv("REDIS_MIN_IDLE_CONNS"), 10, intConverter),
+			PoolSize:     getValue(os.Getenv("REDIS_POOL_SIZE"), 10, intConverter),
+			PoolTimeout:  getValue(os.Getenv("REDIS_POOL_TIMEOUT"), 30*time.Second, durationConverter),
+		},
+		App: AppConfig{
+			Env:                       getValue(os.Getenv("ENV"), "development", stringConverter),
+			HostAddress:               getValue(os.Getenv("HOST_ADDRESS"), "localhost", stringConverter),
+			HostPort:                  getValue(os.Getenv("HOST_PORT"), "8080", stringConverter),
+			LogPath:                   getValue(os.Getenv("LOG_PATH"), "./logs", stringConverter),
+			EmailVerificationDuration: getValue(os.Getenv("EMAIL_VERIFICATION_DURATION"), 24, intConverter),
+			AppURL:                    getValue(os.Getenv("APP_URL"), "http://localhost:3000", stringConverter),
+			Salt:                      getValue(os.Getenv("SALT"), "D3f4u|t", stringConverter),
+		},
+	}
+
+	// Set TCP address
+	cfg.App.TCPAddress = fmt.Sprintf("%s:%s", cfg.App.HostAddress, cfg.App.HostPort)
+
+	// Initialize database connection
+	dsn := fmt.Sprintf(
+		"host=%s user=%s password=%s dbname=%s port=%s sslmode=disable TimeZone=Asia/Jakarta",
+		cfg.Database.Host, cfg.Database.User, cfg.Database.Password, cfg.Database.Name, cfg.Database.Port,
+	)
+
+	db, err := gorm.Open(postgres.Open(dsn), &gorm.Config{
+		TranslateError: true,
+		// Logger:         logger.Default.LogMode(logger.Info),
+	})
+	if err != nil {
+		return fmt.Errorf("failed to connect to database: %w", err)
+	}
+
+	// Configure database connection pooling
+	sqlDB, err := db.DB()
+	if err != nil {
+		return fmt.Errorf("failed to get sql.DB: %w", err)
+	}
+	sqlDB.SetMaxIdleConns(10)
+	sqlDB.SetMaxOpenConns(100)
+	sqlDB.SetConnMaxLifetime(time.Hour)
+	sqlDB.SetConnMaxIdleTime(30 * time.Minute)
+
+	// Assign database connection
+	cfg.Database.DB = db
+	DB = db
+
+	// Perform auto-migration
+	if err := AutoMigrateAll(db); err != nil {
+		return fmt.Errorf("auto-migration failed: %w", err)
+	}
+
+	// Assign to global config
+	GlobalConfig = cfg
+
+	return nil
+}
+
+// AutoMigrateAll performs auto-migration for all models and creates necessary sequences.
+func AutoMigrateAll(db *gorm.DB) error {
+	// Auto-migrate all models
+	err := db.AutoMigrate(
+		&models.Account{},
+		&models.AccountDetails{},
+		&models.EmailVerification{},
+		&models.ExternalAuth{},
+		&models.FCM{},
+		&models.ForgotPassword{},
+		&models.Academy{},
+		&models.AcademyMaterial{},
+		&models.AcademyMaterialProgress{},
+		&models.RegionCity{},
+		&models.RegionProvince{},
+		&models.OptionCategory{},
+		&models.OptionValues{},
+		&models.Quiz{},
+		&models.Question{},
+		&models.Answer{},
+		&models.QuizAttempt{},
+		&models.UserAnswer{},
+		&models.PersonalityAndPreferenceCV{},
+		&models.FamilyMemberCV{},
+		&models.PhysicalAndHealthCV{},
+		&models.WorshipAndReligiousUnderstandingCV{},
+		&models.EducationCV{},
+		&models.JobCV{},
+		&models.AchievementCV{},
+		&models.MarriageReadinessProfile{},
+		&models.PartnerCriteria{},
+	)
+	if err != nil {
+		return fmt.Errorf("failed to auto-migrate models: %w", err)
+	}
+
+	// Create sequences
+	sequences := []string{
+		`CREATE SEQUENCE IF NOT EXISTS seq_ikh_counter START 1 INCREMENT 1 MINVALUE 1;`,
+		`CREATE SEQUENCE IF NOT EXISTS seq_akh_counter START 1 INCREMENT 1 MINVALUE 1;`,
+	}
+	for _, seq := range sequences {
+		if err := db.Exec(seq).Error; err != nil {
+			log.Printf("Failed to create sequence: %v", err)
+			return fmt.Errorf("failed to create sequence: %w", err)
+		}
+	}
+
+	log.Println("Auto-migration and sequence creation completed successfully")
+	return nil
+}
+
+// getValue retrieves an environment variable with a default value and type conversion.
 func getValue[T any](value string, defaultValue T, convert func(string) (T, error)) T {
 	if value == "" {
 		return defaultValue
 	}
 	convertedValue, err := convert(value)
 	if err != nil {
+		log.Printf("Failed to convert %v to type %T: %v, using default: %v", value, defaultValue, err, defaultValue)
 		return defaultValue
 	}
 	return convertedValue
 }
+
+// stringConverter converts a string to a string (identity function).
+func stringConverter(s string) (string, error) {
+	return s, nil
+}
+
+// intConverter converts a string to an int.
+func intConverter(s string) (int, error) {
+	return strconv.Atoi(s)
+}
+
+// durationConverter converts a string to a time.Duration.
+func durationConverter(s string) (time.Duration, error) {
+	return time.ParseDuration(s)
+}

space/main.go

@@ -27,31 +27,33 @@ import (
 
 func main() {
 
-	// setup validation
+	// load config
+	err := config.LoadConfig()
+	utils.FatalIfErr("failed to load config", err)
+
+	// setup validator for validation request
 	validator, err := validation.New(config.DB)
 	utils.FatalIfErr("failed to setup validator", err)
 
-	// setup storage
-	localStorage := storage.NewLocalStorage("uploads", config.APP_URL+"/storage/")
-
-	// setup email sender
-	emailConfig := mail.Config{
-		Host:     config.SMTP_HOST,
-		Port:     config.SMTP_PORT,
-		From:     config.SMTP_SENDER_EMAIL,
-		Username: config.SMTP_SENDER_EMAIL,
-		Password: config.SMTP_SENDER_PASSWORD,
-	}
-
-	emailSender, err := mail.New(&emailConfig)
+	// setup storage for saving files
+	localStorage := storage.NewLocalStorage("uploads", config.GlobalConfig.App.AppURL+"/storage/")
+
+	// setup smtp for sending email
+	emailSender, err := mail.New(&mail.Config{
+		Host:     config.GlobalConfig.SMTP.Host,
+		Port:     config.GlobalConfig.SMTP.Port,
+		From:     config.GlobalConfig.SMTP.SenderEmail,
+		Username: config.GlobalConfig.SMTP.SenderEmail,
+		Password: config.GlobalConfig.SMTP.Password,
+	})
 	utils.FatalIfErr("failed to setup email sender", err)
 	mail.EmailSender = emailSender
 
-	// setup redis task distributor and processor
+	// setup task distributor and processor for async task
 	asynqRedisOpt := asynq.RedisClientOpt{
-		Addr:     net.JoinHostPort(config.REDIS_HOST, strconv.Itoa(config.REDIS_PORT)),
-		Password: config.REDIS_PASSWORD,
-		DB:       config.REDIS_DB,
+		Addr:     net.JoinHostPort(config.GlobalConfig.Redis.Host, strconv.Itoa(config.GlobalConfig.Redis.Port)),
+		Password: config.GlobalConfig.Redis.Password,
+		DB:       config.GlobalConfig.Redis.DB,
 	}
 
 	taskDistributor := worker.NewRedisTaskDistributor(asynqRedisOpt)
@@ -59,7 +61,6 @@ func main() {
 	worker.AsyncTaskDistributor = taskDistributor
 
 	// setup repo, service, and controller
-
 	regionRepository := repositories.NewRegionRepository(config.DB)
 	regionService := services.NewRegionService(regionRepository)
 	regionController := region_controller.NewRegionController(regionService)
@@ -76,8 +77,8 @@ func main() {
 	academyService := services.NewAcademyService(academyRepository, validator)
 	academyController := academy_controller.NewAcademyController(academyService)
 
-	quizRepository := repositories.NewQuizRepository(config.DB)
-	quizService := services.NewQuizService(quizRepository, academyRepository, validator)
+	quizRepository := repositories.NewQuizRepository()
+	quizService := services.NewQuizService(config.DB, quizRepository, academyRepository, validator)
 	quizController := quiz_controller.NewQuizController(quizService)
 
 	cvRepository := repositories.NewCVRepository(config.DB)
@@ -111,7 +112,7 @@ func main() {
 	utils.FatalIfErr("failed to create server", err)
 
 	// run server
-	slog.Info("Starting server", "address", config.TCP_ADDRESS, "port", config.HOST_PORT)
-	err = s.Start(config.TCP_ADDRESS)
+	slog.Info("Starting server", "address", config.GlobalConfig.App.HostAddress, "port", config.GlobalConfig.App.HostPort)
+	err = s.Start(config.GlobalConfig.App.TCPAddress)
 	utils.FatalIfErr("failed to start server", err)
 }

space/models/exception_model.go

@@ -20,6 +20,7 @@ type Exception struct {
 
 	// quiz context
 	QuizTimeExpired     bool `json:"quiz_time_expired,omitempty"`
+	QuizAlreadyPassed   bool `json:"quiz_already_passed,omitempty"`
 	QuizAttemptLimit    bool `json:"quiz_attempt_limit,omitempty"`
 	QuizAlreadyFinished bool `json:"quiz_already_finished,omitempty"`
 	AcademyNotFinished  bool `json:"academy_not_finished,omitempty"`

space/repositories/academy_repository.go

@@ -26,7 +26,7 @@ type AcademyRepository interface {
 
 	// === USER ===
 	UserListAcademy(ctx context.Context, req *models.ListAcademyRequest) ([]models.UserAcademyResponse, *models.Paging, error)
-	UserGetPercentageProgressAcademyByID(ctx context.Context, accountID int64, academyID int64) (float64, error)
+	UserGetPercentageProgressAcademyByID(ctx context.Context, db *gorm.DB, accountID, academyID int64) (float64, error)
 	UserListAcademyMaterial(ctx context.Context, req *models.ListAcademyMaterialRequest) ([]models.UserAcademyMaterialResponse, *models.Paging, error)
 	UserGetAcademyBySlug(ctx context.Context, slug string) (*models.AcademyResponse, error)
 	UserGetAcademyMaterialBySlug(ctx context.Context, slug string, accountID int64) (*models.UserAcademyMaterialDetailResponse, error)
@@ -288,34 +288,33 @@ func (r *academyRepository) UserListAcademy(ctx context.Context, req *models.Lis
 	return academies, pageInfo, nil
 }
 
-func (r *academyRepository) UserGetPercentageProgressAcademyByID(ctx context.Context, accountID int64, academyID int64) (float64, error) {
-	var totalMaterial int64
-	var totalReadMaterial int64
+func (r *academyRepository) UserGetPercentageProgressAcademyByID(ctx context.Context, db *gorm.DB, accountID, academyID int64) (float64, error) {
+	var totalMaterials, completedMaterials int64
 
-	// Hitung total materi dalam academy
-	err := r.db.WithContext(ctx).
+	// Count total materials for the academy
+	err := db.WithContext(ctx).
 		Model(&models.AcademyMaterial{}).
 		Where("academy_id = ?", academyID).
-		Count(&totalMaterial).Error
+		Count(&totalMaterials).Error
 	if err != nil {
 		return 0, err
 	}
 
-	// Hitung total materi yang sudah dibaca oleh user
-	err = r.db.WithContext(ctx).
+	if totalMaterials == 0 {
+		return 100.0, nil // If no materials, consider progress as 100%
+	}
+
+	// Count completed materials for the account
+	err = db.WithContext(ctx).
 		Model(&models.AcademyMaterialProgress{}).
-		Joins("JOIN academy_materials am ON am.id = academy_materials_progress.academy_material_id").
-		Where("academy_materials_progress.account_id = ? AND am.academy_id = ?", accountID, academyID).
-		Count(&totalReadMaterial).Error
+		Where("account_id = ? AND academy_material_id IN (SELECT id FROM academy_materials WHERE academy_id = ?)", accountID, academyID).
+		Count(&completedMaterials).Error
 	if err != nil {
 		return 0, err
 	}
 
-	// Hitung persentase
-	if totalMaterial == 0 {
-		return 0, nil
-	}
-	percentage := float64(totalReadMaterial) / float64(totalMaterial) * 100
+	// Calculate percentage
+	percentage := (float64(completedMaterials) / float64(totalMaterials)) * 100
 	return percentage, nil
 }
 

space/repositories/quiz_repository.go

@@ -10,38 +10,37 @@ import (
 )
 
 type QuizRepository interface {
-	UserGetQuiz(ctx context.Context, req *models.UserGetQuizRequest) (*models.UserGetQuizResponse, error)
-	UserGetActiveAttemptQuiz(ctx context.Context, accountID int64, quizID int64) (*models.QuizAttempt, error)
-	UserGetTotalAttemptsQuiz(ctx context.Context, accountID int64, quizID int64) (int64, error)
-	UserCreateAttemptQuiz(ctx context.Context, attempt *models.QuizAttempt) error
-	UserGetAttemptQuizQuestionsResponse(ctx context.Context, accountID int64, quizID int64, attemptID int64) ([]models.UserAttemptQuizQuestionsResponse, error)
-
-	UserGetAttemptByID(ctx context.Context, attemptID int64) (*models.QuizAttempt, error)
-	UserUpdateAttemptQuiz(ctx context.Context, attempt *models.QuizAttempt) error
-
-	UserGetReviewQuiz(ctx context.Context, attemptID, accountID, quizID int64) (*models.ReviewQuizResponse, error)
-	UseGetLastAttemptQuiz(ctx context.Context, accountID int64, academyID int64) (*models.QuizAttempt, error)
-
-	UserGetTotalQuestionQuiz(ctx context.Context, quizID int64) (int64, error)
-	UserGetTotalCorrectAnswerQuiz(ctx context.Context, quizAttemptID int64) (int64, error)
-	UserDeleteAttemptQuizByAccountIDAndQuizID(ctx context.Context, accountID int64, quizID int64) error
-	UserGetRemainingAttempts(ctx context.Context, accountID int64, quizID int64) (int64, error)
-	UserGetQuestionQuiz(ctx context.Context, attemptID, questionID int64) (*models.GetQuestionQuizResponse, error)
-	UserGetUserAnswer(ctx context.Context, attemptID, questionID int64) (*models.UserAnswer, error)
-	UserSaveUserAnswer(ctx context.Context, answer *models.UserAnswer) error
-	GetCorrectOptionID(ctx context.Context, questionID int64) (int64, error)
-	UserDeleteProgressAndAttempt(ctx context.Context, accountID int64, academyID int64) error
+	UserGetQuiz(ctx context.Context, db *gorm.DB, req *models.UserGetQuizRequest) (*models.UserGetQuizResponse, error)
+	UserIsPassedQuiz(ctx context.Context, db *gorm.DB, accountID int64, quizID int64) (bool, error)
+	UserGetActiveAttemptQuiz(ctx context.Context, db *gorm.DB, accountID int64, quizID int64) (*models.QuizAttempt, error)
+	UserGetTotalAttemptsQuiz(ctx context.Context, db *gorm.DB, accountID int64, quizID int64) (int64, error)
+	UserCreateAttemptQuiz(ctx context.Context, db *gorm.DB, attempt *models.QuizAttempt) error
+	UserGetAttemptQuizQuestionsResponse(ctx context.Context, db *gorm.DB, accountID int64, quizID int64, attemptID int64) ([]models.UserAttemptQuizQuestionsResponse, error)
+
+	UserGetAttemptByID(ctx context.Context, db *gorm.DB, attemptID int64) (*models.QuizAttempt, error)
+	UserUpdateAttemptQuiz(ctx context.Context, db *gorm.DB, attempt *models.QuizAttempt) error
+
+	UserGetReviewQuiz(ctx context.Context, db *gorm.DB, attemptID, accountID, quizID int64) (*models.ReviewQuizResponse, error)
+	UseGetLastAttemptQuiz(ctx context.Context, db *gorm.DB, accountID int64, academyID int64) (*models.QuizAttempt, error)
+
+	UserGetTotalQuestionQuiz(ctx context.Context, db *gorm.DB, quizID int64) (int64, error)
+	UserGetTotalCorrectAnswerQuiz(ctx context.Context, db *gorm.DB, quizAttemptID int64) (int64, error)
+	UserDeleteAttemptQuizByAccountIDAndQuizID(ctx context.Context, db *gorm.DB, accountID int64, quizID int64) error
+	UserGetRemainingAttempts(ctx context.Context, db *gorm.DB, accountID int64, quizID int64) (int64, error)
+	UserGetQuestionQuiz(ctx context.Context, db *gorm.DB, attemptID, questionID int64) (*models.GetQuestionQuizResponse, error)
+	UserGetUserAnswer(ctx context.Context, db *gorm.DB, attemptID, questionID int64) (*models.UserAnswer, error)
+	UserSaveUserAnswer(ctx context.Context, db *gorm.DB, answer *models.UserAnswer) error
+	GetCorrectOptionID(ctx context.Context, db *gorm.DB, questionID int64) (int64, error)
+	UserDeleteProgressAndAttempt(ctx context.Context, db *gorm.DB, accountID int64, academyID int64) error
 }
 
-type quizRepository struct {
-	db *gorm.DB
-}
+type quizRepository struct{}
 
-func NewQuizRepository(db *gorm.DB) QuizRepository {
-	return &quizRepository{db: db}
+func NewQuizRepository() QuizRepository {
+	return &quizRepository{}
 }
 
-func (r *quizRepository) UserGetQuiz(ctx context.Context, req *models.UserGetQuizRequest) (*models.UserGetQuizResponse, error) {
+func (r *quizRepository) UserGetQuiz(ctx context.Context, db *gorm.DB, req *models.UserGetQuizRequest) (*models.UserGetQuizResponse, error) {
 	var quizResponse models.UserGetQuizResponse
 
 	rawQuery := `
@@ -73,7 +72,7 @@ func (r *quizRepository) UserGetQuiz(ctx context.Context, req *models.UserGetQui
             q.attempt_limit, q.time_limit, q.min_score, q.created_at, q.updated_at;
     `
 
-	err := r.db.Debug().Raw(rawQuery, map[string]any{
+	err := db.Debug().Raw(rawQuery, map[string]any{
 		"accountID": req.AccountID,
 		"academyID": req.AcademyID,
 	}).Scan(&quizResponse).Error
@@ -88,10 +87,24 @@ func (r *quizRepository) UserGetQuiz(ctx context.Context, req *models.UserGetQui
 	return &quizResponse, nil
 }
 
-func (r *quizRepository) UserGetActiveAttemptQuiz(ctx context.Context, accountID int64, quizID int64) (*models.QuizAttempt, error) {
+func (r *quizRepository) UserIsPassedQuiz(ctx context.Context, db *gorm.DB, accountID int64, quizID int64) (bool, error) {
+	var count int64
+
+	err := db.WithContext(ctx).
+		Model(&models.QuizAttempt{}).
+		Where("account_id = ? AND quiz_id = ? AND is_passed = ?", accountID, quizID, true).
+		Count(&count).Error
+	if err != nil {
+		return false, fmt.Errorf("failed to check if quiz is passed: %w", err)
+	}
+
+	return count > 0, nil
+}
+
+func (r *quizRepository) UserGetActiveAttemptQuiz(ctx context.Context, db *gorm.DB, accountID int64, quizID int64) (*models.QuizAttempt, error) {
 	var quizAttempt models.QuizAttempt
 
-	err := r.db.Debug().Where("account_id = ? AND quiz_id = ? AND finished_at IS NULL", accountID, quizID).First(&quizAttempt).Error
+	err := db.Debug().Where("account_id = ? AND quiz_id = ? AND finished_at IS NULL", accountID, quizID).First(&quizAttempt).Error
 	if err != nil {
 		return nil, err
 	}
@@ -99,10 +112,10 @@ func (r *quizRepository) UserGetActiveAttemptQuiz(ctx context.Context, accountID
 	return &quizAttempt, nil
 }
 
-func (r *quizRepository) UserGetTotalAttemptsQuiz(ctx context.Context, accountID int64, quizID int64) (int64, error) {
+func (r *quizRepository) UserGetTotalAttemptsQuiz(ctx context.Context, db *gorm.DB, accountID int64, quizID int64) (int64, error) {
 	var totalAttempts int64
 
-	err := r.db.Debug().Model(&models.QuizAttempt{}).Where("account_id = ? AND quiz_id = ? AND finished_at IS NOT NULL", accountID, quizID).Count(&totalAttempts).Error
+	err := db.Debug().Model(&models.QuizAttempt{}).Where("account_id = ? AND quiz_id = ? AND finished_at IS NOT NULL", accountID, quizID).Count(&totalAttempts).Error
 	if err != nil {
 		return 0, err
 	}
@@ -110,11 +123,11 @@ func (r *quizRepository) UserGetTotalAttemptsQuiz(ctx context.Context, accountID
 	return totalAttempts, nil
 }
 
-func (r *quizRepository) UserCreateAttemptQuiz(ctx context.Context, attempt *models.QuizAttempt) error {
-	return r.db.Debug().Create(attempt).Error
+func (r *quizRepository) UserCreateAttemptQuiz(ctx context.Context, db *gorm.DB, attempt *models.QuizAttempt) error {
+	return db.Debug().Create(attempt).Error
 }
 
-func (r *quizRepository) UserGetAttemptQuizQuestionsResponse(ctx context.Context, accountID int64, quizID int64, attemptID int64) ([]models.UserAttemptQuizQuestionsResponse, error) {
+func (r *quizRepository) UserGetAttemptQuizQuestionsResponse(ctx context.Context, db *gorm.DB, accountID int64, quizID int64, attemptID int64) ([]models.UserAttemptQuizQuestionsResponse, error) {
 	questions := make([]models.UserAttemptQuizQuestionsResponse, 0)
 
 	rawQuery := `
@@ -144,7 +157,7 @@ func (r *quizRepository) UserGetAttemptQuizQuestionsResponse(ctx context.Context
 			q.id;
 	`
 
-	err := r.db.Debug().Raw(rawQuery, attemptID, accountID, quizID, attemptID, quizID).Scan(&questions).Error
+	err := db.Debug().Raw(rawQuery, attemptID, accountID, quizID, attemptID, quizID).Scan(&questions).Error
 	if err != nil {
 		return nil, err
 	}
@@ -152,10 +165,10 @@ func (r *quizRepository) UserGetAttemptQuizQuestionsResponse(ctx context.Context
 	return questions, nil
 }
 
-func (r *quizRepository) UserGetAttemptByID(ctx context.Context, attemptID int64) (*models.QuizAttempt, error) {
+func (r *quizRepository) UserGetAttemptByID(ctx context.Context, db *gorm.DB, attemptID int64) (*models.QuizAttempt, error) {
 	var quizAttempt models.QuizAttempt
 
-	err := r.db.Where("id = ?", attemptID).
+	err := db.Where("id = ?", attemptID).
 		Preload("Quiz").
 		First(&quizAttempt).Error
 	if err != nil {
@@ -165,14 +178,14 @@ func (r *quizRepository) UserGetAttemptByID(ctx context.Context, attemptID int64
 	return &quizAttempt, nil
 }
 
-func (r *quizRepository) UserUpdateAttemptQuiz(ctx context.Context, attempt *models.QuizAttempt) error {
-	return r.db.Save(attempt).Error
+func (r *quizRepository) UserUpdateAttemptQuiz(ctx context.Context, db *gorm.DB, attempt *models.QuizAttempt) error {
+	return db.Save(attempt).Error
 }
 
-func (r *quizRepository) UserGetTotalQuestionQuiz(ctx context.Context, quizID int64) (int64, error) {
+func (r *quizRepository) UserGetTotalQuestionQuiz(ctx context.Context, db *gorm.DB, quizID int64) (int64, error) {
 	var totalQuestion int64
 
-	err := r.db.Model(&models.Question{}).Where("quiz_id = ?", quizID).Count(&totalQuestion).Error
+	err := db.Model(&models.Question{}).Where("quiz_id = ?", quizID).Count(&totalQuestion).Error
 	if err != nil {
 		return 0, err
 	}
@@ -180,10 +193,10 @@ func (r *quizRepository) UserGetTotalQuestionQuiz(ctx context.Context, quizID in
 	return totalQuestion, nil
 }
 
-func (r *quizRepository) UserGetTotalCorrectAnswerQuiz(ctx context.Context, quizAttemptID int64) (int64, error) {
+func (r *quizRepository) UserGetTotalCorrectAnswerQuiz(ctx context.Context, db *gorm.DB, quizAttemptID int64) (int64, error) {
 	var totalCorrectAnswer int64
 
-	err := r.db.Model(&models.UserAnswer{}).Where("quiz_attempt_id = ? AND is_correct = TRUE", quizAttemptID).Count(&totalCorrectAnswer).Error
+	err := db.Model(&models.UserAnswer{}).Where("quiz_attempt_id = ? AND is_correct = TRUE", quizAttemptID).Count(&totalCorrectAnswer).Error
 	if err != nil {
 		return 0, err
 	}
@@ -191,11 +204,11 @@ func (r *quizRepository) UserGetTotalCorrectAnswerQuiz(ctx context.Context, quiz
 	return totalCorrectAnswer, nil
 }
 
-func (r *quizRepository) UserDeleteAttemptQuizByAccountIDAndQuizID(ctx context.Context, accountID int64, quizID int64) error {
-	return r.db.Where("account_id = ? AND quiz_id = ?", accountID, quizID).Delete(&models.QuizAttempt{}).Error
+func (r *quizRepository) UserDeleteAttemptQuizByAccountIDAndQuizID(ctx context.Context, db *gorm.DB, accountID int64, quizID int64) error {
+	return db.Where("account_id = ? AND quiz_id = ?", accountID, quizID).Delete(&models.QuizAttempt{}).Error
 }
 
-func (r *quizRepository) UserGetRemainingAttempts(ctx context.Context, accountID int64, quizID int64) (int64, error) {
+func (r *quizRepository) UserGetRemainingAttempts(ctx context.Context, db *gorm.DB, accountID int64, quizID int64) (int64, error) {
 	var remainingAttempts int64
 
 	rawQuery := `
@@ -214,7 +227,7 @@ func (r *quizRepository) UserGetRemainingAttempts(ctx context.Context, accountID
             q.attempt_limit;
     `
 
-	err := r.db.Raw(rawQuery, accountID, quizID).Scan(&remainingAttempts).Error
+	err := db.Raw(rawQuery, accountID, quizID).Scan(&remainingAttempts).Error
 	if err != nil {
 		return 0, err
 	}
@@ -222,7 +235,7 @@ func (r *quizRepository) UserGetRemainingAttempts(ctx context.Context, accountID
 	return remainingAttempts, nil
 }
 
-func (r *quizRepository) UserGetQuestionQuiz(ctx context.Context, attemptID, questionID int64) (*models.GetQuestionQuizResponse, error) {
+func (r *quizRepository) UserGetQuestionQuiz(ctx context.Context, db *gorm.DB, attemptID, questionID int64) (*models.GetQuestionQuizResponse, error) {
 	var resultJSON string
 	var response models.GetQuestionQuizResponse
 
@@ -251,14 +264,14 @@ func (r *quizRepository) UserGetQuestionQuiz(ctx context.Context, attemptID, que
         LEFT JOIN
             user_answers ua
             ON q.id = ua.question_id
-            AND ua.quiz_attempt_id = $1
+            AND ua.quiz_attempt_id = ?
         WHERE
-            q.id = $2
+            q.id = ?
         GROUP BY
             q.id, q.quiz_id, q.content, ua.selected_answer_id, ua.is_doubt;
     `
 
-	err := r.db.Raw(rawQuery, attemptID, questionID).Scan(&resultJSON).Error
+	err := db.Raw(rawQuery, attemptID, questionID).Scan(&resultJSON).Error
 	if err != nil {
 		return nil, err
 	}
@@ -271,10 +284,10 @@ func (r *quizRepository) UserGetQuestionQuiz(ctx context.Context, attemptID, que
 	return &response, nil
 }
 
-func (r *quizRepository) UserGetQuestionByID(ctx context.Context, questionID int64) (*models.Question, error) {
+func (r *quizRepository) UserGetQuestionByID(ctx context.Context, db *gorm.DB, questionID int64) (*models.Question, error) {
 	var question models.Question
 
-	err := r.db.Where("id = ?", questionID).First(&question).Error
+	err := db.Where("id = ?", questionID).First(&question).Error
 	if err != nil {
 		return nil, err
 	}
@@ -282,10 +295,10 @@ func (r *quizRepository) UserGetQuestionByID(ctx context.Context, questionID int
 	return &question, nil
 }
 
-func (r *quizRepository) UserGetUserAnswer(ctx context.Context, attemptID, questionID int64) (*models.UserAnswer, error) {
+func (r *quizRepository) UserGetUserAnswer(ctx context.Context, db *gorm.DB, attemptID, questionID int64) (*models.UserAnswer, error) {
 	var userAnswer models.UserAnswer
 
-	err := r.db.Where("quiz_attempt_id = ? AND question_id = ?", attemptID, questionID).First(&userAnswer).Error
+	err := db.Where("quiz_attempt_id = ? AND question_id = ?", attemptID, questionID).First(&userAnswer).Error
 	if err != nil {
 		return nil, err
 	}
@@ -293,11 +306,11 @@ func (r *quizRepository) UserGetUserAnswer(ctx context.Context, attemptID, quest
 	return &userAnswer, nil
 }
 
-func (r *quizRepository) UserSaveUserAnswer(ctx context.Context, userAnswer *models.UserAnswer) error {
-	return r.db.Save(userAnswer).Error
+func (r *quizRepository) UserSaveUserAnswer(ctx context.Context, db *gorm.DB, userAnswer *models.UserAnswer) error {
+	return db.Save(userAnswer).Error
 }
 
-func (r *quizRepository) UserGetReviewQuiz(ctx context.Context, attemptID, accountID, quizID int64) (*models.ReviewQuizResponse, error) {
+func (r *quizRepository) UserGetReviewQuiz(ctx context.Context, db *gorm.DB, attemptID, accountID, quizID int64) (*models.ReviewQuizResponse, error) {
 	var resultJSON string
 	var reviewQuizResponse models.ReviewQuizResponse
 
@@ -326,7 +339,7 @@ func (r *quizRepository) UserGetReviewQuiz(ctx context.Context, attemptID, accou
                             FROM answers a
                             WHERE a.question_id = q.id
                         ),
-                        'answer_id', ua.selected_answer_id
+						'answer_id', NULLIF(ua.selected_answer_id, 0)
                     ) ORDER BY q.order
                 ),
                 '[]'::json
@@ -341,7 +354,7 @@ func (r *quizRepository) UserGetReviewQuiz(ctx context.Context, attemptID, accou
             q.quiz_id = ?
     `
 
-	err := r.db.Raw(rawQuery, attemptID, quizID).Scan(&resultJSON).Error
+	err := db.Raw(rawQuery, attemptID, quizID).Scan(&resultJSON).Error
 	if err != nil {
 		return nil, fmt.Errorf("failed to query reviews: %w", err)
 	}
@@ -356,10 +369,10 @@ func (r *quizRepository) UserGetReviewQuiz(ctx context.Context, attemptID, accou
 	return &reviewQuizResponse, nil
 }
 
-func (r *quizRepository) UseGetLastAttemptQuiz(ctx context.Context, accountID int64, academyID int64) (*models.QuizAttempt, error) {
+func (r *quizRepository) UseGetLastAttemptQuiz(ctx context.Context, db *gorm.DB, accountID int64, academyID int64) (*models.QuizAttempt, error) {
 	var attempt models.QuizAttempt
 
-	err := r.db.Where("account_id = ? AND academy_id = ?", accountID, academyID).Last(&attempt).Error
+	err := db.Where("account_id = ? AND academy_id = ?", accountID, academyID).Last(&attempt).Error
 	if err != nil {
 		return nil, err
 	}
@@ -367,7 +380,7 @@ func (r *quizRepository) UseGetLastAttemptQuiz(ctx context.Context, accountID in
 	return &attempt, nil
 }
 
-func (r *quizRepository) GetCorrectOptionID(ctx context.Context, questionID int64) (int64, error) {
+func (r *quizRepository) GetCorrectOptionID(ctx context.Context, db *gorm.DB, questionID int64) (int64, error) {
 	var correctOptionID int64
 
 	rawQuery := `
@@ -378,7 +391,7 @@ func (r *quizRepository) GetCorrectOptionID(ctx context.Context, questionID int6
         LIMIT 1;
     `
 
-	err := r.db.Raw(rawQuery, questionID).Scan(&correctOptionID).Error
+	err := db.Raw(rawQuery, questionID).Scan(&correctOptionID).Error
 	if err != nil {
 		return 0, err
 	}
@@ -386,13 +399,20 @@ func (r *quizRepository) GetCorrectOptionID(ctx context.Context, questionID int6
 	return correctOptionID, nil
 }
 
-func (r *quizRepository) UserDeleteProgressAndAttempt(ctx context.Context, accountID int64, academyID int64) error {
-	r.db.Where("account_id = ? AND academy_material_id IN (SELECT id FROM academy_materials WHERE academy_id = ?)", accountID, academyID).
-		Delete(&models.AcademyMaterialProgress{})
+func (r *quizRepository) UserDeleteProgressAndAttempt(ctx context.Context, db *gorm.DB, accountID int64, academyID int64) error {
+	// Delete academy material progress
+	err := db.Where("account_id = ? AND academy_material_id IN (SELECT id FROM academy_materials WHERE academy_id = ?)", accountID, academyID).
+		Delete(&models.AcademyMaterialProgress{}).Error
+	if err != nil {
+		return err
+	}
 
-	// Delete quiz attempts for the quiz associated with the academy
-	r.db.Where("account_id = ? AND quiz_id IN (SELECT id FROM quizzes WHERE academy_id = ?)", accountID, academyID).
-		Delete(&models.QuizAttempt{})
+	// Delete quiz attempts
+	err = db.Where("account_id = ? AND quiz_id IN (SELECT id FROM quizzes WHERE academy_id = ?)", accountID, academyID).
+		Delete(&models.QuizAttempt{}).Error
+	if err != nil {
+		return err
+	}
 
 	return nil
 }

space/response/api_response_v2.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"errors"
 	"net/http"
+	"strconv"
 
 	"api.qobiltu.id/models"
 	"api.qobiltu.id/pkg/validation"
@@ -49,7 +50,8 @@ func HandleError(c *gin.Context, err error) {
 			responseError(c, http.StatusBadRequest, exception)
 		case exception.AcademyNotFinished:
 			responseError(c, http.StatusBadRequest, exception)
-
+		case exception.QuizAlreadyPassed:
+			responseError(c, http.StatusBadRequest, exception)
 		case exception.ValidationError:
 			responseValidationError(c, http.StatusUnprocessableEntity, exception.ValidationErrorFields)
 		default:
@@ -84,6 +86,16 @@ func HandleError(c *gin.Context, err error) {
 		return
 	}
 
+	var numErr *strconv.NumError
+	if errors.As(err, &numErr) {
+		responseError(c, http.StatusBadRequest, models.Exception{
+			BadRequest: true,
+			Message:    "Invalid number format",
+			Err:        err,
+		})
+		return
+	}
+
 	utils.LogError(err)
 	responseError(c, http.StatusInternalServerError, models.Exception{
 		InternalServerError: true,

space/services/email_service.go

@@ -44,7 +44,7 @@ func (s *emailService) CreateEmailVerification(ctx context.Context, req *models.
 		}
 	}
 
-	remainingTime := time.Duration(config.EMAIL_VERIFICATION_DURATION) * time.Minute
+	remainingTime := time.Duration(config.GlobalConfig.App.EmailVerificationDuration) * time.Minute
 	dueTime := time.Now().Add(remainingTime)
 
 	payload := models.EmailVerification{

space/services/forgot_password_service.go

@@ -1,13 +1,14 @@
 package services
 
 import (
-	"api.qobiltu.id/pkg/worker"
-	"api.qobiltu.id/utils"
 	"context"
-	"github.com/hibiken/asynq"
 	"strconv"
 	"time"
 
+	"api.qobiltu.id/pkg/worker"
+	"api.qobiltu.id/utils"
+	"github.com/hibiken/asynq"
+
 	"api.qobiltu.id/config"
 	"api.qobiltu.id/models"
 	"api.qobiltu.id/repositories"
@@ -40,7 +41,7 @@ func (s *ForgotPasswordService) Create(email string) {
 		return
 	}
 
-	remainingTime := time.Duration(config.EMAIL_VERIFICATION_DURATION) * time.Hour
+	remainingTime := time.Duration(config.GlobalConfig.App.EmailVerificationDuration) * time.Minute
 	dueTime := CalculateDueTime(remainingTime)
 
 	s.Constructor.UUID = uuid.NewV4()

space/services/jwt_service.go

@@ -11,16 +11,15 @@ import (
 	"golang.org/x/crypto/bcrypt"
 )
 
-var salt = config.Salt
-var secretKey = []byte(salt)
-
 func GenerateToken(user *models.Account) (string, error) {
+	secretKey := []byte(config.GlobalConfig.App.Salt)
+
 	claims := models.CustomClaims{
 		UserID: user.Id,
 		RegisteredClaims: jwt.RegisteredClaims{
 			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour * 24)), // Token berlaku 24 jam
 			IssuedAt:  jwt.NewNumericDate(time.Now()),
-			Issuer:    "apqobiltu.id",
+			Issuer:    "api.qobiltu.id",
 		},
 	}
 
@@ -38,13 +37,11 @@ func ExtractBearerToken(authHeader string) (string, error) {
 }
 
 func VerifyToken(bearerToken string) (uint, string, error) {
-	// fmt.Println("bearerToken :", bearerToken)
+	secretKey := []byte(config.GlobalConfig.App.Salt)
 
 	tokenData, err := ExtractBearerToken(bearerToken)
 	if err != nil {
 		return 0, "invalid-token", err
-	} else {
-		// fmt.Println("Extracted Token:", tokenData)
 	}
 
 	token, err := jwt.ParseWithClaims(tokenData, &models.CustomClaims{}, func(token *jwt.Token) (interface{}, error) {
@@ -55,7 +52,6 @@ func VerifyToken(bearerToken string) (uint, string, error) {
 		return 0, "invalid-token", err
 	}
 
-	// Extract the claims
 	claims, ok := token.Claims.(*models.CustomClaims)
 	if !ok || !token.Valid {
 		return 0, "invalid-token", err
@@ -74,6 +70,7 @@ func VerifyPassword(hashedPassword, password string) error {
 	}
 	return nil
 }
+
 func HashPassword(password string) (string, error) {
 	bytes, err := bcrypt.GenerateFromPassword([]byte(password), 14)
 	return string(bytes), err

space/services/quiz_service.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"time"
 
+	"api.qobiltu.id/config"
 	"api.qobiltu.id/models"
 	"api.qobiltu.id/pkg/validation"
 	"api.qobiltu.id/repositories"
@@ -27,17 +28,23 @@ type QuizService interface {
 }
 
 type quizService struct {
+	db                *gorm.DB
 	quizRepository    repositories.QuizRepository
 	academyRepository repositories.AcademyRepository
 	validator         *validation.Validator
 }
 
-func NewQuizService(quizRepository repositories.QuizRepository, academyRepository repositories.AcademyRepository, validator *validation.Validator) QuizService {
-	return &quizService{quizRepository: quizRepository, academyRepository: academyRepository, validator: validator}
+func NewQuizService(db *gorm.DB, quizRepository repositories.QuizRepository, academyRepository repositories.AcademyRepository, validator *validation.Validator) QuizService {
+	return &quizService{
+		db:                db,
+		quizRepository:    quizRepository,
+		academyRepository: academyRepository,
+		validator:         validator,
+	}
 }
 
 func (s *quizService) UserGetQuiz(ctx context.Context, req *models.UserGetQuizRequest) (*models.UserGetQuizResponse, error) {
-	quiz, err := s.quizRepository.UserGetQuiz(ctx, req)
+	quiz, err := s.quizRepository.UserGetQuiz(ctx, s.db, req)
 	if err != nil {
 		return nil, response.HandleGormError(err, "Internal Server Error")
 	}
@@ -46,8 +53,8 @@ func (s *quizService) UserGetQuiz(ctx context.Context, req *models.UserGetQuizRe
 }
 
 func (s *quizService) UserAttemptQuiz(ctx context.Context, req *models.UserAttemptQuizRequest) (*models.UserAttemptQuizResponse, error) {
-	// ambil data quiz attempt
-	quizAttempt, err := s.quizRepository.UserGetQuiz(ctx, &models.UserGetQuizRequest{
+	// Fetch quiz data
+	quizAttempt, err := s.quizRepository.UserGetQuiz(ctx, s.db, &models.UserGetQuizRequest{
 		AccountID: req.AccountID,
 		AcademyID: req.AcademyID,
 	})
@@ -57,31 +64,41 @@ func (s *quizService) UserAttemptQuiz(ctx context.Context, req *models.UserAttem
 
 	quiz := &quizAttempt.Quiz
 
-	// ambil attempt quiz yg sedang aktif
-	existingAttempt, err := s.quizRepository.UserGetActiveAttemptQuiz(ctx, req.AccountID, quiz.ID)
+	// check is already passed
+	isPassedQuiz, err := s.quizRepository.UserIsPassedQuiz(ctx, s.db, req.AccountID, quiz.ID)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+
+	if isPassedQuiz {
+		return nil, models.Exception{QuizAlreadyPassed: true, Message: "You have already passed this quiz"}
+	}
+
+	// Check for active attempt
+	existingAttempt, err := s.quizRepository.UserGetActiveAttemptQuiz(ctx, s.db, req.AccountID, quiz.ID)
 	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
 		return nil, response.HandleGormError(err, "Internal Server Error")
 	}
 
-	// jika ada attempt yang sedang active
+	// Handle existing active attempt
 	if existingAttempt != nil {
 		return s.handleActiveAttempt(ctx, req, quiz, existingAttempt)
 	}
 
+	// Handle new attempt
 	return s.handleNewAttempt(ctx, req, quiz)
 }
 
 func (s *quizService) handleActiveAttempt(ctx context.Context, req *models.UserAttemptQuizRequest, quiz *models.Quiz, attempt *models.QuizAttempt) (*models.UserAttemptQuizResponse, error) {
 	now := time.Now()
 
-	// jika attempt nya telah melewati batas waktu dan belum submit / finish
+	// Check if attempt has expired
 	if attempt.DueAt.Before(now) && attempt.FinishedAt == nil {
-		// frontend nge-trigger submit
 		return nil, models.Exception{QuizTimeExpired: true, Message: "Quiz time has expired"}
 	}
 
-	// jika masih dalam waktu yang ditentukan
-	questions, err := s.quizRepository.UserGetAttemptQuizQuestionsResponse(ctx, req.AccountID, quiz.ID, attempt.ID)
+	// Fetch questions for active attempt
+	questions, err := s.quizRepository.UserGetAttemptQuizQuestionsResponse(ctx, s.db, req.AccountID, quiz.ID, attempt.ID)
 	if err != nil {
 		return nil, response.HandleGormError(err, "Internal Server Error")
 	}
@@ -101,64 +118,77 @@ func (s *quizService) handleActiveAttempt(ctx context.Context, req *models.UserA
 }
 
 func (s *quizService) handleNewAttempt(ctx context.Context, req *models.UserAttemptQuizRequest, quiz *models.Quiz) (*models.UserAttemptQuizResponse, error) {
+	var result *models.UserAttemptQuizResponse
 
-	// ini sekedar untuk make sure apakah masih bisa attemp dan telah membaca semua materi.
-	totalAttempts, err := s.quizRepository.UserGetTotalAttemptsQuiz(ctx, req.AccountID, quiz.ID)
-	if err != nil {
-		return nil, response.HandleGormError(err, "Internal Server Error")
-	}
-	if totalAttempts >= quiz.AttemptLimit {
-		return nil, models.Exception{QuizAttemptLimit: true, Message: "Attempt limit reached"}
-	}
+	err := config.RunTx(ctx, s.db, func(tx *gorm.DB) error {
+		// Check total attempts
+		totalAttempts, err := s.quizRepository.UserGetTotalAttemptsQuiz(ctx, tx, req.AccountID, quiz.ID)
+		if err != nil {
+			return response.HandleGormError(err, "Internal Server Error")
+		}
+		if totalAttempts >= quiz.AttemptLimit {
+			return models.Exception{QuizAttemptLimit: true, Message: "Attempt limit reached"}
+		}
 
-	percentage, err := s.academyRepository.UserGetPercentageProgressAcademyByID(ctx, req.AccountID, quiz.AcademyID)
-	if err != nil {
-		return nil, response.HandleGormError(err, "Internal Server Error")
-	}
-	if percentage < 100 {
-		return nil, models.Exception{AcademyNotFinished: true, Message: "Academy not finished"}
-	}
+		// Check academy progress
+		percentage, err := s.academyRepository.UserGetPercentageProgressAcademyByID(ctx, tx, req.AccountID, req.AcademyID)
+		if err != nil {
+			return response.HandleGormError(err, "Internal Server Error")
+		}
+		if percentage < 100 {
+			return models.Exception{AcademyNotFinished: true, Message: "Academy not finished"}
+		}
 
-	// buat attempt quiz
-	attempt := models.QuizAttempt{
-		AccountID: req.AccountID,
-		QuizID:    quiz.ID,
-		AcademyID: quiz.AcademyID,
-		StartedAt: time.Now(),
-		DueAt:     time.Now().Add(time.Duration(quiz.TimeLimit) * time.Minute),
-	}
+		// Create new attempt
+		attempt := models.QuizAttempt{
+			AccountID: req.AccountID,
+			QuizID:    quiz.ID,
+			AcademyID: quiz.AcademyID,
+			StartedAt: time.Now(),
+			DueAt:     time.Now().Add(time.Duration(quiz.TimeLimit) * time.Minute),
+		}
 
-	if err := s.quizRepository.UserCreateAttemptQuiz(ctx, &attempt); err != nil {
-		return nil, response.HandleGormError(err, "Internal Server Error")
-	}
+		if err := s.quizRepository.UserCreateAttemptQuiz(ctx, tx, &attempt); err != nil {
+			return response.HandleGormError(err, "Internal Server Error")
+		}
+
+		// Fetch questions
+		questions, err := s.quizRepository.UserGetAttemptQuizQuestionsResponse(ctx, tx, req.AccountID, quiz.ID, attempt.ID)
+		if err != nil {
+			return response.HandleGormError(err, "Internal Server Error")
+		}
+
+		questions = utils.ShuffleWithKey(questions, attempt.ID)
+
+		result = &models.UserAttemptQuizResponse{
+			ID:         attempt.ID,
+			AccountID:  attempt.AccountID,
+			QuizID:     attempt.QuizID,
+			StartedAt:  attempt.StartedAt,
+			DueAt:      attempt.DueAt,
+			FinishedAt: attempt.FinishedAt,
+			Score:      attempt.Score,
+			Questions:  questions,
+		}
+
+		return nil
+	})
 
-	// ambil question
-	questions, err := s.quizRepository.UserGetAttemptQuizQuestionsResponse(ctx, req.AccountID, quiz.ID, attempt.ID)
 	if err != nil {
-		return nil, response.HandleGormError(err, "Internal Server Error")
+		return nil, models.Exception{InternalServerError: true, Message: "Internal Server Error"}
 	}
 
-	questions = utils.ShuffleWithKey(questions, attempt.ID)
-
-	return &models.UserAttemptQuizResponse{
-		ID:         attempt.ID,
-		AccountID:  attempt.AccountID,
-		QuizID:     attempt.QuizID,
-		StartedAt:  attempt.StartedAt,
-		DueAt:      attempt.DueAt,
-		FinishedAt: attempt.FinishedAt,
-		Score:      attempt.Score,
-		Questions:  questions,
-	}, nil
+	return result, nil
 }
 
 func (s *quizService) calculateQuizScore(
 	ctx context.Context,
+	tx *gorm.DB,
 	quiz *models.Quiz,
 	attempt *models.QuizAttempt,
 ) error {
-	// ambil total question dari quiz
-	totalQuestion, err := s.quizRepository.UserGetTotalQuestionQuiz(ctx, attempt.QuizID)
+	// Fetch total questions
+	totalQuestion, err := s.quizRepository.UserGetTotalQuestionQuiz(ctx, tx, attempt.QuizID)
 	if err != nil {
 		return err
 	}
@@ -172,14 +202,14 @@ func (s *quizService) calculateQuizScore(
 		return nil
 	}
 
-	// ambil semua user answer yang is_correct nya true
-	correctAnswer, err := s.quizRepository.UserGetTotalCorrectAnswerQuiz(ctx, attempt.ID)
+	// Fetch total correct answers
+	correctAnswer, err := s.quizRepository.UserGetTotalCorrectAnswerQuiz(ctx, tx, attempt.ID)
 	if err != nil {
 		return err
 	}
 
+	// Calculate score
 	score := float64(correctAnswer) / float64(totalQuestion) * 100
-
 	attempt.Score = score
 	attempt.TotalQuestions = totalQuestion
 	attempt.TotalCorrectAnswer = correctAnswer
@@ -193,14 +223,14 @@ func (s *quizService) calculateQuizScore(
 }
 
 func (s *quizService) UserGetQuestionQuiz(ctx context.Context, req *models.GetQuestionQuizRequest) (*models.GetQuestionQuizResponse, error) {
-	// pastiin dulu attemp nya ada atau tidak
-	_, err := s.quizRepository.UserGetAttemptByID(ctx, req.AttemptID)
+	// Check if attempt exists
+	_, err := s.quizRepository.UserGetAttemptByID(ctx, s.db, req.AttemptID)
 	if err != nil {
 		return nil, response.HandleGormError(err, "Internal Server Error")
 	}
 
-	// ambil pertanyaan dan jawaban pengguna
-	question, err := s.quizRepository.UserGetQuestionQuiz(ctx, req.AttemptID, req.QuestionID)
+	// Fetch question and user answer
+	question, err := s.quizRepository.UserGetQuestionQuiz(ctx, s.db, req.AttemptID, req.QuestionID)
 	if err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
 			return nil, models.Exception{DataNotFound: true, Message: "Question not found"}
@@ -212,105 +242,135 @@ func (s *quizService) UserGetQuestionQuiz(ctx context.Context, req *models.GetQu
 }
 
 func (s *quizService) UserAnswerQuiz(ctx context.Context, req *models.AnswerQuizRequest) (*models.GetQuestionQuizResponse, error) {
+	var result *models.GetQuestionQuizResponse
 
-	correctOptionID, err := s.quizRepository.GetCorrectOptionID(ctx, req.QuestionID)
-	if err != nil {
-		return nil, response.HandleGormError(err, "Internal Server Error")
-	}
-
-	question, err := s.quizRepository.UserGetUserAnswer(ctx, req.AttemptID, req.QuestionID)
-	if err != nil {
-
-		// jika belum ada answer
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			userAnswer := models.UserAnswer{
-				QuizAttemptID: req.AttemptID,
-				QuestionID:    req.QuestionID,
-				AnswerID:      req.AnswerID,
-				IsDoubt:       req.IsDoubt,
-				IsCorrect:     false,
-			}
-
-			if req.AnswerID != nil {
-				userAnswer.IsCorrect = *req.AnswerID == correctOptionID
-			}
-
-			if err := s.quizRepository.UserSaveUserAnswer(ctx, &userAnswer); err != nil {
-				return nil, response.HandleGormError(err, "Internal Server Error")
-			}
+	err := config.RunTx(ctx, s.db, func(tx *gorm.DB) error {
+		// Fetch correct option ID
+		correctOptionID, err := s.quizRepository.GetCorrectOptionID(ctx, tx, req.QuestionID)
+		if err != nil {
+			return response.HandleGormError(err, "Internal Server Error")
+		}
 
-			res, err := s.quizRepository.UserGetQuestionQuiz(ctx, req.AttemptID, req.QuestionID)
-			if err != nil {
-				return nil, response.HandleGormError(err, "Internal Server Error")
+		// Check if user answer exists
+		question, err := s.quizRepository.UserGetUserAnswer(ctx, tx, req.AttemptID, req.QuestionID)
+		if err != nil {
+			// If no answer exists, create a new one
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				userAnswer := models.UserAnswer{
+					QuizAttemptID: req.AttemptID,
+					QuestionID:    req.QuestionID,
+					AnswerID:      req.AnswerID,
+					IsDoubt:       req.IsDoubt,
+					IsCorrect:     false,
+				}
+
+				if req.AnswerID != nil {
+					userAnswer.IsCorrect = *req.AnswerID == correctOptionID
+				}
+
+				if err := s.quizRepository.UserSaveUserAnswer(ctx, tx, &userAnswer); err != nil {
+					return response.HandleGormError(err, "Internal Server Error")
+				}
+
+				res, err := s.quizRepository.UserGetQuestionQuiz(ctx, tx, req.AttemptID, req.QuestionID)
+				if err != nil {
+					return response.HandleGormError(err, "Internal Server Error")
+				}
+
+				result = res
+				return nil
 			}
 
-			return res, nil
+			return response.HandleGormError(err, "Internal Server Error")
 		}
 
-		return nil, response.HandleGormError(err, "Internal Server Error")
-	}
+		// Update existing answer
+		question.AnswerID = req.AnswerID
+		question.IsDoubt = req.IsDoubt
+		if req.AnswerID != nil {
+			question.IsCorrect = *req.AnswerID == correctOptionID
+		}
 
-	// updating answer
-	question.AnswerID = req.AnswerID
-	question.IsDoubt = req.IsDoubt
+		if err := s.quizRepository.UserSaveUserAnswer(ctx, tx, question); err != nil {
+			return response.HandleGormError(err, "Internal Server Error")
+		}
 
-	if req.AnswerID != nil {
-		question.IsCorrect = *req.AnswerID == correctOptionID
-	}
+		res, err := s.quizRepository.UserGetQuestionQuiz(ctx, tx, req.AttemptID, req.QuestionID)
+		if err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return models.Exception{DataNotFound: true, Message: "Question not found"}
+			}
+			return response.HandleGormError(err, "Internal Server Error")
+		}
 
-	if err := s.quizRepository.UserSaveUserAnswer(ctx, question); err != nil {
-		return nil, response.HandleGormError(err, "Internal Server Error")
-	}
+		result = res
+		return nil
+	})
 
-	res, err := s.quizRepository.UserGetQuestionQuiz(ctx, req.AttemptID, req.QuestionID)
 	if err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return nil, models.Exception{DataNotFound: true, Message: "Question not found"}
-		}
-		return nil, response.HandleGormError(err, "Internal Server Error")
+		return nil, err
 	}
 
-	return res, nil
+	return result, nil
 }
 
 func (s *quizService) UserSubmitQuiz(ctx context.Context, req *models.SubmitQuizRequest) (*models.SubmitQuizResponse, error) {
-	attempt, err := s.quizRepository.UserGetAttemptByID(ctx, req.AttemptID)
-	if err != nil {
-		return nil, response.HandleGormError(err, "Internal Server Error")
-	}
+	var result *models.SubmitQuizResponse
 
-	if err := s.calculateQuizScore(ctx, attempt.Quiz, attempt); err != nil {
-		return nil, response.HandleGormError(err, "Internal Server Error")
-	}
+	err := config.RunTx(ctx, s.db, func(tx *gorm.DB) error {
+		// Fetch attempt
+		attempt, err := s.quizRepository.UserGetAttemptByID(ctx, tx, req.AttemptID)
+		if err != nil {
+			return response.HandleGormError(err, "Internal Server Error")
+		}
 
-	if err := s.quizRepository.UserUpdateAttemptQuiz(ctx, attempt); err != nil {
-		return nil, response.HandleGormError(err, "Internal Server Error")
-	}
+		// Calculate score
+		if err := s.calculateQuizScore(ctx, tx, attempt.Quiz, attempt); err != nil {
+			return response.HandleGormError(err, "Internal Server Error")
+		}
 
-	remainingAttempts, err := s.quizRepository.UserGetRemainingAttempts(ctx, attempt.AccountID, attempt.AcademyID)
-	if err != nil {
-		return nil, response.HandleGormError(err, "Internal Server Error")
-	}
+		// Update attempt
+		if err := s.quizRepository.UserUpdateAttemptQuiz(ctx, tx, attempt); err != nil {
+			return response.HandleGormError(err, "Internal Server Error")
+		}
 
-	if remainingAttempts == 0 {
-		// hapus progress dan semua attempt pada quiz
-		if err := s.quizRepository.UserDeleteProgressAndAttempt(ctx, attempt.AccountID, attempt.QuizID); err != nil {
-			return nil, response.HandleGormError(err, "Internal Server Error")
+		// Get remaining attempts
+		remainingAttempts, err := s.quizRepository.UserGetRemainingAttempts(ctx, tx, attempt.AccountID, attempt.AcademyID)
+		if err != nil {
+			return response.HandleGormError(err, "Internal Server Error")
 		}
+
+		// If no remaining attempts, delete progress and attempts
+		if remainingAttempts == 0 {
+			if err := s.quizRepository.UserDeleteProgressAndAttempt(ctx, tx, attempt.AccountID, attempt.AcademyID); err != nil {
+				return response.HandleGormError(err, "Internal Server Error")
+			}
+		}
+
+		result = &models.SubmitQuizResponse{
+			QuizAttempt:       *attempt,
+			RemainingAttempts: remainingAttempts,
+		}
+
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
 	}
 
-	return &models.SubmitQuizResponse{
-		QuizAttempt:       *attempt,
-		RemainingAttempts: remainingAttempts,
-	}, nil
+	return result, nil
 }
 
 func (s *quizService) UserResultQuiz(ctx context.Context, req *models.ResultQuizRequest) (*models.ResultQuizResponse, error) {
-	attempt, err := s.quizRepository.UseGetLastAttemptQuiz(ctx, req.AccountID, req.AcademyID)
+	// Fetch last attempt
+	attempt, err := s.quizRepository.UseGetLastAttemptQuiz(ctx, s.db, req.AccountID, req.AcademyID)
 	if err != nil {
 		return nil, response.HandleGormError(err, "Internal Server Error")
 	}
-	remainingAttempts, err := s.quizRepository.UserGetRemainingAttempts(ctx, attempt.AccountID, attempt.AcademyID)
+
+	// Get remaining attempts
+	remainingAttempts, err := s.quizRepository.UserGetRemainingAttempts(ctx, s.db, attempt.AccountID, attempt.AcademyID)
 	if err != nil {
 		return nil, response.HandleGormError(err, "Internal Server Error")
 	}
@@ -322,12 +382,14 @@ func (s *quizService) UserResultQuiz(ctx context.Context, req *models.ResultQuiz
 }
 
 func (s *quizService) UserReviewQuiz(ctx context.Context, req *models.ReviewQuizRequest) (*models.ReviewQuizResponse, error) {
-	attempt, err := s.quizRepository.UseGetLastAttemptQuiz(ctx, req.AccountID, req.AcademyID)
+	// Fetch last attempt
+	attempt, err := s.quizRepository.UseGetLastAttemptQuiz(ctx, s.db, req.AccountID, req.AcademyID)
 	if err != nil {
 		return nil, response.HandleGormError(err, "Internal Server Error")
 	}
 
-	review, err := s.quizRepository.UserGetReviewQuiz(ctx, attempt.ID, attempt.AccountID, attempt.QuizID)
+	// Fetch review
+	review, err := s.quizRepository.UserGetReviewQuiz(ctx, s.db, attempt.ID, attempt.AccountID, attempt.QuizID)
 	if err != nil {
 		return nil, response.HandleGormError(err, "Internal Server Error")
 	}

space/space/controller/quiz/quiz_controller.go

@@ -20,6 +20,7 @@ type QuizController interface {
 	UserGetQuestionQuiz(ctx *gin.Context)
 	UserAnswerQuiz(ctx *gin.Context)
 	UserSubmitQuiz(ctx *gin.Context)
+	UserResultQuiz(ctx *gin.Context)
 	UserReviewQuiz(ctx *gin.Context)
 }
 
@@ -189,6 +190,29 @@ func (c *quizController) UserSubmitQuiz(ctx *gin.Context) {
 	response.HandleSuccess(ctx, http.StatusOK, "Quiz submitted successfully", res, nil)
 }
 
+func (c *quizController) UserResultQuiz(ctx *gin.Context) {
+	academyID := ctx.Query("academy_id")
+	academyIDInt, err := strconv.Atoi(academyID)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	accountData := middleware.GetAccountData(ctx)
+	req := models.ResultQuizRequest{
+		AccountID: int64(accountData.UserID),
+		AcademyID: int64(academyIDInt),
+	}
+
+	res, err := c.quizService.UserResultQuiz(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Quiz submitted successfully", res, nil)
+}
+
 func (c *quizController) UserReviewQuiz(ctx *gin.Context) {
 	academyID := ctx.Query("academy_id")
 	academyIDInt, err := strconv.Atoi(academyID)

space/space/models/request_model.go

@@ -234,6 +234,17 @@ type (
 		RemainingAttempts int64 `json:"remaining_attempts" validate:"required"`
 	}
 
+	// RESULT QUIZ
+	ResultQuizRequest struct {
+		AccountID int64 `json:"account_id" validate:"required"`
+		AcademyID int64 `json:"academy_id" validate:"required"`
+	}
+
+	ResultQuizResponse struct {
+		QuizAttempt
+		RemainingAttempts int64 `json:"remaining_attempts" validate:"required"`
+	}
+
 	// REVIEW QUIZ
 	ReviewQuizRequest struct {
 		AccountID int64 `json:"account_id" validate:"required"`
@@ -254,7 +265,7 @@ type (
 			Content   string `json:"content"`
 			IsCorrect bool   `json:"is_correct"`
 		} `json:"answer_options"`
-		AnswerID int64 `json:"answer_id"`
+		AnswerID *int64 `json:"answer_id"`
 	}
 
 	ReviewQuizResponse struct {

space/space/router/quiz_route.go

@@ -12,6 +12,7 @@ func (s *Server) QuizRoute() {
 		userRouterGroup.GET("/question", middleware.AuthUser, s.quizController.UserGetQuestionQuiz)
 		userRouterGroup.PUT("/answer", middleware.AuthUser, s.quizController.UserAnswerQuiz)
 		userRouterGroup.POST("/submit", middleware.AuthUser, s.quizController.UserSubmitQuiz)
+		userRouterGroup.GET("/result", middleware.AuthUser, s.quizController.UserResultQuiz)
 		userRouterGroup.GET("/review", middleware.AuthUser, s.quizController.UserReviewQuiz)
 	}
 }

space/space/services/quiz_service.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"time"
 
+	"api.qobiltu.id/config"
 	"api.qobiltu.id/models"
 	"api.qobiltu.id/pkg/validation"
 	"api.qobiltu.id/repositories"
@@ -22,21 +23,28 @@ type QuizService interface {
 	UserGetQuestionQuiz(ctx context.Context, req *models.GetQuestionQuizRequest) (*models.GetQuestionQuizResponse, error)
 	UserAnswerQuiz(ctx context.Context, req *models.AnswerQuizRequest) (*models.GetQuestionQuizResponse, error)
 	UserSubmitQuiz(ctx context.Context, req *models.SubmitQuizRequest) (*models.SubmitQuizResponse, error)
+	UserResultQuiz(ctx context.Context, req *models.ResultQuizRequest) (*models.ResultQuizResponse, error)
 	UserReviewQuiz(ctx context.Context, req *models.ReviewQuizRequest) (*models.ReviewQuizResponse, error)
 }
 
 type quizService struct {
+	db                *gorm.DB
 	quizRepository    repositories.QuizRepository
 	academyRepository repositories.AcademyRepository
 	validator         *validation.Validator
 }
 
-func NewQuizService(quizRepository repositories.QuizRepository, academyRepository repositories.AcademyRepository, validator *validation.Validator) QuizService {
-	return &quizService{quizRepository: quizRepository, academyRepository: academyRepository, validator: validator}
+func NewQuizService(db *gorm.DB, quizRepository repositories.QuizRepository, academyRepository repositories.AcademyRepository, validator *validation.Validator) QuizService {
+	return &quizService{
+		db:                db,
+		quizRepository:    quizRepository,
+		academyRepository: academyRepository,
+		validator:         validator,
+	}
 }
 
 func (s *quizService) UserGetQuiz(ctx context.Context, req *models.UserGetQuizRequest) (*models.UserGetQuizResponse, error) {
-	quiz, err := s.quizRepository.UserGetQuiz(ctx, req)
+	quiz, err := s.quizRepository.UserGetQuiz(ctx, s.db, req)
 	if err != nil {
 		return nil, response.HandleGormError(err, "Internal Server Error")
 	}
@@ -45,8 +53,8 @@ func (s *quizService) UserGetQuiz(ctx context.Context, req *models.UserGetQuizRe
 }
 
 func (s *quizService) UserAttemptQuiz(ctx context.Context, req *models.UserAttemptQuizRequest) (*models.UserAttemptQuizResponse, error) {
-	// ambil data quiz attempt
-	quizAttempt, err := s.quizRepository.UserGetQuiz(ctx, &models.UserGetQuizRequest{
+	// Fetch quiz data
+	quizAttempt, err := s.quizRepository.UserGetQuiz(ctx, s.db, &models.UserGetQuizRequest{
 		AccountID: req.AccountID,
 		AcademyID: req.AcademyID,
 	})
@@ -56,31 +64,41 @@ func (s *quizService) UserAttemptQuiz(ctx context.Context, req *models.UserAttem
 
 	quiz := &quizAttempt.Quiz
 
-	// ambil attempt quiz yg sedang aktif
-	existingAttempt, err := s.quizRepository.UserGetActiveAttemptQuiz(ctx, req.AccountID, quiz.ID)
+	// check is already passed
+	isPassedQuiz, err := s.quizRepository.UserIsPassedQuiz(ctx, s.db, req.AccountID, quiz.ID)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+
+	if isPassedQuiz {
+		return nil, models.Exception{QuizAlreadyPassed: true, Message: "You have already passed this quiz"}
+	}
+
+	// Check for active attempt
+	existingAttempt, err := s.quizRepository.UserGetActiveAttemptQuiz(ctx, s.db, req.AccountID, quiz.ID)
 	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
 		return nil, response.HandleGormError(err, "Internal Server Error")
 	}
 
-	// jika ada attempt yang sedang active
+	// Handle existing active attempt
 	if existingAttempt != nil {
 		return s.handleActiveAttempt(ctx, req, quiz, existingAttempt)
 	}
 
+	// Handle new attempt
 	return s.handleNewAttempt(ctx, req, quiz)
 }
 
 func (s *quizService) handleActiveAttempt(ctx context.Context, req *models.UserAttemptQuizRequest, quiz *models.Quiz, attempt *models.QuizAttempt) (*models.UserAttemptQuizResponse, error) {
 	now := time.Now()
 
-	// jika attempt nya telah melewati batas waktu dan belum submit / finish
+	// Check if attempt has expired
 	if attempt.DueAt.Before(now) && attempt.FinishedAt == nil {
-		// frontend nge-trigger submit
 		return nil, models.Exception{QuizTimeExpired: true, Message: "Quiz time has expired"}
 	}
 
-	// jika masih dalam waktu yang ditentukan
-	questions, err := s.quizRepository.UserGetAttemptQuizQuestionsResponse(ctx, req.AccountID, quiz.ID, attempt.ID)
+	// Fetch questions for active attempt
+	questions, err := s.quizRepository.UserGetAttemptQuizQuestionsResponse(ctx, s.db, req.AccountID, quiz.ID, attempt.ID)
 	if err != nil {
 		return nil, response.HandleGormError(err, "Internal Server Error")
 	}
@@ -100,64 +118,77 @@ func (s *quizService) handleActiveAttempt(ctx context.Context, req *models.UserA
 }
 
 func (s *quizService) handleNewAttempt(ctx context.Context, req *models.UserAttemptQuizRequest, quiz *models.Quiz) (*models.UserAttemptQuizResponse, error) {
+	var result *models.UserAttemptQuizResponse
 
-	// ini sekedar untuk make sure apakah masih bisa attemp dan telah membaca semua materi.
-	totalAttempts, err := s.quizRepository.UserGetTotalAttemptsQuiz(ctx, req.AccountID, quiz.ID)
-	if err != nil {
-		return nil, response.HandleGormError(err, "Internal Server Error")
-	}
-	if totalAttempts >= quiz.AttemptLimit {
-		return nil, models.Exception{QuizAttemptLimit: true, Message: "Attempt limit reached"}
-	}
+	err := config.RunTx(ctx, s.db, func(tx *gorm.DB) error {
+		// Check total attempts
+		totalAttempts, err := s.quizRepository.UserGetTotalAttemptsQuiz(ctx, tx, req.AccountID, quiz.ID)
+		if err != nil {
+			return response.HandleGormError(err, "Internal Server Error")
+		}
+		if totalAttempts >= quiz.AttemptLimit {
+			return models.Exception{QuizAttemptLimit: true, Message: "Attempt limit reached"}
+		}
 
-	percentage, err := s.academyRepository.UserGetPercentageProgressAcademyByID(ctx, req.AccountID, quiz.AcademyID)
-	if err != nil {
-		return nil, response.HandleGormError(err, "Internal Server Error")
-	}
-	if percentage < 100 {
-		return nil, models.Exception{AcademyNotFinished: true, Message: "Academy not finished"}
-	}
+		// Check academy progress
+		percentage, err := s.academyRepository.UserGetPercentageProgressAcademyByID(ctx, tx, req.AccountID, req.AcademyID)
+		if err != nil {
+			return response.HandleGormError(err, "Internal Server Error")
+		}
+		if percentage < 100 {
+			return models.Exception{AcademyNotFinished: true, Message: "Academy not finished"}
+		}
 
-	// buat attempt quiz
-	attempt := models.QuizAttempt{
-		AccountID: req.AccountID,
-		QuizID:    quiz.ID,
-		AcademyID: quiz.AcademyID,
-		StartedAt: time.Now(),
-		DueAt:     time.Now().Add(time.Duration(quiz.TimeLimit) * time.Minute),
-	}
+		// Create new attempt
+		attempt := models.QuizAttempt{
+			AccountID: req.AccountID,
+			QuizID:    quiz.ID,
+			AcademyID: quiz.AcademyID,
+			StartedAt: time.Now(),
+			DueAt:     time.Now().Add(time.Duration(quiz.TimeLimit) * time.Minute),
+		}
 
-	if err := s.quizRepository.UserCreateAttemptQuiz(ctx, &attempt); err != nil {
-		return nil, response.HandleGormError(err, "Internal Server Error")
-	}
+		if err := s.quizRepository.UserCreateAttemptQuiz(ctx, tx, &attempt); err != nil {
+			return response.HandleGormError(err, "Internal Server Error")
+		}
+
+		// Fetch questions
+		questions, err := s.quizRepository.UserGetAttemptQuizQuestionsResponse(ctx, tx, req.AccountID, quiz.ID, attempt.ID)
+		if err != nil {
+			return response.HandleGormError(err, "Internal Server Error")
+		}
+
+		questions = utils.ShuffleWithKey(questions, attempt.ID)
+
+		result = &models.UserAttemptQuizResponse{
+			ID:         attempt.ID,
+			AccountID:  attempt.AccountID,
+			QuizID:     attempt.QuizID,
+			StartedAt:  attempt.StartedAt,
+			DueAt:      attempt.DueAt,
+			FinishedAt: attempt.FinishedAt,
+			Score:      attempt.Score,
+			Questions:  questions,
+		}
+
+		return nil
+	})
 
-	// ambil question
-	questions, err := s.quizRepository.UserGetAttemptQuizQuestionsResponse(ctx, req.AccountID, quiz.ID, attempt.ID)
 	if err != nil {
-		return nil, response.HandleGormError(err, "Internal Server Error")
+		return nil, models.Exception{InternalServerError: true, Message: "Internal Server Error"}
 	}
 
-	questions = utils.ShuffleWithKey(questions, attempt.ID)
-
-	return &models.UserAttemptQuizResponse{
-		ID:         attempt.ID,
-		AccountID:  attempt.AccountID,
-		QuizID:     attempt.QuizID,
-		StartedAt:  attempt.StartedAt,
-		DueAt:      attempt.DueAt,
-		FinishedAt: attempt.FinishedAt,
-		Score:      attempt.Score,
-		Questions:  questions,
-	}, nil
+	return result, nil
 }
 
 func (s *quizService) calculateQuizScore(
 	ctx context.Context,
+	tx *gorm.DB,
 	quiz *models.Quiz,
 	attempt *models.QuizAttempt,
 ) error {
-	// ambil total question dari quiz
-	totalQuestion, err := s.quizRepository.UserGetTotalQuestionQuiz(ctx, attempt.QuizID)
+	// Fetch total questions
+	totalQuestion, err := s.quizRepository.UserGetTotalQuestionQuiz(ctx, tx, attempt.QuizID)
 	if err != nil {
 		return err
 	}
@@ -171,14 +202,14 @@ func (s *quizService) calculateQuizScore(
 		return nil
 	}
 
-	// ambil semua user answer yang is_correct nya true
-	correctAnswer, err := s.quizRepository.UserGetTotalCorrectAnswerQuiz(ctx, attempt.ID)
+	// Fetch total correct answers
+	correctAnswer, err := s.quizRepository.UserGetTotalCorrectAnswerQuiz(ctx, tx, attempt.ID)
 	if err != nil {
 		return err
 	}
 
+	// Calculate score
 	score := float64(correctAnswer) / float64(totalQuestion) * 100
-
 	attempt.Score = score
 	attempt.TotalQuestions = totalQuestion
 	attempt.TotalCorrectAnswer = correctAnswer
@@ -192,14 +223,14 @@ func (s *quizService) calculateQuizScore(
 }
 
 func (s *quizService) UserGetQuestionQuiz(ctx context.Context, req *models.GetQuestionQuizRequest) (*models.GetQuestionQuizResponse, error) {
-	// pastiin dulu attemp nya ada atau tidak
-	_, err := s.quizRepository.UserGetAttemptByID(ctx, req.AttemptID)
+	// Check if attempt exists
+	_, err := s.quizRepository.UserGetAttemptByID(ctx, s.db, req.AttemptID)
 	if err != nil {
 		return nil, response.HandleGormError(err, "Internal Server Error")
 	}
 
-	// ambil pertanyaan dan jawaban pengguna
-	question, err := s.quizRepository.UserGetQuestionQuiz(ctx, req.AttemptID, req.QuestionID)
+	// Fetch question and user answer
+	question, err := s.quizRepository.UserGetQuestionQuiz(ctx, s.db, req.AttemptID, req.QuestionID)
 	if err != nil {
 		if errors.Is(err, gorm.ErrRecordNotFound) {
 			return nil, models.Exception{DataNotFound: true, Message: "Question not found"}
@@ -211,106 +242,154 @@ func (s *quizService) UserGetQuestionQuiz(ctx context.Context, req *models.GetQu
 }
 
 func (s *quizService) UserAnswerQuiz(ctx context.Context, req *models.AnswerQuizRequest) (*models.GetQuestionQuizResponse, error) {
+	var result *models.GetQuestionQuizResponse
 
-	correctOptionID, err := s.quizRepository.GetCorrectOptionID(ctx, req.QuestionID)
-	if err != nil {
-		return nil, response.HandleGormError(err, "Internal Server Error")
-	}
-
-	question, err := s.quizRepository.UserGetUserAnswer(ctx, req.AttemptID, req.QuestionID)
-	if err != nil {
+	err := config.RunTx(ctx, s.db, func(tx *gorm.DB) error {
+		// Fetch correct option ID
+		correctOptionID, err := s.quizRepository.GetCorrectOptionID(ctx, tx, req.QuestionID)
+		if err != nil {
+			return response.HandleGormError(err, "Internal Server Error")
+		}
 
-		// jika belum ada answer
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			userAnswer := models.UserAnswer{
-				QuizAttemptID: req.AttemptID,
-				QuestionID:    req.QuestionID,
-				AnswerID:      req.AnswerID,
-				IsDoubt:       req.IsDoubt,
-				IsCorrect:     false,
+		// Check if user answer exists
+		question, err := s.quizRepository.UserGetUserAnswer(ctx, tx, req.AttemptID, req.QuestionID)
+		if err != nil {
+			// If no answer exists, create a new one
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				userAnswer := models.UserAnswer{
+					QuizAttemptID: req.AttemptID,
+					QuestionID:    req.QuestionID,
+					AnswerID:      req.AnswerID,
+					IsDoubt:       req.IsDoubt,
+					IsCorrect:     false,
+				}
+
+				if req.AnswerID != nil {
+					userAnswer.IsCorrect = *req.AnswerID == correctOptionID
+				}
+
+				if err := s.quizRepository.UserSaveUserAnswer(ctx, tx, &userAnswer); err != nil {
+					return response.HandleGormError(err, "Internal Server Error")
+				}
+
+				res, err := s.quizRepository.UserGetQuestionQuiz(ctx, tx, req.AttemptID, req.QuestionID)
+				if err != nil {
+					return response.HandleGormError(err, "Internal Server Error")
+				}
+
+				result = res
+				return nil
 			}
 
-			if req.AnswerID != nil {
-				userAnswer.IsCorrect = *req.AnswerID == correctOptionID
-			}
+			return response.HandleGormError(err, "Internal Server Error")
+		}
 
-			if err := s.quizRepository.UserSaveUserAnswer(ctx, &userAnswer); err != nil {
-				return nil, response.HandleGormError(err, "Internal Server Error")
-			}
+		// Update existing answer
+		question.AnswerID = req.AnswerID
+		question.IsDoubt = req.IsDoubt
+		if req.AnswerID != nil {
+			question.IsCorrect = *req.AnswerID == correctOptionID
+		}
 
-			res, err := s.quizRepository.UserGetQuestionQuiz(ctx, req.AttemptID, req.QuestionID)
-			if err != nil {
-				return nil, response.HandleGormError(err, "Internal Server Error")
-			}
+		if err := s.quizRepository.UserSaveUserAnswer(ctx, tx, question); err != nil {
+			return response.HandleGormError(err, "Internal Server Error")
+		}
 
-			return res, nil
+		res, err := s.quizRepository.UserGetQuestionQuiz(ctx, tx, req.AttemptID, req.QuestionID)
+		if err != nil {
+			if errors.Is(err, gorm.ErrRecordNotFound) {
+				return models.Exception{DataNotFound: true, Message: "Question not found"}
+			}
+			return response.HandleGormError(err, "Internal Server Error")
 		}
 
-		return nil, response.HandleGormError(err, "Internal Server Error")
+		result = res
+		return nil
+	})
+
+	if err != nil {
+		return nil, err
 	}
 
-	// updating answer
-	question.AnswerID = req.AnswerID
-	question.IsDoubt = req.IsDoubt
+	return result, nil
+}
 
-	if req.AnswerID != nil {
-		question.IsCorrect = *req.AnswerID == correctOptionID
-	}
+func (s *quizService) UserSubmitQuiz(ctx context.Context, req *models.SubmitQuizRequest) (*models.SubmitQuizResponse, error) {
+	var result *models.SubmitQuizResponse
 
-	if err := s.quizRepository.UserSaveUserAnswer(ctx, question); err != nil {
-		return nil, response.HandleGormError(err, "Internal Server Error")
-	}
+	err := config.RunTx(ctx, s.db, func(tx *gorm.DB) error {
+		// Fetch attempt
+		attempt, err := s.quizRepository.UserGetAttemptByID(ctx, tx, req.AttemptID)
+		if err != nil {
+			return response.HandleGormError(err, "Internal Server Error")
+		}
 
-	res, err := s.quizRepository.UserGetQuestionQuiz(ctx, req.AttemptID, req.QuestionID)
-	if err != nil {
-		if errors.Is(err, gorm.ErrRecordNotFound) {
-			return nil, models.Exception{DataNotFound: true, Message: "Question not found"}
+		// Calculate score
+		if err := s.calculateQuizScore(ctx, tx, attempt.Quiz, attempt); err != nil {
+			return response.HandleGormError(err, "Internal Server Error")
 		}
-		return nil, response.HandleGormError(err, "Internal Server Error")
-	}
 
-	return res, nil
-}
+		// Update attempt
+		if err := s.quizRepository.UserUpdateAttemptQuiz(ctx, tx, attempt); err != nil {
+			return response.HandleGormError(err, "Internal Server Error")
+		}
+
+		// Get remaining attempts
+		remainingAttempts, err := s.quizRepository.UserGetRemainingAttempts(ctx, tx, attempt.AccountID, attempt.AcademyID)
+		if err != nil {
+			return response.HandleGormError(err, "Internal Server Error")
+		}
+
+		// If no remaining attempts, delete progress and attempts
+		if remainingAttempts == 0 {
+			if err := s.quizRepository.UserDeleteProgressAndAttempt(ctx, tx, attempt.AccountID, attempt.AcademyID); err != nil {
+				return response.HandleGormError(err, "Internal Server Error")
+			}
+		}
+
+		result = &models.SubmitQuizResponse{
+			QuizAttempt:       *attempt,
+			RemainingAttempts: remainingAttempts,
+		}
+
+		return nil
+	})
 
-func (s *quizService) UserSubmitQuiz(ctx context.Context, req *models.SubmitQuizRequest) (*models.SubmitQuizResponse, error) {
-	attempt, err := s.quizRepository.UserGetAttemptByID(ctx, req.AttemptID)
 	if err != nil {
-		return nil, response.HandleGormError(err, "Internal Server Error")
+		return nil, err
 	}
 
-	if err := s.calculateQuizScore(ctx, attempt.Quiz, attempt); err != nil {
-		return nil, response.HandleGormError(err, "Internal Server Error")
-	}
+	return result, nil
+}
 
-	if err := s.quizRepository.UserUpdateAttemptQuiz(ctx, attempt); err != nil {
+func (s *quizService) UserResultQuiz(ctx context.Context, req *models.ResultQuizRequest) (*models.ResultQuizResponse, error) {
+	// Fetch last attempt
+	attempt, err := s.quizRepository.UseGetLastAttemptQuiz(ctx, s.db, req.AccountID, req.AcademyID)
+	if err != nil {
 		return nil, response.HandleGormError(err, "Internal Server Error")
 	}
 
-	remainingAttempts, err := s.quizRepository.UserGetRemainingAttempts(ctx, attempt.AccountID, attempt.AcademyID)
+	// Get remaining attempts
+	remainingAttempts, err := s.quizRepository.UserGetRemainingAttempts(ctx, s.db, attempt.AccountID, attempt.AcademyID)
 	if err != nil {
 		return nil, response.HandleGormError(err, "Internal Server Error")
 	}
 
-	if remainingAttempts == 0 {
-		// hapus progress dan semua attempt pada quiz
-		if err := s.quizRepository.UserDeleteProgressAndAttempt(ctx, attempt.AccountID, attempt.QuizID); err != nil {
-			return nil, response.HandleGormError(err, "Internal Server Error")
-		}
-	}
-
-	return &models.SubmitQuizResponse{
+	return &models.ResultQuizResponse{
 		QuizAttempt:       *attempt,
 		RemainingAttempts: remainingAttempts,
 	}, nil
 }
 
 func (s *quizService) UserReviewQuiz(ctx context.Context, req *models.ReviewQuizRequest) (*models.ReviewQuizResponse, error) {
-	attempt, err := s.quizRepository.UseGetLastAttemptQuiz(ctx, req.AccountID, req.AcademyID)
+	// Fetch last attempt
+	attempt, err := s.quizRepository.UseGetLastAttemptQuiz(ctx, s.db, req.AccountID, req.AcademyID)
 	if err != nil {
 		return nil, response.HandleGormError(err, "Internal Server Error")
 	}
 
-	review, err := s.quizRepository.UserGetReviewQuiz(ctx, attempt.ID, attempt.AccountID, attempt.QuizID)
+	// Fetch review
+	review, err := s.quizRepository.UserGetReviewQuiz(ctx, s.db, attempt.ID, attempt.AccountID, attempt.QuizID)
 	if err != nil {
 		return nil, response.HandleGormError(err, "Internal Server Error")
 	}

space/space/space/repositories/quiz_repository.go

@@ -65,6 +65,7 @@ func (r *quizRepository) UserGetQuiz(ctx context.Context, req *models.UserGetQui
             quiz_attempts qa
             ON q.id = qa.quiz_id
             AND qa.account_id = @accountID
+            AND qa.finished_at IS NOT NULL
         WHERE
             q.academy_id = @academyID
         GROUP BY
@@ -77,7 +78,7 @@ func (r *quizRepository) UserGetQuiz(ctx context.Context, req *models.UserGetQui
 		"academyID": req.AcademyID,
 	}).Scan(&quizResponse).Error
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("failed to query quiz: %w", err)
 	}
 
 	if quizResponse.ID == 0 {

space/space/space/space/models/field_counter.go

@@ -164,7 +164,7 @@ func isFieldFilled(field reflect.Value) bool {
 	case reflect.Float32, reflect.Float64:
 		return field.Float() != 0
 	case reflect.Bool:
-		return field.Bool()
+		return true
 	case reflect.Slice, reflect.Map, reflect.Array:
 		return !field.IsNil() && field.Len() > 0
 	case reflect.Struct:

space/space/space/space/pkg/validation/validation.go

@@ -21,9 +21,9 @@ func New(db *gorm.DB) (*Validator, error) {
 		return nil, err
 	}
 
-	// Start background refresh every 10 minutes
+	// Start background refresh every 5 minutes
 	ctx := context.Background()
-	dbSource.StartAutoRefresh(ctx, 10*time.Minute)
+	dbSource.StartAutoRefresh(ctx, 5*time.Minute)
 
 	// create validator
 	validator := NewValidator(dbSource)

space/space/space/space/services/cv_service.go

@@ -192,6 +192,9 @@ func (s *cvService) SavePersonalityAndPreference(ctx context.Context, req *model
 func (s *cvService) GetPersonalityAndPreference(ctx context.Context, req *models.GetPersonalityAndPreferenceRequest) (*models.PersonalityAndPreferenceCV, error) {
 	res, err := s.cvRepository.GetPersonalityAndPreferenceByAccountID(ctx, req.AccountID)
 	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return &models.PersonalityAndPreferenceCV{}, nil
+		}
 		return nil, response.HandleGormError(err, "Internal Server Error")
 	}
 
@@ -312,7 +315,9 @@ func (s *cvService) SavePhysicalAndHealth(ctx context.Context, req *models.SaveP
 func (s *cvService) GetPhysicalAndHealth(ctx context.Context, req *models.GetPhysicalAndHealthRequest) (*models.PhysicalAndHealthCV, error) {
 	res, err := s.cvRepository.GetPhysicalAndHealthByAccountID(ctx, req.AccountID)
 	if err != nil {
-		return nil, response.HandleGormError(err, "Internal Server Error")
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return &models.PhysicalAndHealthCV{}, nil
+		}
 	}
 	return res, nil
 }
@@ -369,7 +374,7 @@ func (s *cvService) SaveWorshipAndReligiousUnderstanding(ctx context.Context, re
 func (s *cvService) GetWorshipAndReligiousUnderstanding(ctx context.Context, req *models.GetWorshipAndReligiousUnderstandingRequest) (*models.WorshipAndReligiousUnderstandingCV, error) {
 	res, err := s.cvRepository.GetWorshipAndReligiousUnderstandingByAccountID(ctx, req.AccountID)
 	if err != nil {
-		return nil, response.HandleGormError(err, "Internal Server Error")
+		return &models.WorshipAndReligiousUnderstandingCV{}, nil
 	}
 	return res, nil
 }

space/space/space/space/space/controller/quiz/quiz_controller.go

@@ -17,6 +17,10 @@ type QuizController interface {
 	// === USER ===
 	UserGetQuiz(ctx *gin.Context)
 	UserAttemptQuiz(ctx *gin.Context)
+	UserGetQuestionQuiz(ctx *gin.Context)
+	UserAnswerQuiz(ctx *gin.Context)
+	UserSubmitQuiz(ctx *gin.Context)
+	UserReviewQuiz(ctx *gin.Context)
 }
 
 type quizController struct {
@@ -30,7 +34,7 @@ func NewQuizController(quizService services.QuizService) QuizController {
 }
 
 func (c *quizController) UserGetQuiz(ctx *gin.Context) {
-	academyID := ctx.Param("id")
+	academyID := ctx.Query("academy_id")
 	academyIDInt, err := strconv.Atoi(academyID)
 	if err != nil {
 		response.HandleError(ctx, err)
@@ -38,6 +42,7 @@ func (c *quizController) UserGetQuiz(ctx *gin.Context) {
 	}
 
 	accountData := middleware.GetAccountData(ctx)
+
 	req := models.UserGetQuizRequest{
 		AccountID: int64(accountData.UserID),
 		AcademyID: int64(academyIDInt),
@@ -49,11 +54,11 @@ func (c *quizController) UserGetQuiz(ctx *gin.Context) {
 		return
 	}
 
-	response.HandleSuccess(ctx, http.StatusOK, "Quiz retrieved successfully", http.StatusOK, res)
+	response.HandleSuccess(ctx, http.StatusOK, "Quiz retrieved successfully", res, nil)
 }
 
 func (c *quizController) UserAttemptQuiz(ctx *gin.Context) {
-	academyID := ctx.Param("id")
+	academyID := ctx.Query("academy_id")
 	academyIDInt, err := strconv.Atoi(academyID)
 	if err != nil {
 		response.HandleError(ctx, err)
@@ -61,6 +66,7 @@ func (c *quizController) UserAttemptQuiz(ctx *gin.Context) {
 	}
 
 	accountData := middleware.GetAccountData(ctx)
+
 	req := models.UserAttemptQuizRequest{
 		AccountID: int64(accountData.UserID),
 		AcademyID: int64(academyIDInt),
@@ -72,5 +78,137 @@ func (c *quizController) UserAttemptQuiz(ctx *gin.Context) {
 		return
 	}
 
-	response.HandleSuccess(ctx, http.StatusOK, "Quiz attempt retrieved successfully", http.StatusOK, res)
+	response.HandleSuccess(ctx, http.StatusOK, "Quiz attempt retrieved successfully", res, nil)
+}
+
+func (c *quizController) UserGetQuestionQuiz(ctx *gin.Context) {
+	academyID := ctx.Query("academy_id")
+	academyIDInt, err := strconv.Atoi(academyID)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	questionID := ctx.Query("question_id")
+	questionIDInt, err := strconv.Atoi(questionID)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	attemptID := ctx.Query("attempt_id")
+	attemptIDInt, err := strconv.Atoi(attemptID)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	accountData := middleware.GetAccountData(ctx)
+
+	req := models.GetQuestionQuizRequest{
+		AccountID:  int64(accountData.UserID),
+		AcademyID:  int64(academyIDInt),
+		QuestionID: int64(questionIDInt),
+		AttemptID:  int64(attemptIDInt),
+	}
+
+	res, err := c.quizService.UserGetQuestionQuiz(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Question retrieved successfully", res, nil)
+}
+
+func (c *quizController) UserAnswerQuiz(ctx *gin.Context) {
+	var req models.AnswerQuizRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	academyID := ctx.Query("academy_id")
+	academyIDInt, err := strconv.Atoi(academyID)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	attemptID := ctx.Query("attempt_id")
+	attemptIDInt, err := strconv.Atoi(attemptID)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	accountData := middleware.GetAccountData(ctx)
+
+	req.AccountID = int64(accountData.UserID)
+	req.AcademyID = int64(academyIDInt)
+	req.AttemptID = int64(attemptIDInt)
+
+	res, err := c.quizService.UserAnswerQuiz(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Question retrieved successfully", res, nil)
+}
+
+func (c *quizController) UserSubmitQuiz(ctx *gin.Context) {
+	academyID := ctx.Query("academy_id")
+	academyIDInt, err := strconv.Atoi(academyID)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	attemptID := ctx.Query("attempt_id")
+	attemptIDInt, err := strconv.Atoi(attemptID)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	accountData := middleware.GetAccountData(ctx)
+
+	req := models.SubmitQuizRequest{
+		AccountID: int64(accountData.UserID),
+		AcademyID: int64(academyIDInt),
+		AttemptID: int64(attemptIDInt),
+	}
+
+	res, err := c.quizService.UserSubmitQuiz(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Quiz submitted successfully", res, nil)
+}
+
+func (c *quizController) UserReviewQuiz(ctx *gin.Context) {
+	academyID := ctx.Query("academy_id")
+	academyIDInt, err := strconv.Atoi(academyID)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	accountData := middleware.GetAccountData(ctx)
+
+	req := models.ReviewQuizRequest{
+		AccountID: int64(accountData.UserID),
+		AcademyID: int64(academyIDInt),
+	}
+
+	res, err := c.quizService.UserReviewQuiz(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Quiz review retrieved successfully", res.Reviews, nil)
 }

space/space/space/space/space/models/database_orm_model.go

@@ -156,7 +156,7 @@ type (
 		Quiz      *Quiz     `gorm:"foreignKey:QuizID;constraint:OnDelete:CASCADE" json:"quiz,omitempty"`
 		Content   string    `gorm:"column:content" json:"content"`
 		Order     int       `gorm:"column:order" json:"order"`
-		Review    string    `gorm:"column:reviews" json:"reviews"`
+		Review    string    `gorm:"column:review" json:"review"`
 		CreatedAt time.Time `gorm:"column:created_at;autoCreateTime" json:"created_at"`
 		UpdatedAt time.Time `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`
 	}
@@ -172,17 +172,23 @@ type (
 	}
 
 	QuizAttempt struct {
-		ID         int64      `gorm:"column:id;primaryKey;autoIncrement"  json:"id"`
-		AccountID  int64      `gorm:"column:account_id;not null" json:"account_id"`
-		Account    *Account   `gorm:"foreignKey:AccountID;constraint:OnDelete:CASCADE" json:"account,omitempty"`
-		QuizID     int64      `gorm:"column:quiz_id;not null" json:"quiz_id"`
-		Quiz       *Quiz      `gorm:"foreignKey:QuizID;constraint:OnDelete:CASCADE" json:"quiz,omitempty"`
-		StartedAt  time.Time  `gorm:"column:started_at;autoCreateTime" json:"started_at"`
-		DueAt      time.Time  `gorm:"column:due_at" json:"due_at"`
-		FinishedAt *time.Time `gorm:"column:finished_at" json:"finished_at"`
-		Score      float64    `gorm:"column:score" json:"score"`
-		CreatedAt  time.Time  `gorm:"column:created_at;autoCreateTime" json:"created_at"`
-		UpdatedAt  time.Time  `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`
+		ID                 int64      `gorm:"column:id;primaryKey;autoIncrement"  json:"id"`
+		AccountID          int64      `gorm:"column:account_id;not null" json:"account_id"`
+		Account            *Account   `gorm:"foreignKey:AccountID;constraint:OnDelete:CASCADE" json:"account,omitempty"`
+		AcademyID          int64      `gorm:"column:academy_id;not null" json:"academy_id"`
+		Academy            *Academy   `gorm:"foreignKey:AcademyID;constraint:OnDelete:CASCADE" json:"academy,omitempty"`
+		QuizID             int64      `gorm:"column:quiz_id;not null" json:"quiz_id"`
+		Quiz               *Quiz      `gorm:"foreignKey:QuizID;constraint:OnDelete:CASCADE" json:"-"`
+		StartedAt          time.Time  `gorm:"column:started_at;autoCreateTime" json:"started_at"`
+		DueAt              time.Time  `gorm:"column:due_at" json:"due_at"`
+		FinishedAt         *time.Time `gorm:"column:finished_at" json:"finished_at"`
+		TotalQuestions     int64      `gorm:"column:total_questions;not null" json:"total_questions"`
+		TotalCorrectAnswer int64      `gorm:"column:total_correct_answer;not null" json:"total_correct_answer"`
+		TotalWrongAnswer   int64      `gorm:"column:total_wrong_answer;not null" json:"total_wrong_answer"`
+		Score              float64    `gorm:"column:score" json:"score"`
+		IsPassed           bool       `gorm:"column:is_passed" json:"is_passed"`
+		CreatedAt          time.Time  `gorm:"column:created_at;autoCreateTime" json:"created_at"`
+		UpdatedAt          time.Time  `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`
 	}
 
 	UserAnswer struct {
@@ -193,7 +199,7 @@ type (
 		Question      *Question    `gorm:"foreignKey:QuestionID;constraint:OnDelete:CASCADE" json:"question,omitempty"`
 		AnswerID      *int64       `gorm:"column:selected_answer_id" json:"selected_answer"`
 		Answer        *Answer      `gorm:"foreignKey:AnswerID;constraint:OnDelete:CASCADE" json:"answer,omitempty"`
-		IsDoubt       bool         `gorm:"column:id_doubt" json:"id_doubt"`
+		IsDoubt       bool         `gorm:"column:is_doubt" json:"is_doubt"`
 		IsCorrect     bool         `gorm:"column:is_correct" json:"is_correct"`
 		CreatedAt     time.Time    `gorm:"column:created_at;autoCreateTime" json:"created_at"`
 		UpdatedAt     time.Time    `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`

space/space/space/space/space/models/request_model.go

@@ -152,6 +152,7 @@ func NewListAcademyContentRequest() ListAcademyContentRequest {
 }
 
 type (
+	// GET QUIZ
 	UserGetQuizRequest struct {
 		AccountID int64 `json:"account_id" validate:"required"`
 		AcademyID int64 `json:"academy_id" validate:"required"`
@@ -159,36 +160,105 @@ type (
 
 	UserGetQuizResponse struct {
 		Quiz
-		TotalQuestions int64 `json:"total_questions"`
-		UserAttempts   int64 `json:"user_attempts"`
+		TotalQuestions   int64 `json:"total_questions"`
+		UserAttempts     int64 `json:"user_attempts"`
+		HasActiveAttempt bool  `json:"has_active_attempt"`
 	}
 
+	// ATTEMP QUIZ
 	UserAttemptQuizRequest struct {
-		AccountID int64 `json:"account_id"`
-		AcademyID int64 `json:"academy_id"`
+		AccountID int64 `json:"account_id" validate:"required"`
+		AcademyID int64 `json:"academy_id" validate:"required"`
 	}
 
 	UserAttemptQuizQuestionsResponse struct {
-		ID         int64 `gorm:"column:id" json:"id"`
-		IsDoubt    bool  `gorm:"column:is_doubt" json:"is_doubt"`
-		IsAnswered bool  `gorm:"column:is_answered" json:"is_answered"`
+		ID         int64 `json:"id"`
+		IsDoubt    bool  `json:"is_doubt"`
+		IsAnswered bool  `json:"is_answered"`
 	}
 
 	UserAttemptQuizResponse struct {
-		QuizAttempt
-		Questions []UserAttemptQuizQuestionsResponse `json:"questions"`
+		ID         int64                              `json:"id"`
+		AccountID  int64                              `json:"account_id"`
+		QuizID     int64                              `json:"quiz_id"`
+		StartedAt  time.Time                          `json:"started_at"`
+		DueAt      time.Time                          `json:"due_at"`
+		FinishedAt *time.Time                         `json:"finished_at"`
+		Score      float64                            `json:"score"`
+		Questions  []UserAttemptQuizQuestionsResponse `json:"questions"`
 	}
 
+	// GET QUESTION
 	GetQuestionQuizRequest struct {
-		AccountID int64 `json:"account_id"`
-		QuizID    int64 `json:"quiz_id" validate:"required"`
+		AccountID  int64 `json:"account_id" validate:"required"`
+		AcademyID  int64 `json:"academy_id" validate:"required"`
+		AttemptID  int64 `json:"attempt_id" validate:"required"`
+		QuestionID int64 `json:"question_id" validate:"required"`
 	}
 
 	GetQuestionQuizResponse struct {
-		Question   Question `json:"question"`
-		Answer     []Answer `json:"answer_options"`
-		UserAnswer int      `json:"current_user_answer"`
-		IsDoubt    bool     `json:"is_doubt"`
+		Question struct {
+			ID      int64  `json:"id"`
+			QuizID  int64  `json:"quiz_id"`
+			Content string `json:"content"`
+		} `json:"question"`
+		AnswerOptions []struct {
+			ID      int64  `json:"id"`
+			Content string `json:"content"`
+		} `json:"answer_options"`
+		AnswerID   *int64 `json:"answer_id"`
+		IsDoubt    bool   `json:"is_doubt"`
+		IsAnswered bool   `json:"is_answered"`
+	}
+
+	// ANSWER QUESTION
+	AnswerQuizRequest struct {
+		AccountID int64 `json:"account_id" validate:"required"`
+		AcademyID int64 `json:"academy_id" validate:"required"`
+		AttemptID int64 `json:"attempt_id" validate:"required"`
+
+		QuestionID int64  `json:"question_id" validate:"required"`
+		AnswerID   *int64 `json:"answer_id"`
+		IsDoubt    bool   `json:"is_doubt"`
+	}
+
+	// SUBMIT QUIZ
+	SubmitQuizRequest struct {
+		AccountID int64 `json:"account_id" validate:"required"`
+		AcademyID int64 `json:"academy_id" validate:"required"`
+		AttemptID int64 `json:"attempt_id" validate:"required"`
+	}
+
+	SubmitQuizResponse struct {
+		QuizAttempt
+		RemainingAttempts int64 `json:"remaining_attempts" validate:"required"`
+	}
+
+	// REVIEW QUIZ
+	ReviewQuizRequest struct {
+		AccountID int64 `json:"account_id" validate:"required"`
+		AcademyID int64 `json:"academy_id" validate:"required"`
+	}
+
+	ReviewQuizQuestion struct {
+		ID      int64  `gorm:"column:id;primaryKey;autoIncrement"  json:"id"`
+		QuizID  int64  `gorm:"column:quiz_id;not null" json:"quiz_id"`
+		Content string `gorm:"column:content" json:"content"`
+		Review  string `gorm:"column:review" json:"review"`
+	}
+
+	ReviewQuiz struct {
+		Question      ReviewQuizQuestion `json:"question"`
+		AnswerOptions []struct {
+			ID        int64  `json:"id"`
+			Content   string `json:"content"`
+			IsCorrect bool   `json:"is_correct"`
+		} `json:"answer_options"`
+		AnswerID int64 `json:"answer_id"`
+	}
+
+	ReviewQuizResponse struct {
+		Reviews []ReviewQuiz
 	}
 )
 
@@ -239,11 +309,6 @@ type QuestionQuizRequest struct {
 	QuestionNo int `json:"question_no" binding:"required"`
 }
 
-type AnswerQuizRequest struct {
-	QuestionNo int `json:"question_no" binding:"required"`
-	Answer     int `json:"answer" binding:"required"`
-}
-
 type (
 	ListCitiesByProvinceIdRequest struct {
 		ProvinceID int64 `json:"province_id" binding:"required"`

space/space/space/space/space/repositories/quiz_repository.go

@@ -2,6 +2,8 @@ package repositories
 
 import (
 	"context"
+	"encoding/json"
+	"fmt"
 
 	"api.qobiltu.id/models"
 	"gorm.io/gorm"
@@ -10,13 +12,25 @@ import (
 type QuizRepository interface {
 	UserGetQuiz(ctx context.Context, req *models.UserGetQuizRequest) (*models.UserGetQuizResponse, error)
 	UserGetActiveAttemptQuiz(ctx context.Context, accountID int64, quizID int64) (*models.QuizAttempt, error)
-	UserUpdateAttemptQuiz(ctx context.Context, attempt *models.QuizAttempt) error
-	UserGetAttemptQuizQuestionsResponse(ctx context.Context, accountID int64, quizID int64, attemptID int64) ([]models.UserAttemptQuizQuestionsResponse, error)
-	UserCreateAttemptQuiz(ctx context.Context, attempt *models.QuizAttempt) error
 	UserGetTotalAttemptsQuiz(ctx context.Context, accountID int64, quizID int64) (int64, error)
+	UserCreateAttemptQuiz(ctx context.Context, attempt *models.QuizAttempt) error
+	UserGetAttemptQuizQuestionsResponse(ctx context.Context, accountID int64, quizID int64, attemptID int64) ([]models.UserAttemptQuizQuestionsResponse, error)
+
+	UserGetAttemptByID(ctx context.Context, attemptID int64) (*models.QuizAttempt, error)
+	UserUpdateAttemptQuiz(ctx context.Context, attempt *models.QuizAttempt) error
+
+	UserGetReviewQuiz(ctx context.Context, attemptID, accountID, quizID int64) (*models.ReviewQuizResponse, error)
+	UseGetLastAttemptQuiz(ctx context.Context, accountID int64, academyID int64) (*models.QuizAttempt, error)
+
 	UserGetTotalQuestionQuiz(ctx context.Context, quizID int64) (int64, error)
 	UserGetTotalCorrectAnswerQuiz(ctx context.Context, quizAttemptID int64) (int64, error)
 	UserDeleteAttemptQuizByAccountIDAndQuizID(ctx context.Context, accountID int64, quizID int64) error
+	UserGetRemainingAttempts(ctx context.Context, accountID int64, quizID int64) (int64, error)
+	UserGetQuestionQuiz(ctx context.Context, attemptID, questionID int64) (*models.GetQuestionQuizResponse, error)
+	UserGetUserAnswer(ctx context.Context, attemptID, questionID int64) (*models.UserAnswer, error)
+	UserSaveUserAnswer(ctx context.Context, answer *models.UserAnswer) error
+	GetCorrectOptionID(ctx context.Context, questionID int64) (int64, error)
+	UserDeleteProgressAndAttempt(ctx context.Context, accountID int64, academyID int64) error
 }
 
 type quizRepository struct {
@@ -31,24 +45,37 @@ func (r *quizRepository) UserGetQuiz(ctx context.Context, req *models.UserGetQui
 	var quizResponse models.UserGetQuizResponse
 
 	rawQuery := `
-		SELECT
-			q.*,
-			(SELECT COUNT(*) FROM questions ques WHERE ques.quiz_id = q.id) AS total_questions,
-			COALESCE(COUNT(qa.id), 0) AS user_attempts
-		FROM
-			quizzes q
-		LEFT JOIN
-			quiz_attempts qa
-		ON q.id = qa.quiz_id
-			AND qa.account_id = ?
-		WHERE
-			q.academy_id = ?
-		GROUP BY
-			q.id, q.academy_id, q.slug, q.title, q.description,
-			q.attempt_limit, q.time_limit, q.min_score, q.created_at, q.updated_at;
-	`
+        SELECT
+            q.*,
+            (SELECT COUNT(*) FROM questions ques WHERE ques.quiz_id = q.id) AS total_questions,
+            COALESCE(COUNT(qa.id), 0) AS user_attempts,
+            CASE
+                WHEN EXISTS (
+                    SELECT 1
+                    FROM quiz_attempts qa2
+                    WHERE qa2.quiz_id = q.id
+                    AND qa2.account_id = @accountID
+                    AND qa2.finished_at IS NULL
+                ) THEN TRUE
+                ELSE FALSE
+            END AS has_active_attempt
+        FROM
+            quizzes q
+        LEFT JOIN
+            quiz_attempts qa
+            ON q.id = qa.quiz_id
+            AND qa.account_id = @accountID
+        WHERE
+            q.academy_id = @academyID
+        GROUP BY
+            q.id, q.academy_id, q.slug, q.title, q.description,
+            q.attempt_limit, q.time_limit, q.min_score, q.created_at, q.updated_at;
+    `
 
-	err := r.db.Raw(rawQuery, req.AccountID, req.AcademyID).Scan(&quizResponse).Error
+	err := r.db.Debug().Raw(rawQuery, map[string]any{
+		"accountID": req.AccountID,
+		"academyID": req.AcademyID,
+	}).Scan(&quizResponse).Error
 	if err != nil {
 		return nil, err
 	}
@@ -63,7 +90,7 @@ func (r *quizRepository) UserGetQuiz(ctx context.Context, req *models.UserGetQui
 func (r *quizRepository) UserGetActiveAttemptQuiz(ctx context.Context, accountID int64, quizID int64) (*models.QuizAttempt, error) {
 	var quizAttempt models.QuizAttempt
 
-	err := r.db.Where("account_id = ? AND quiz_id = ? AND finished_at IS NULL", accountID, quizID).First(&quizAttempt).Error
+	err := r.db.Debug().Where("account_id = ? AND quiz_id = ? AND finished_at IS NULL", accountID, quizID).First(&quizAttempt).Error
 	if err != nil {
 		return nil, err
 	}
@@ -71,8 +98,19 @@ func (r *quizRepository) UserGetActiveAttemptQuiz(ctx context.Context, accountID
 	return &quizAttempt, nil
 }
 
-func (r *quizRepository) UserUpdateAttemptQuiz(ctx context.Context, attempt *models.QuizAttempt) error {
-	return r.db.Model(&models.QuizAttempt{}).Where("id = ?", attempt.ID).Updates(attempt).Error
+func (r *quizRepository) UserGetTotalAttemptsQuiz(ctx context.Context, accountID int64, quizID int64) (int64, error) {
+	var totalAttempts int64
+
+	err := r.db.Debug().Model(&models.QuizAttempt{}).Where("account_id = ? AND quiz_id = ? AND finished_at IS NOT NULL", accountID, quizID).Count(&totalAttempts).Error
+	if err != nil {
+		return 0, err
+	}
+
+	return totalAttempts, nil
+}
+
+func (r *quizRepository) UserCreateAttemptQuiz(ctx context.Context, attempt *models.QuizAttempt) error {
+	return r.db.Debug().Create(attempt).Error
 }
 
 func (r *quizRepository) UserGetAttemptQuizQuestionsResponse(ctx context.Context, accountID int64, quizID int64, attemptID int64) ([]models.UserAttemptQuizQuestionsResponse, error) {
@@ -105,7 +143,7 @@ func (r *quizRepository) UserGetAttemptQuizQuestionsResponse(ctx context.Context
 			q.id;
 	`
 
-	err := r.db.Raw(rawQuery, attemptID, accountID, quizID, attemptID, quizID).Scan(&questions).Error
+	err := r.db.Debug().Raw(rawQuery, attemptID, accountID, quizID, attemptID, quizID).Scan(&questions).Error
 	if err != nil {
 		return nil, err
 	}
@@ -113,19 +151,21 @@ func (r *quizRepository) UserGetAttemptQuizQuestionsResponse(ctx context.Context
 	return questions, nil
 }
 
-func (r *quizRepository) UserCreateAttemptQuiz(ctx context.Context, attempt *models.QuizAttempt) error {
-	return r.db.Create(attempt).Error
-}
-
-func (r *quizRepository) UserGetTotalAttemptsQuiz(ctx context.Context, accountID int64, quizID int64) (int64, error) {
-	var totalAttempts int64
+func (r *quizRepository) UserGetAttemptByID(ctx context.Context, attemptID int64) (*models.QuizAttempt, error) {
+	var quizAttempt models.QuizAttempt
 
-	err := r.db.Model(&models.QuizAttempt{}).Where("account_id = ? AND quiz_id = ? AND finished_at IS NOT NULL", accountID, quizID).Count(&totalAttempts).Error
+	err := r.db.Where("id = ?", attemptID).
+		Preload("Quiz").
+		First(&quizAttempt).Error
 	if err != nil {
-		return 0, err
+		return nil, err
 	}
 
-	return totalAttempts, nil
+	return &quizAttempt, nil
+}
+
+func (r *quizRepository) UserUpdateAttemptQuiz(ctx context.Context, attempt *models.QuizAttempt) error {
+	return r.db.Save(attempt).Error
 }
 
 func (r *quizRepository) UserGetTotalQuestionQuiz(ctx context.Context, quizID int64) (int64, error) {
@@ -153,3 +193,205 @@ func (r *quizRepository) UserGetTotalCorrectAnswerQuiz(ctx context.Context, quiz
 func (r *quizRepository) UserDeleteAttemptQuizByAccountIDAndQuizID(ctx context.Context, accountID int64, quizID int64) error {
 	return r.db.Where("account_id = ? AND quiz_id = ?", accountID, quizID).Delete(&models.QuizAttempt{}).Error
 }
+
+func (r *quizRepository) UserGetRemainingAttempts(ctx context.Context, accountID int64, quizID int64) (int64, error) {
+	var remainingAttempts int64
+
+	rawQuery := `
+        SELECT
+            GREATEST(q.attempt_limit - COALESCE(COUNT(qa.id), 0), 0) AS remaining_attempts
+        FROM
+            quizzes q
+        LEFT JOIN
+            quiz_attempts qa
+            ON q.id = qa.quiz_id
+            AND qa.account_id = ?
+            AND qa.finished_at IS NOT NULL
+        WHERE
+            q.id = ?
+        GROUP BY
+            q.attempt_limit;
+    `
+
+	err := r.db.Raw(rawQuery, accountID, quizID).Scan(&remainingAttempts).Error
+	if err != nil {
+		return 0, err
+	}
+
+	return remainingAttempts, nil
+}
+
+func (r *quizRepository) UserGetQuestionQuiz(ctx context.Context, attemptID, questionID int64) (*models.GetQuestionQuizResponse, error) {
+	var resultJSON string
+	var response models.GetQuestionQuizResponse
+
+	rawQuery := `
+        SELECT
+            json_build_object(
+                'question', json_build_object(
+                    'id', q.id,
+                    'quiz_id', q.quiz_id,
+                    'content', q.content
+                ),
+                'answer_options', json_agg(
+                    json_build_object(
+                        'id', a.id,
+                        'content', a.content
+                    )
+                ),
+                'answer_id', ua.selected_answer_id,
+                'is_doubt', COALESCE(ua.is_doubt, FALSE),
+                'is_answered', ua.selected_answer_id IS NOT NULL
+            ) AS result
+        FROM
+            questions q
+        LEFT JOIN
+            answers a ON q.id = a.question_id
+        LEFT JOIN
+            user_answers ua
+            ON q.id = ua.question_id
+            AND ua.quiz_attempt_id = $1
+        WHERE
+            q.id = $2
+        GROUP BY
+            q.id, q.quiz_id, q.content, ua.selected_answer_id, ua.is_doubt;
+    `
+
+	err := r.db.Raw(rawQuery, attemptID, questionID).Scan(&resultJSON).Error
+	if err != nil {
+		return nil, err
+	}
+
+	err = json.Unmarshal([]byte(resultJSON), &response)
+	if err != nil {
+		return nil, err
+	}
+
+	return &response, nil
+}
+
+func (r *quizRepository) UserGetQuestionByID(ctx context.Context, questionID int64) (*models.Question, error) {
+	var question models.Question
+
+	err := r.db.Where("id = ?", questionID).First(&question).Error
+	if err != nil {
+		return nil, err
+	}
+
+	return &question, nil
+}
+
+func (r *quizRepository) UserGetUserAnswer(ctx context.Context, attemptID, questionID int64) (*models.UserAnswer, error) {
+	var userAnswer models.UserAnswer
+
+	err := r.db.Where("quiz_attempt_id = ? AND question_id = ?", attemptID, questionID).First(&userAnswer).Error
+	if err != nil {
+		return nil, err
+	}
+
+	return &userAnswer, nil
+}
+
+func (r *quizRepository) UserSaveUserAnswer(ctx context.Context, userAnswer *models.UserAnswer) error {
+	return r.db.Save(userAnswer).Error
+}
+
+func (r *quizRepository) UserGetReviewQuiz(ctx context.Context, attemptID, accountID, quizID int64) (*models.ReviewQuizResponse, error) {
+	var resultJSON string
+	var reviewQuizResponse models.ReviewQuizResponse
+
+	reviews := make([]models.ReviewQuiz, 0)
+
+	rawQuery := `
+        SELECT
+            COALESCE(
+                json_agg(
+                    json_build_object(
+                        'question', json_build_object(
+                            'id', q.id,
+                            'quiz_id', q.quiz_id,
+                            'content', q.content,
+                            'review', q.review
+                        ),
+                        'answer_options', (
+                            SELECT json_agg(
+                                json_build_object(
+                                    'id', a.id,
+                                    'content', a.content,
+                                    'is_correct', a.is_correct
+                                )
+                                ORDER BY a.id
+                            )
+                            FROM answers a
+                            WHERE a.question_id = q.id
+                        ),
+                        'answer_id', ua.selected_answer_id
+                    ) ORDER BY q.order
+                ),
+                '[]'::json
+            ) AS reviews
+        FROM
+            questions q
+        LEFT JOIN
+            user_answers ua
+            ON q.id = ua.question_id
+            AND ua.quiz_attempt_id = ?
+        WHERE
+            q.quiz_id = ?
+    `
+
+	err := r.db.Raw(rawQuery, attemptID, quizID).Scan(&resultJSON).Error
+	if err != nil {
+		return nil, fmt.Errorf("failed to query reviews: %w", err)
+	}
+
+	// Unmarshal the JSON result into the Reviews field
+	err = json.Unmarshal([]byte(resultJSON), &reviews)
+	if err != nil {
+		return nil, fmt.Errorf("failed to unmarshal JSON result: %w", err)
+	}
+
+	reviewQuizResponse.Reviews = reviews
+	return &reviewQuizResponse, nil
+}
+
+func (r *quizRepository) UseGetLastAttemptQuiz(ctx context.Context, accountID int64, academyID int64) (*models.QuizAttempt, error) {
+	var attempt models.QuizAttempt
+
+	err := r.db.Where("account_id = ? AND academy_id = ?", accountID, academyID).Last(&attempt).Error
+	if err != nil {
+		return nil, err
+	}
+
+	return &attempt, nil
+}
+
+func (r *quizRepository) GetCorrectOptionID(ctx context.Context, questionID int64) (int64, error) {
+	var correctOptionID int64
+
+	rawQuery := `
+        SELECT id
+        FROM answers
+        WHERE question_id = ?
+        AND is_correct = TRUE
+        LIMIT 1;
+    `
+
+	err := r.db.Raw(rawQuery, questionID).Scan(&correctOptionID).Error
+	if err != nil {
+		return 0, err
+	}
+
+	return correctOptionID, nil
+}
+
+func (r *quizRepository) UserDeleteProgressAndAttempt(ctx context.Context, accountID int64, academyID int64) error {
+	r.db.Where("account_id = ? AND academy_material_id IN (SELECT id FROM academy_materials WHERE academy_id = ?)", accountID, academyID).
+		Delete(&models.AcademyMaterialProgress{})
+
+	// Delete quiz attempts for the quiz associated with the academy
+	r.db.Where("account_id = ? AND quiz_id IN (SELECT id FROM quizzes WHERE academy_id = ?)", accountID, academyID).
+		Delete(&models.QuizAttempt{})
+
+	return nil
+}

space/space/space/space/space/router/quiz_route.go

@@ -7,8 +7,11 @@ import (
 func (s *Server) QuizRoute() {
 	userRouterGroup := s.router.Group("/api/v1/quiz")
 	{
-		// :id is academy id
-		userRouterGroup.GET("/:id", middleware.AuthUser, s.quizController.UserGetQuiz)
-		userRouterGroup.POST("/:id/attempt", middleware.AuthUser, s.quizController.UserAttemptQuiz)
+		userRouterGroup.GET("", middleware.AuthUser, s.quizController.UserGetQuiz)
+		userRouterGroup.POST("/attempt", middleware.AuthUser, s.quizController.UserAttemptQuiz)
+		userRouterGroup.GET("/question", middleware.AuthUser, s.quizController.UserGetQuestionQuiz)
+		userRouterGroup.PUT("/answer", middleware.AuthUser, s.quizController.UserAnswerQuiz)
+		userRouterGroup.POST("/submit", middleware.AuthUser, s.quizController.UserSubmitQuiz)
+		userRouterGroup.GET("/review", middleware.AuthUser, s.quizController.UserReviewQuiz)
 	}
 }

space/space/space/space/space/services/quiz_service.go

@@ -3,29 +3,26 @@ package services
 import (
 	"context"
 	"errors"
-	"math/rand"
 	"time"
 
 	"api.qobiltu.id/models"
 	"api.qobiltu.id/pkg/validation"
 	"api.qobiltu.id/repositories"
 	"api.qobiltu.id/response"
+	"api.qobiltu.id/utils"
 	"gorm.io/gorm"
 )
 
 type QuizService interface {
 	// === ADMIN ===
 
-	// 	// === USER ===
+	// === USER ===
 	UserGetQuiz(ctx context.Context, req *models.UserGetQuizRequest) (*models.UserGetQuizResponse, error)
 	UserAttemptQuiz(ctx context.Context, req *models.UserAttemptQuizRequest) (*models.UserAttemptQuizResponse, error)
-
-	// UserGetQuestionQuiz(ctx context.Context, req *models.GetQuestionQuizRequest) (*models.GetQuestionQuizResponse, error)
-	// UserAnswerQuiz(ctx context.Context, req *models.AnswerQuizRequest) (*models.AnswerQuizResponse, error)
-	// UserReviewQuiz(ctx context.Context, req *models.ReviewQuizRequest) (*models.ReviewQuizResponse, error)
-	// UserSubmitQuiz(ctx context.Context, req *models.SubmitQuizRequest) (*models.SubmitQuizResponse, error)
-	// UserResultQuiz(ctx context.Context, req *models.ResultQuizRequest) (*models.ResultQuizResponse, error)
-	// UserListResultQuiz(ctx context.Context, req *models.ListResultQuizRequest) (*models.ListResultQuizResponse, *models.Paging, error)
+	UserGetQuestionQuiz(ctx context.Context, req *models.GetQuestionQuizRequest) (*models.GetQuestionQuizResponse, error)
+	UserAnswerQuiz(ctx context.Context, req *models.AnswerQuizRequest) (*models.GetQuestionQuizResponse, error)
+	UserSubmitQuiz(ctx context.Context, req *models.SubmitQuizRequest) (*models.SubmitQuizResponse, error)
+	UserReviewQuiz(ctx context.Context, req *models.ReviewQuizRequest) (*models.ReviewQuizResponse, error)
 }
 
 type quizService struct {
@@ -48,6 +45,7 @@ func (s *quizService) UserGetQuiz(ctx context.Context, req *models.UserGetQuizRe
 }
 
 func (s *quizService) UserAttemptQuiz(ctx context.Context, req *models.UserAttemptQuizRequest) (*models.UserAttemptQuizResponse, error) {
+	// ambil data quiz attempt
 	quizAttempt, err := s.quizRepository.UserGetQuiz(ctx, &models.UserGetQuizRequest{
 		AccountID: req.AccountID,
 		AcademyID: req.AcademyID,
@@ -58,66 +56,52 @@ func (s *quizService) UserAttemptQuiz(ctx context.Context, req *models.UserAttem
 
 	quiz := &quizAttempt.Quiz
 
+	// ambil attempt quiz yg sedang aktif
 	existingAttempt, err := s.quizRepository.UserGetActiveAttemptQuiz(ctx, req.AccountID, quiz.ID)
 	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
 		return nil, response.HandleGormError(err, "Internal Server Error")
 	}
 
+	// jika ada attempt yang sedang active
 	if existingAttempt != nil {
-		return s.handleExistingAttempt(ctx, req, quiz, existingAttempt)
+		return s.handleActiveAttempt(ctx, req, quiz, existingAttempt)
 	}
 
 	return s.handleNewAttempt(ctx, req, quiz)
 }
 
-func (s *quizService) handleExistingAttempt(ctx context.Context, req *models.UserAttemptQuizRequest, quiz *models.Quiz, attempt *models.QuizAttempt) (*models.UserAttemptQuizResponse, error) {
+func (s *quizService) handleActiveAttempt(ctx context.Context, req *models.UserAttemptQuizRequest, quiz *models.Quiz, attempt *models.QuizAttempt) (*models.UserAttemptQuizResponse, error) {
 	now := time.Now()
 
-	if attempt.DueAt.Before(now) {
-		if attempt.FinishedAt == nil {
-			attempt.FinishedAt = &now
-			attempt.Score = s.calculateQuizScore(ctx, attempt)
-
-			if err := s.quizRepository.UserUpdateAttemptQuiz(ctx, attempt); err != nil {
-				return nil, response.HandleGormError(err, "Internal Server Error")
-			}
-
-			totalAttempts, err := s.quizRepository.UserGetTotalAttemptsQuiz(ctx, req.AccountID, quiz.ID)
-			if err != nil {
-				return nil, response.HandleGormError(err, "Internal Server Error")
-			}
-
-			if totalAttempts >= quiz.AttemptLimit {
-				if err := s.academyRepository.UserResetAcademyProgressByID(ctx, req.AccountID, quiz.AcademyID); err != nil {
-					return nil, response.HandleGormError(err, "Internal Server Error")
-				}
-
-				// hapus juga semua attempt quiz by account id dan quiz id
-				if err := s.quizRepository.UserDeleteAttemptQuizByAccountIDAndQuizID(ctx, req.AccountID, quiz.ID); err != nil {
-					return nil, response.HandleGormError(err, "Internal Server Error")
-				}
-			}
-
-			return nil, models.Exception{QuizTimeExpired: true, Message: "Quiz time has expired"}
-		}
-
-		return nil, models.Exception{QuizAlreadyFinished: true, Message: "Quiz already finished"}
+	// jika attempt nya telah melewati batas waktu dan belum submit / finish
+	if attempt.DueAt.Before(now) && attempt.FinishedAt == nil {
+		// frontend nge-trigger submit
+		return nil, models.Exception{QuizTimeExpired: true, Message: "Quiz time has expired"}
 	}
 
+	// jika masih dalam waktu yang ditentukan
 	questions, err := s.quizRepository.UserGetAttemptQuizQuestionsResponse(ctx, req.AccountID, quiz.ID, attempt.ID)
 	if err != nil {
 		return nil, response.HandleGormError(err, "Internal Server Error")
 	}
 
-	questions = shuffleWithKey(questions, attempt.ID)
+	questions = utils.ShuffleWithKey(questions, attempt.ID)
 
 	return &models.UserAttemptQuizResponse{
-		QuizAttempt: *attempt,
-		Questions:   questions,
+		ID:         attempt.ID,
+		AccountID:  attempt.AccountID,
+		QuizID:     attempt.QuizID,
+		StartedAt:  attempt.StartedAt,
+		DueAt:      attempt.DueAt,
+		FinishedAt: attempt.FinishedAt,
+		Score:      attempt.Score,
+		Questions:  questions,
 	}, nil
 }
 
 func (s *quizService) handleNewAttempt(ctx context.Context, req *models.UserAttemptQuizRequest, quiz *models.Quiz) (*models.UserAttemptQuizResponse, error) {
+
+	// ini sekedar untuk make sure apakah masih bisa attemp dan telah membaca semua materi.
 	totalAttempts, err := s.quizRepository.UserGetTotalAttemptsQuiz(ctx, req.AccountID, quiz.ID)
 	if err != nil {
 		return nil, response.HandleGormError(err, "Internal Server Error")
@@ -134,67 +118,202 @@ func (s *quizService) handleNewAttempt(ctx context.Context, req *models.UserAtte
 		return nil, models.Exception{AcademyNotFinished: true, Message: "Academy not finished"}
 	}
 
-	quizAttempt := models.QuizAttempt{
+	// buat attempt quiz
+	attempt := models.QuizAttempt{
 		AccountID: req.AccountID,
 		QuizID:    quiz.ID,
+		AcademyID: quiz.AcademyID,
 		StartedAt: time.Now(),
 		DueAt:     time.Now().Add(time.Duration(quiz.TimeLimit) * time.Minute),
 	}
 
-	if err := s.quizRepository.UserCreateAttemptQuiz(ctx, &quizAttempt); err != nil {
+	if err := s.quizRepository.UserCreateAttemptQuiz(ctx, &attempt); err != nil {
 		return nil, response.HandleGormError(err, "Internal Server Error")
 	}
 
-	questions, err := s.quizRepository.UserGetAttemptQuizQuestionsResponse(ctx, req.AccountID, quiz.ID, quizAttempt.ID)
+	// ambil question
+	questions, err := s.quizRepository.UserGetAttemptQuizQuestionsResponse(ctx, req.AccountID, quiz.ID, attempt.ID)
 	if err != nil {
 		return nil, response.HandleGormError(err, "Internal Server Error")
 	}
 
-	questions = shuffleWithKey(questions, quizAttempt.ID)
+	questions = utils.ShuffleWithKey(questions, attempt.ID)
 
 	return &models.UserAttemptQuizResponse{
-		QuizAttempt: quizAttempt,
-		Questions:   questions,
+		ID:         attempt.ID,
+		AccountID:  attempt.AccountID,
+		QuizID:     attempt.QuizID,
+		StartedAt:  attempt.StartedAt,
+		DueAt:      attempt.DueAt,
+		FinishedAt: attempt.FinishedAt,
+		Score:      attempt.Score,
+		Questions:  questions,
 	}, nil
 }
 
-func (s *quizService) calculateQuizScore(ctx context.Context, attempt *models.QuizAttempt) float64 {
+func (s *quizService) calculateQuizScore(
+	ctx context.Context,
+	quiz *models.Quiz,
+	attempt *models.QuizAttempt,
+) error {
 	// ambil total question dari quiz
 	totalQuestion, err := s.quizRepository.UserGetTotalQuestionQuiz(ctx, attempt.QuizID)
 	if err != nil {
-		return 0
+		return err
 	}
 
 	if totalQuestion == 0 {
-		return 0
+		attempt.Score = 0
+		attempt.TotalQuestions = 0
+		attempt.TotalCorrectAnswer = 0
+		attempt.TotalWrongAnswer = 0
+		attempt.IsPassed = false
+		return nil
 	}
 
 	// ambil semua user answer yang is_correct nya true
 	correctAnswer, err := s.quizRepository.UserGetTotalCorrectAnswerQuiz(ctx, attempt.ID)
 	if err != nil {
-		return 0
+		return err
 	}
 
-	// hitung score nya
 	score := float64(correctAnswer) / float64(totalQuestion) * 100
 
-	return score
+	attempt.Score = score
+	attempt.TotalQuestions = totalQuestion
+	attempt.TotalCorrectAnswer = correctAnswer
+	attempt.TotalWrongAnswer = totalQuestion - correctAnswer
+	attempt.IsPassed = score >= float64(quiz.MinScore)
+
+	now := time.Now()
+	attempt.FinishedAt = &now
+
+	return nil
+}
+
+func (s *quizService) UserGetQuestionQuiz(ctx context.Context, req *models.GetQuestionQuizRequest) (*models.GetQuestionQuizResponse, error) {
+	// pastiin dulu attemp nya ada atau tidak
+	_, err := s.quizRepository.UserGetAttemptByID(ctx, req.AttemptID)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+
+	// ambil pertanyaan dan jawaban pengguna
+	question, err := s.quizRepository.UserGetQuestionQuiz(ctx, req.AttemptID, req.QuestionID)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, models.Exception{DataNotFound: true, Message: "Question not found"}
+		}
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+
+	return question, nil
 }
 
-// shuffleWithKey mengacak slice dengan menggunakan integer key sebagai seed
-// untuk memastikan hasil acak yang konsisten untuk key yang sama
-func shuffleWithKey[T any](slice []T, key int64) []T {
-	// Buat salinan slice untuk menghindari modifikasi original
-	shuffled := make([]T, len(slice))
-	copy(shuffled, slice)
+func (s *quizService) UserAnswerQuiz(ctx context.Context, req *models.AnswerQuizRequest) (*models.GetQuestionQuizResponse, error) {
 
-	// Buat random source dengan seed dari key
-	r := rand.New(rand.NewSource(key))
+	correctOptionID, err := s.quizRepository.GetCorrectOptionID(ctx, req.QuestionID)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
 
-	// Lakukan shuffling
-	r.Shuffle(len(shuffled), func(i, j int) {
-		shuffled[i], shuffled[j] = shuffled[j], shuffled[i]
-	})
+	question, err := s.quizRepository.UserGetUserAnswer(ctx, req.AttemptID, req.QuestionID)
+	if err != nil {
+
+		// jika belum ada answer
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			userAnswer := models.UserAnswer{
+				QuizAttemptID: req.AttemptID,
+				QuestionID:    req.QuestionID,
+				AnswerID:      req.AnswerID,
+				IsDoubt:       req.IsDoubt,
+				IsCorrect:     false,
+			}
+
+			if req.AnswerID != nil {
+				userAnswer.IsCorrect = *req.AnswerID == correctOptionID
+			}
+
+			if err := s.quizRepository.UserSaveUserAnswer(ctx, &userAnswer); err != nil {
+				return nil, response.HandleGormError(err, "Internal Server Error")
+			}
+
+			res, err := s.quizRepository.UserGetQuestionQuiz(ctx, req.AttemptID, req.QuestionID)
+			if err != nil {
+				return nil, response.HandleGormError(err, "Internal Server Error")
+			}
+
+			return res, nil
+		}
+
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+
+	// updating answer
+	question.AnswerID = req.AnswerID
+	question.IsDoubt = req.IsDoubt
+
+	if req.AnswerID != nil {
+		question.IsCorrect = *req.AnswerID == correctOptionID
+	}
+
+	if err := s.quizRepository.UserSaveUserAnswer(ctx, question); err != nil {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+
+	res, err := s.quizRepository.UserGetQuestionQuiz(ctx, req.AttemptID, req.QuestionID)
+	if err != nil {
+		if errors.Is(err, gorm.ErrRecordNotFound) {
+			return nil, models.Exception{DataNotFound: true, Message: "Question not found"}
+		}
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+
+	return res, nil
+}
+
+func (s *quizService) UserSubmitQuiz(ctx context.Context, req *models.SubmitQuizRequest) (*models.SubmitQuizResponse, error) {
+	attempt, err := s.quizRepository.UserGetAttemptByID(ctx, req.AttemptID)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+
+	if err := s.calculateQuizScore(ctx, attempt.Quiz, attempt); err != nil {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+
+	if err := s.quizRepository.UserUpdateAttemptQuiz(ctx, attempt); err != nil {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+
+	remainingAttempts, err := s.quizRepository.UserGetRemainingAttempts(ctx, attempt.AccountID, attempt.AcademyID)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+
+	if remainingAttempts == 0 {
+		// hapus progress dan semua attempt pada quiz
+		if err := s.quizRepository.UserDeleteProgressAndAttempt(ctx, attempt.AccountID, attempt.QuizID); err != nil {
+			return nil, response.HandleGormError(err, "Internal Server Error")
+		}
+	}
+
+	return &models.SubmitQuizResponse{
+		QuizAttempt:       *attempt,
+		RemainingAttempts: remainingAttempts,
+	}, nil
+}
+
+func (s *quizService) UserReviewQuiz(ctx context.Context, req *models.ReviewQuizRequest) (*models.ReviewQuizResponse, error) {
+	attempt, err := s.quizRepository.UseGetLastAttemptQuiz(ctx, req.AccountID, req.AcademyID)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+
+	review, err := s.quizRepository.UserGetReviewQuiz(ctx, attempt.ID, attempt.AccountID, attempt.QuizID)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
 
-	return shuffled
+	return review, nil
 }

space/space/space/space/space/space/response/api_response_v2.go

@@ -41,6 +41,15 @@ func HandleError(c *gin.Context, err error) {
 			responseError(c, http.StatusRequestTimeout, exception)
 		case exception.AttemptNotFound:
 			responseError(c, http.StatusNotFound, exception)
+		case exception.QuizTimeExpired:
+			responseError(c, http.StatusBadRequest, exception)
+		case exception.QuizAlreadyFinished:
+			responseError(c, http.StatusBadRequest, exception)
+		case exception.QuizAttemptLimit:
+			responseError(c, http.StatusBadRequest, exception)
+		case exception.AcademyNotFinished:
+			responseError(c, http.StatusBadRequest, exception)
+
 		case exception.ValidationError:
 			responseValidationError(c, http.StatusUnprocessableEntity, exception.ValidationErrorFields)
 		default:

space/space/space/space/space/space/space/config/database_connection_config.go

@@ -62,11 +62,13 @@ func AutoMigrateAll(db *gorm.DB) {
 		&models.RegionProvince{},
 		&models.OptionCategory{},
 		&models.OptionValues{},
+
 		&models.Quiz{},
-		&models.QuizAttempt{},
 		&models.Question{},
 		&models.Answer{},
+		&models.QuizAttempt{},
 		&models.UserAnswer{},
+
 		&models.PersonalityAndPreferenceCV{},
 		&models.FamilyMemberCV{},
 		&models.PhysicalAndHealthCV{},

space/space/space/space/space/space/space/controller/quiz/quiz_controller.go

@@ -0,0 +1,76 @@
+package quiz_controller
+
+import (
+	"net/http"
+	"strconv"
+
+	"api.qobiltu.id/middleware"
+	"api.qobiltu.id/models"
+	"api.qobiltu.id/response"
+	"api.qobiltu.id/services"
+	"github.com/gin-gonic/gin"
+)
+
+type QuizController interface {
+	// === ADMIN ===
+
+	// === USER ===
+	UserGetQuiz(ctx *gin.Context)
+	UserAttemptQuiz(ctx *gin.Context)
+}
+
+type quizController struct {
+	quizService services.QuizService
+}
+
+func NewQuizController(quizService services.QuizService) QuizController {
+	return &quizController{
+		quizService: quizService,
+	}
+}
+
+func (c *quizController) UserGetQuiz(ctx *gin.Context) {
+	academyID := ctx.Param("id")
+	academyIDInt, err := strconv.Atoi(academyID)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	accountData := middleware.GetAccountData(ctx)
+	req := models.UserGetQuizRequest{
+		AccountID: int64(accountData.UserID),
+		AcademyID: int64(academyIDInt),
+	}
+
+	res, err := c.quizService.UserGetQuiz(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Quiz retrieved successfully", http.StatusOK, res)
+}
+
+func (c *quizController) UserAttemptQuiz(ctx *gin.Context) {
+	academyID := ctx.Param("id")
+	academyIDInt, err := strconv.Atoi(academyID)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	accountData := middleware.GetAccountData(ctx)
+	req := models.UserAttemptQuizRequest{
+		AccountID: int64(accountData.UserID),
+		AcademyID: int64(academyIDInt),
+	}
+
+	res, err := c.quizService.UserAttemptQuiz(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Quiz attempt retrieved successfully", http.StatusOK, res)
+}

space/space/space/space/space/space/space/main.go

@@ -12,6 +12,7 @@ import (
 	marriage_readiness_profile_controller "api.qobiltu.id/controller/marriage_readiness_profile"
 	options_controller "api.qobiltu.id/controller/options"
 	partner_criteria_controller "api.qobiltu.id/controller/partner_criteria"
+	quiz_controller "api.qobiltu.id/controller/quiz"
 	region_controller "api.qobiltu.id/controller/region"
 	"api.qobiltu.id/pkg/mail"
 	"api.qobiltu.id/pkg/storage"
@@ -75,6 +76,10 @@ func main() {
 	academyService := services.NewAcademyService(academyRepository, validator)
 	academyController := academy_controller.NewAcademyController(academyService)
 
+	quizRepository := repositories.NewQuizRepository(config.DB)
+	quizService := services.NewQuizService(quizRepository, academyRepository, validator)
+	quizController := quiz_controller.NewQuizController(quizService)
+
 	cvRepository := repositories.NewCVRepository(config.DB)
 	cvService := services.NewCVService(cvRepository, localStorage, validator)
 	cvController := cv_controller.NewCVController(cvService)
@@ -98,6 +103,7 @@ func main() {
 		optionController,
 		emailController,
 		academyController,
+		quizController,
 		cvController,
 		marriageReadinessProfileController,
 		partnerCriteriaController,

space/space/space/space/space/space/space/models/database_orm_model.go

@@ -134,57 +134,71 @@ type RegionCity struct {
 	FullCode   string `json:"full_code"`
 	ProvinceID uint   `json:"province_id"`
 }
-type Answer struct {
-	ID         uint   `gorm:"primaryKey" json:"id"`
-	QuestionID uint   `json:"question_id"`
-	Content    string `json:"content"`
-	IsCorrect  bool   `json:"-"`
-}
-type Question struct {
-	ID            uint   `gorm:"primaryKey"  json:"id"`
-	QuizID        uint   `json:"quiz_id"`
-	Content       string `json:"content"`
-	Order         int    `json:"order"`
-	CorrectAnswer uint   `json:"correct_answer"`
-	Review        string `json:"reviews"`
-}
-type Quiz struct {
-	ID             uint      `gorm:"primaryKey" json:"id"`
-	AcademyID      uint      `json:"academy_id"`
-	Slug           string    `json:"slug" gorm:"uniqueIndex" `
-	Title          string    `json:"title"`
-	Description    string    `json:"description"`
-	TotalQuestions int       `json:"total_questions"`
-	AttemptLimit   int       `json:"attempt_limit"`
-	TimeLimit      int       `json:"time_limit"`
-	MinScore       int       `json:"min_score"`
-	CreatedAt      time.Time `json:"created_at"`
-}
 
-type QuizAttempt struct {
-	ID         uint       `gorm:"primaryKey" json:"id"`
-	AccountID  uint       `json:"user_id"`
-	QuizID     uint       `json:"quiz_id"`
-	StartedAt  time.Time  `json:"started_at"`
-	DueAt      time.Time  `json:"due_at"`
-	FinishedAt *time.Time `json:"finished_at"`
-	Score      float64    `json:"score"`
-}
-type UserAnswer struct {
-	ID             uint `gorm:"primaryKey" json:"id"`
-	QuizAttemptID  uint `json:"quiz_attempt_id"`
-	QuestionID     uint `json:"question_id"`
-	SelectedAnswer uint `json:"selected_answer"`
-	IsDoubt        bool `json:"id_doubt"`
-	IsCorrect      bool `json:"is_correct"`
-}
-type QuizResult struct {
-	QuizAttemptID  uint    `gorm:"column:quiz_attempt_id" json:"quiz_attempt_id"`
-	TotalQuestions int     `gorm:"column:total_questions" json:"total_questions"`
-	CorrectAnswers int     `gorm:"column:correct_answers" json:"correct_answers"`
-	AverageScore   float64 `gorm:"column:average_score" json:"average_score"`
-	IsPassed       bool    `gorm:"column:is_passed" json:"is_passed"`
-}
+type (
+	Quiz struct {
+		ID           int64     `gorm:"column:id;primaryKey;autoIncrement" json:"id"`
+		AcademyID    int64     `gorm:"column:academy_id;not null" json:"academy_id"`
+		Academy      *Academy  `gorm:"foreignKey:AcademyID;constraint:OnDelete:CASCADE" json:"academy,omitempty"`
+		Slug         string    `gorm:"column:slug;uniqueIndex" json:"slug" `
+		Title        string    `gorm:"column:title" json:"title"`
+		Description  string    `gorm:"column:description" json:"description"`
+		AttemptLimit int64     `gorm:"column:attempt_limit" json:"attempt_limit"`
+		TimeLimit    int64     `gorm:"column:time_limit" json:"time_limit"`
+		MinScore     int64     `gorm:"column:min_score" json:"min_score"`
+		CreatedAt    time.Time `gorm:"column:created_at;autoCreateTime" json:"created_at"`
+		UpdatedAt    time.Time `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`
+	}
+
+	Question struct {
+		ID        int64     `gorm:"column:id;primaryKey;autoIncrement"  json:"id"`
+		QuizID    int64     `gorm:"column:quiz_id;not null" json:"quiz_id"`
+		Quiz      *Quiz     `gorm:"foreignKey:QuizID;constraint:OnDelete:CASCADE" json:"quiz,omitempty"`
+		Content   string    `gorm:"column:content" json:"content"`
+		Order     int       `gorm:"column:order" json:"order"`
+		Review    string    `gorm:"column:reviews" json:"reviews"`
+		CreatedAt time.Time `gorm:"column:created_at;autoCreateTime" json:"created_at"`
+		UpdatedAt time.Time `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`
+	}
+
+	Answer struct {
+		ID         int64     `gorm:"column:id;primaryKey;autoIncrement"  json:"id"`
+		QuestionID int64     `gorm:"column:question_id;not null" json:"question_id"`
+		Question   *Question `gorm:"foreignKey:QuestionID;constraint:OnDelete:CASCADE" json:"question,omitempty"`
+		Content    string    `gorm:"column:content" json:"content"`
+		IsCorrect  bool      `gorm:"column:is_correct" json:"is_correct"`
+		CreatedAt  time.Time `gorm:"column:created_at;autoCreateTime" json:"created_at"`
+		UpdatedAt  time.Time `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`
+	}
+
+	QuizAttempt struct {
+		ID         int64      `gorm:"column:id;primaryKey;autoIncrement"  json:"id"`
+		AccountID  int64      `gorm:"column:account_id;not null" json:"account_id"`
+		Account    *Account   `gorm:"foreignKey:AccountID;constraint:OnDelete:CASCADE" json:"account,omitempty"`
+		QuizID     int64      `gorm:"column:quiz_id;not null" json:"quiz_id"`
+		Quiz       *Quiz      `gorm:"foreignKey:QuizID;constraint:OnDelete:CASCADE" json:"quiz,omitempty"`
+		StartedAt  time.Time  `gorm:"column:started_at;autoCreateTime" json:"started_at"`
+		DueAt      time.Time  `gorm:"column:due_at" json:"due_at"`
+		FinishedAt *time.Time `gorm:"column:finished_at" json:"finished_at"`
+		Score      float64    `gorm:"column:score" json:"score"`
+		CreatedAt  time.Time  `gorm:"column:created_at;autoCreateTime" json:"created_at"`
+		UpdatedAt  time.Time  `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`
+	}
+
+	UserAnswer struct {
+		ID            int64        `gorm:"column:id;primaryKey;autoIncrement"  json:"id"`
+		QuizAttemptID int64        `gorm:"column:quiz_attempt_id;not null" json:"quiz_attempt_id"`
+		QuizAttempt   *QuizAttempt `gorm:"foreignKey:QuizAttemptID;constraint:OnDelete:CASCADE" json:"quiz_attempt,omitempty"`
+		QuestionID    int64        `gorm:"column:question_id;not null" json:"question_id"`
+		Question      *Question    `gorm:"foreignKey:QuestionID;constraint:OnDelete:CASCADE" json:"question,omitempty"`
+		AnswerID      *int64       `gorm:"column:selected_answer_id" json:"selected_answer"`
+		Answer        *Answer      `gorm:"foreignKey:AnswerID;constraint:OnDelete:CASCADE" json:"answer,omitempty"`
+		IsDoubt       bool         `gorm:"column:id_doubt" json:"id_doubt"`
+		IsCorrect     bool         `gorm:"column:is_correct" json:"is_correct"`
+		CreatedAt     time.Time    `gorm:"column:created_at;autoCreateTime" json:"created_at"`
+		UpdatedAt     time.Time    `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`
+	}
+)
 
 type (
 	PersonalityAndPreferenceCV struct {
@@ -243,27 +257,34 @@ type (
 	}
 
 	WorshipAndReligiousUnderstandingCV struct {
-		ID                            int64           `gorm:"column:id;primaryKey;autoIncrement" json:"id" counter:"skip"`
-		AccountID                     int64           `gorm:"column:account_id;not null;unique" json:"account_id" counter:"skip"`
-		Account                       *Account        `gorm:"foreignKey:AccountID;constraint:OnDelete:CASCADE" json:"account,omitempty" counter:"skip"`
+		ID        int64    `gorm:"column:id;primaryKey;autoIncrement" json:"id" counter:"skip"`
+		AccountID int64    `gorm:"column:account_id;not null;unique" json:"account_id" counter:"skip"`
+		Account   *Account `gorm:"foreignKey:AccountID;constraint:OnDelete:CASCADE" json:"account,omitempty" counter:"skip"`
+
+		// Data ibadah
 		ObligatoryPrayer              *string         `gorm:"column:obligatory_prayer" json:"obligatory_prayer"`                               // sholat_wajib_5_waktu
 		CongregationalPrayer          *string         `gorm:"column:congregational_prayer" json:"congregational_prayer"`                       // sholat_berjamaah_di_masjid
 		TahajjudPrayer                *string         `gorm:"column:tahajjud_prayer" json:"tahajjud_prayer"`                                   // sholat_tahajud
 		DhuhaPrayer                   *string         `gorm:"column:dhuha_prayer" json:"dhuha_prayer"`                                         // sholat_dhuha
-		QuranMemorization             *string         `gorm:"column:quran_memorization" json:"quran_memorization"`                             // hafalan_alquran
-		QuranReadingAbility           *string         `gorm:"column:quran_reading_ability" json:"quran_reading_ability"`                       // kemampuan_baca_alquran
-		WeeklyReligiousStudyFrequency *string         `gorm:"column:weekly_religious_study_frequency" json:"weekly_religious_study_frequency"` // kajian_yang_diikuti_dalam_sepekan
 		DaudFasting                   *string         `gorm:"column:daud_fasting" json:"daud_fasting"`                                         // puasa_daud
 		AyyamulBidhFasting            *string         `gorm:"column:ayyamul_bidh_fasting" json:"ayyamul_bidh_fasting"`                         // puasa_ayyamul_bidh
+		QuranReadingAbility           *string         `gorm:"column:quran_reading_ability" json:"quran_reading_ability"`                       // kemampuan_baca_alquran
+		QuranMemorization             *string         `gorm:"column:quran_memorization" json:"quran_memorization"`                             // hafalan_alquran
+		WeeklyReligiousStudyFrequency *string         `gorm:"column:weekly_religious_study_frequency" json:"weekly_religious_study_frequency"` // jumlah kajian yang diikuti dalam seminggu
 		HajjOrUmrah                   *pq.StringArray `gorm:"column:hajj_or_umrah;type:varchar(255)[]" json:"hajj_or_umrah"`                   // ibadah_haji_umroh
-		ListeningToMusic              *string         `gorm:"column:listening_to_music" json:"listening_to_music"`                             // mendengarkan_musik
-		OpinionOnIkhtilat             *string         `gorm:"column:opinion_on_ikhtilat" json:"opinion_on_ikhtilat"`                           // pendapat_ikhtilat
-		OpinionOnTouchingNonMahram    *string         `gorm:"column:opinion_on_touching_non_mahram" json:"opinion_on_touching_non_mahram"`     // pendapat_menyentuh_non_mahram
-		OpinionOnVeil                 *string         `gorm:"column:opinion_on_veil" json:"opinion_on_veil"`                                   // pendapat_tentang_cadar
-		WeeklyReligiousStudies        *string         `gorm:"column:weekly_religious_studies" json:"weekly_religious_studies"`                 // kajian_yang_diikuti_dalam_sepekan
-		FollowedUstadz                *string         `gorm:"column:followed_ustadz" json:"followed_ustadz"`                                   // ustadz_yang_diikuti
-		CreatedAt                     time.Time       `gorm:"column:created_at;autoCreateTime" json:"created_at" counter:"skip"`
-		UpdatedAt                     time.Time       `gorm:"column:updated_at;autoUpdateTime" json:"updated_at" counter:"skip"`
+
+		// Data Pemahaman Agama
+		ListeningToMusic           *bool   `gorm:"column:listening_to_music" json:"listening_to_music"`                         // mendengarkan_musik
+		OpinionOnIkhtilat          *string `gorm:"column:opinion_on_ikhtilat" json:"opinion_on_ikhtilat"`                       // pendapat_ikhtilat
+		OpinionOnTouchingNonMahram *string `gorm:"column:opinion_on_touching_non_mahram" json:"opinion_on_touching_non_mahram"` // pendapat_menyentuh_non_mahram
+		OpinionOnVeil              *string `gorm:"column:opinion_on_veil" json:"opinion_on_veil"`                               // pendapat_tentang_cadar
+		OpinionOnBeard             *string `gorm:"column:opinion_on_beard" json:"opinion_on_beard"`                             // pendapat_tentang_jenggot_pada_laki_laki
+		OpinionOnPantsAboveAnkle   *string `gorm:"column:opinion_on_pants_above_ankle" json:"opinion_on_pants_above_ankle"`     // pendapat_tentang_celana_di_atas_mata_kaki
+		WeeklyReligiousStudies     *string `gorm:"column:weekly_religious_studies" json:"weekly_religious_studies"`             // kajian_yang_diikuti_dalam_sepekan
+		FollowedUstadz             *string `gorm:"column:followed_ustadz" json:"followed_ustadz"`                               // ustadz_yang_diikuti
+
+		CreatedAt time.Time `gorm:"column:created_at;autoCreateTime" json:"created_at" counter:"skip"`
+		UpdatedAt time.Time `gorm:"column:updated_at;autoUpdateTime" json:"updated_at" counter:"skip"`
 		FieldCounter
 	}
 
@@ -335,6 +356,46 @@ func (w WorshipAndReligiousUnderstandingCV) GetFilledFields() []string {
 	return w.FieldCounter.GetFilledFields(w)
 }
 
+var WorshipFields = []string{
+	"ObligatoryPrayer",
+	"CongregationalPrayer",
+	"TahajjudPrayer",
+	"DhuhaPrayer",
+	"DaudFasting",
+	"AyyamulBidhFasting",
+	"QuranReadingAbility",
+	"QuranMemorization",
+	"WeeklyReligiousStudyFrequency",
+	"HajjOrUmrah",
+}
+
+var ReligiousUnderstandingFields = []string{
+	"ListeningToMusic",
+	"OpinionOnIkhtilat",
+	"OpinionOnTouchingNonMahram",
+	"OpinionOnVeil",
+	"OpinionOnBeard",
+	"OpinionOnPantsAboveAnkle",
+	"WeeklyReligiousStudies",
+	"FollowedUstadz",
+}
+
+func (w WorshipAndReligiousUnderstandingCV) GetTotalFieldsWorship() int {
+	return w.FieldCounter.CountFieldsByNames(w, WorshipFields)
+}
+
+func (w WorshipAndReligiousUnderstandingCV) GetTotalFieldsReligiousUnderstanding() int {
+	return w.FieldCounter.CountFieldsByNames(w, ReligiousUnderstandingFields)
+}
+
+func (w WorshipAndReligiousUnderstandingCV) GetFilledFieldsWorship() []string {
+	return w.FieldCounter.GetFilledFieldsByNames(w, WorshipFields)
+}
+
+func (w WorshipAndReligiousUnderstandingCV) GetFilledFieldsReligiousUnderstanding() []string {
+	return w.FieldCounter.GetFilledFieldsByNames(w, ReligiousUnderstandingFields)
+}
+
 type (
 	MarriageReadinessProfile struct {
 		ID        int64    `gorm:"column:id;primaryKey;autoIncrement" json:"id"`
@@ -431,9 +492,9 @@ func (AcademyMaterial) TableName() string            { return "academy_materials
 func (AcademyMaterialProgress) TableName() string    { return "academy_materials_progress" }
 func (RegionProvince) TableName() string             { return "region_provinces" }
 func (RegionCity) TableName() string                 { return "region_cities" }
-func (Answer) TableName() string                     { return "answers" }
-func (Question) TableName() string                   { return "questions" }
 func (Quiz) TableName() string                       { return "quizzes" }
+func (Question) TableName() string                   { return "questions" }
+func (Answer) TableName() string                     { return "answers" }
 func (QuizAttempt) TableName() string                { return "quiz_attempts" }
 func (UserAnswer) TableName() string                 { return "user_answers" }
 func (OptionCategory) TableName() string             { return "option_categories" }

space/space/space/space/space/space/space/models/exception_model.go

@@ -18,6 +18,12 @@ type Exception struct {
 	Forbidden             bool `json:"forbidden,omitempty"`
 	ValidationError       bool `json:"validation_error,omitempty"`
 
+	// quiz context
+	QuizTimeExpired     bool `json:"quiz_time_expired,omitempty"`
+	QuizAttemptLimit    bool `json:"quiz_attempt_limit,omitempty"`
+	QuizAlreadyFinished bool `json:"quiz_already_finished,omitempty"`
+	AcademyNotFinished  bool `json:"academy_not_finished,omitempty"`
+
 	Message               string                    `json:"message,omitempty"`
 	Err                   error                     `json:"-"`
 	ValidationErrorFields []validation.ErrorMessage `json:"validation_error_fields,omitempty"`

space/space/space/space/space/space/space/models/field_counter.go

@@ -97,6 +97,46 @@ func (fc FieldCounter) GetFilledFields(s any) []string {
 	return filledFields
 }
 
+// GetFilledFieldsByNames mengembalikan field terisi berdasarkan nama field yang diberikan
+func (fc FieldCounter) GetFilledFieldsByNames(s any, fieldNames []string) []string {
+	var filledFields []string
+	v := reflect.ValueOf(s)
+
+	if v.Kind() == reflect.Ptr {
+		if v.IsNil() {
+			return filledFields
+		}
+		v = v.Elem()
+	}
+
+	t := v.Type()
+	fieldNameSet := make(map[string]struct{}, len(fieldNames))
+	for _, name := range fieldNames {
+		fieldNameSet[name] = struct{}{}
+	}
+
+	for i := 0; i < v.NumField(); i++ {
+		field := v.Field(i)
+		fieldType := t.Field(i)
+		name := fieldType.Name
+
+		if shouldSkipField(fieldType) {
+			continue
+		}
+
+		if _, ok := fieldNameSet[name]; ok && isFieldFilled(field) {
+			filledFields = append(filledFields, name)
+		}
+	}
+
+	return filledFields
+}
+
+// CountFieldsByNames menghitung total field dari daftar yang diberikan (dianggap valid dan bukan skip)
+func (fc FieldCounter) CountFieldsByNames(s any, fieldNames []string) int {
+	return len(fieldNames)
+}
+
 // isFieldFilled memeriksa apakah field memiliki nilai non-zero
 func isFieldFilled(field reflect.Value) bool {
 	// Jika field tidak dapat di-address atau diakses, anggap kosong

space/space/space/space/space/space/space/models/request_model.go

@@ -152,22 +152,31 @@ func NewListAcademyContentRequest() ListAcademyContentRequest {
 }
 
 type (
-	ListQuizRequest struct {
-		AccountID int64 `json:"account_id"`
+	UserGetQuizRequest struct {
+		AccountID int64 `json:"account_id" validate:"required"`
 		AcademyID int64 `json:"academy_id" validate:"required"`
 	}
 
-	ListQuizResponse struct {
-		Quiz []Quiz `json:"quiz"`
+	UserGetQuizResponse struct {
+		Quiz
+		TotalQuestions int64 `json:"total_questions"`
+		UserAttempts   int64 `json:"user_attempts"`
 	}
 
-	AttemptQuizRequest struct {
+	UserAttemptQuizRequest struct {
 		AccountID int64 `json:"account_id"`
-		QuizID    int64 `json:"quiz_id" validate:"required"`
+		AcademyID int64 `json:"academy_id"`
+	}
+
+	UserAttemptQuizQuestionsResponse struct {
+		ID         int64 `gorm:"column:id" json:"id"`
+		IsDoubt    bool  `gorm:"column:is_doubt" json:"is_doubt"`
+		IsAnswered bool  `gorm:"column:is_answered" json:"is_answered"`
 	}
 
-	AttemptQuizResponse struct {
-		QuizAttempt QuizAttempt `json:"quiz_attempt"`
+	UserAttemptQuizResponse struct {
+		QuizAttempt
+		Questions []UserAttemptQuizQuestionsResponse `json:"questions"`
 	}
 
 	GetQuestionQuizRequest struct {
@@ -356,10 +365,12 @@ type (
 		DaudFasting                   *string         `json:"daud_fasting"`                                                                 // puasa_daud
 		AyyamulBidhFasting            *string         `json:"ayyamul_bidh_fasting"`                                                         // puasa_ayyamul_bidh
 		HajjOrUmrah                   *pq.StringArray `json:"hajj_or_umrah"`                                                                // ibadah_haji_umroh
-		ListeningToMusic              *string         `json:"listening_to_music"`                                                           // mendengarkan_musik
+		ListeningToMusic              *bool           `json:"listening_to_music"`                                                           // mendengarkan_musik
 		OpinionOnIkhtilat             *string         `json:"opinion_on_ikhtilat"`                                                          // pendapat_ikhtilat
 		OpinionOnTouchingNonMahram    *string         `json:"opinion_on_touching_non_mahram"`                                               // pendapat_menyentuh_non_mahram
 		OpinionOnVeil                 *string         `json:"opinion_on_veil"`                                                              // pendapat_tentang_cadar
+		OpinionOnBeard                *string         `json:"opinion_on_beard"`                                                             // pendapat_tentang_jenggot_pada_laki_laki
+		OpinionOnPantsAboveAnkle      *string         `json:"opinion_on_pants_above_ankle"`                                                 // pendapat_tentang_celana_di_atas_mata_kaki
 		WeeklyReligiousStudies        *string         `json:"weekly_religious_studies"`                                                     // kajian_yang_diikuti_dalam_sepekan
 		FollowedUstadz                *string         `json:"followed_ustadz"`                                                              // ustadz_yang_diikuti
 	}
@@ -467,15 +478,16 @@ type (
 	}
 
 	GetProgressCVResponse struct {
-		AccountDetailsProgress                     float64 `json:"account_details_progress"`
-		PersonalityAndPreferenceCVProgress         float64 `json:"personality_and_preference_cv_progress"`
-		FamilyMemberCVProgress                     float64 `json:"family_member_cv_progress"`
-		PhysicalAndHealthCVProgress                float64 `json:"physical_and_health_cv_progress"`
-		WorshipAndReligiousUnderstandingCVProgress float64 `json:"worship_and_religious_understanding_cv_progress"`
-		EducationCVProgress                        float64 `json:"education_cv_progress"`
-		JobCVProgress                              float64 `json:"job_cv_progress"`
-		AchievementCVProgress                      float64 `json:"achievement_cv_progress"`
-		TotalProgress                              float64 `json:"total_progress"`
+		AccountDetailsProgress             float64 `json:"account_details_progress"`
+		PersonalityAndPreferenceCVProgress float64 `json:"personality_and_preference_cv_progress"`
+		FamilyMemberCVProgress             float64 `json:"family_member_cv_progress"`
+		PhysicalAndHealthCVProgress        float64 `json:"physical_and_health_cv_progress"`
+		WorshipCVProgress                  float64 `json:"worship_cv_progress"`
+		ReligiousUnderstandingCVProgress   float64 `json:"religious_understanding_cv_progress"`
+		EducationCVProgress                float64 `json:"education_cv_progress"`
+		JobCVProgress                      float64 `json:"job_cv_progress"`
+		AchievementCVProgress              float64 `json:"achievement_cv_progress"`
+		TotalProgress                      float64 `json:"total_progress"`
 	}
 )
 

space/space/space/space/space/space/space/models/response_model.go

@@ -45,11 +45,6 @@ type QuestionResponse struct {
 	IsDoubt    bool     `json:"is_doubt"`
 }
 
-type QuizResultResponse struct {
-	QuizAttempt QuizAttempt `json:"quiz_attempt"`
-	Result      QuizResult  `json:"result"`
-}
-
 type OnExamUserAnswerResponse struct {
 	ID             uint `gorm:"primaryKey" json:"id"`
 	QuizAttemptID  uint `json:"quiz_attempt_id"`

space/space/space/space/space/space/space/repositories/academy_repository.go

@@ -26,12 +26,14 @@ type AcademyRepository interface {
 
 	// === USER ===
 	UserListAcademy(ctx context.Context, req *models.ListAcademyRequest) ([]models.UserAcademyResponse, *models.Paging, error)
+	UserGetPercentageProgressAcademyByID(ctx context.Context, accountID int64, academyID int64) (float64, error)
 	UserListAcademyMaterial(ctx context.Context, req *models.ListAcademyMaterialRequest) ([]models.UserAcademyMaterialResponse, *models.Paging, error)
 	UserGetAcademyBySlug(ctx context.Context, slug string) (*models.AcademyResponse, error)
 	UserGetAcademyMaterialBySlug(ctx context.Context, slug string, accountID int64) (*models.UserAcademyMaterialDetailResponse, error)
 	UserSaveAcademyMaterialProgress(ctx context.Context, req *models.AcademyMaterialProgress) error
 	UserGetAcademyMaterialProgressByAccountID(ctx context.Context, accountID int64, materialID int64) (*models.AcademyMaterialProgress, error)
 	UserDeleteAcademyMaterialProgress(ctx context.Context, accountID int64, materialID int64) error
+	UserResetAcademyProgressByID(ctx context.Context, accountID int64, academyID int64) error
 }
 
 type academyRepository struct {
@@ -286,6 +288,37 @@ func (r *academyRepository) UserListAcademy(ctx context.Context, req *models.Lis
 	return academies, pageInfo, nil
 }
 
+func (r *academyRepository) UserGetPercentageProgressAcademyByID(ctx context.Context, accountID int64, academyID int64) (float64, error) {
+	var totalMaterial int64
+	var totalReadMaterial int64
+
+	// Hitung total materi dalam academy
+	err := r.db.WithContext(ctx).
+		Model(&models.AcademyMaterial{}).
+		Where("academy_id = ?", academyID).
+		Count(&totalMaterial).Error
+	if err != nil {
+		return 0, err
+	}
+
+	// Hitung total materi yang sudah dibaca oleh user
+	err = r.db.WithContext(ctx).
+		Model(&models.AcademyMaterialProgress{}).
+		Joins("JOIN academy_materials am ON am.id = academy_materials_progress.academy_material_id").
+		Where("academy_materials_progress.account_id = ? AND am.academy_id = ?", accountID, academyID).
+		Count(&totalReadMaterial).Error
+	if err != nil {
+		return 0, err
+	}
+
+	// Hitung persentase
+	if totalMaterial == 0 {
+		return 0, nil
+	}
+	percentage := float64(totalReadMaterial) / float64(totalMaterial) * 100
+	return percentage, nil
+}
+
 func (r *academyRepository) UserListAcademyMaterial(ctx context.Context, req *models.ListAcademyMaterialRequest) ([]models.UserAcademyMaterialResponse, *models.Paging, error) {
 	materials := make([]models.UserAcademyMaterialResponse, 0)
 	offset := req.Filter.GetOffset()
@@ -414,3 +447,18 @@ func (r *academyRepository) UserGetAcademyMaterialProgressByAccountID(ctx contex
 func (r *academyRepository) UserDeleteAcademyMaterialProgress(ctx context.Context, accountID int64, materialID int64) error {
 	return r.db.WithContext(ctx).Where("account_id = ? AND academy_material_id = ?", accountID, materialID).Delete(&models.AcademyMaterialProgress{}).Error
 }
+
+func (r *academyRepository) UserResetAcademyProgressByID(ctx context.Context, accountID int64, academyID int64) error {
+	// Subquery untuk mendapatkan semua material ID dari academyID
+	subQuery := r.db.
+		WithContext(ctx).
+		Model(&models.AcademyMaterial{}).
+		Select("id").
+		Where("academy_id = ?", academyID)
+
+	// Delete progress berdasarkan account_id dan academy_material_id yang ada di subquery
+	return r.db.
+		WithContext(ctx).
+		Where("account_id = ? AND academy_material_id IN (?)", accountID, subQuery).
+		Delete(&models.AcademyMaterialProgress{}).Error
+}

space/space/space/space/space/space/space/repositories/quiz_repository.go

@@ -8,7 +8,15 @@ import (
 )
 
 type QuizRepository interface {
-	UserListQuiz(ctx context.Context, req *models.ListQuizRequest) (*models.ListQuizResponse, *models.Paging, error)
+	UserGetQuiz(ctx context.Context, req *models.UserGetQuizRequest) (*models.UserGetQuizResponse, error)
+	UserGetActiveAttemptQuiz(ctx context.Context, accountID int64, quizID int64) (*models.QuizAttempt, error)
+	UserUpdateAttemptQuiz(ctx context.Context, attempt *models.QuizAttempt) error
+	UserGetAttemptQuizQuestionsResponse(ctx context.Context, accountID int64, quizID int64, attemptID int64) ([]models.UserAttemptQuizQuestionsResponse, error)
+	UserCreateAttemptQuiz(ctx context.Context, attempt *models.QuizAttempt) error
+	UserGetTotalAttemptsQuiz(ctx context.Context, accountID int64, quizID int64) (int64, error)
+	UserGetTotalQuestionQuiz(ctx context.Context, quizID int64) (int64, error)
+	UserGetTotalCorrectAnswerQuiz(ctx context.Context, quizAttemptID int64) (int64, error)
+	UserDeleteAttemptQuizByAccountIDAndQuizID(ctx context.Context, accountID int64, quizID int64) error
 }
 
 type quizRepository struct {
@@ -19,144 +27,129 @@ func NewQuizRepository(db *gorm.DB) QuizRepository {
 	return &quizRepository{db: db}
 }
 
-func (r *quizRepository) UserListQuiz(ctx context.Context, req *models.ListQuizRequest) (*models.ListQuizResponse, *models.Paging, error) {
-	panic("not implemented")
-}
+func (r *quizRepository) UserGetQuiz(ctx context.Context, req *models.UserGetQuizRequest) (*models.UserGetQuizResponse, error) {
+	var quizResponse models.UserGetQuizResponse
+
+	rawQuery := `
+		SELECT
+			q.*,
+			(SELECT COUNT(*) FROM questions ques WHERE ques.quiz_id = q.id) AS total_questions,
+			COALESCE(COUNT(qa.id), 0) AS user_attempts
+		FROM
+			quizzes q
+		LEFT JOIN
+			quiz_attempts qa
+		ON q.id = qa.quiz_id
+			AND qa.account_id = ?
+		WHERE
+			q.academy_id = ?
+		GROUP BY
+			q.id, q.academy_id, q.slug, q.title, q.description,
+			q.attempt_limit, q.time_limit, q.min_score, q.created_at, q.updated_at;
+	`
 
-func GetQuizbyAcademyId(academyId uint) Repository[models.Quiz, []models.Quiz] {
-	repo := Construct[models.Quiz, []models.Quiz](
-		models.Quiz{AcademyID: academyId},
-	)
-	repo.Transactions(
-		WhereGivenConstructor[models.Quiz, []models.Quiz],
-		Find[models.Quiz, []models.Quiz],
-	)
-	return *repo
-}
+	err := r.db.Raw(rawQuery, req.AccountID, req.AcademyID).Scan(&quizResponse).Error
+	if err != nil {
+		return nil, err
+	}
 
-func GetAllUserAttempt(userId uint, quizId uint) Repository[models.QuizAttempt, []models.QuizAttempt] {
-	repo := Construct[models.QuizAttempt, []models.QuizAttempt](
-		models.QuizAttempt{AccountID: userId, QuizID: quizId},
-	)
-	repo.Transactions(
-		WhereGivenConstructor[models.QuizAttempt, []models.QuizAttempt],
-		Find[models.QuizAttempt, []models.QuizAttempt],
-	)
-	return *repo
+	if quizResponse.ID == 0 {
+		return nil, gorm.ErrRecordNotFound
+	}
+
+	return &quizResponse, nil
 }
 
-func GetQuizbyId(quizId uint) Repository[models.Quiz, models.Quiz] {
-	repo := Construct[models.Quiz, models.Quiz](
-		models.Quiz{ID: quizId},
-	)
-	repo.Transactions(
-		WhereGivenConstructor[models.Quiz, models.Quiz],
-		Find[models.Quiz, models.Quiz],
-	)
+func (r *quizRepository) UserGetActiveAttemptQuiz(ctx context.Context, accountID int64, quizID int64) (*models.QuizAttempt, error) {
+	var quizAttempt models.QuizAttempt
 
-	return *repo
-}
+	err := r.db.Where("account_id = ? AND quiz_id = ? AND finished_at IS NULL", accountID, quizID).First(&quizAttempt).Error
+	if err != nil {
+		return nil, err
+	}
 
-func GetUserLastAttempt(userId uint, quizId uint) Repository[models.QuizAttempt, models.QuizAttempt] {
-	repo := Construct[models.QuizAttempt, models.QuizAttempt](
-		models.QuizAttempt{AccountID: userId, QuizID: quizId},
-	)
-	repo.Transaction.Where(&repo.Constructor).Last(&repo.Result)
-	repo.RowsError = repo.Transaction.Error
-	repo.NoRecord = false
-	// fmt.Println(repo.Transaction.RowsAffected) Kenapa 0 !!!!
-	return *repo
+	return &quizAttempt, nil
 }
 
-func GetAttemptByIdandUserId(attemptId uint, userId uint) Repository[models.QuizAttempt, models.QuizAttempt] {
-	repo := Construct[models.QuizAttempt, models.QuizAttempt](
-		models.QuizAttempt{
-			ID:        attemptId,
-			AccountID: userId,
-		},
-	)
-	repo.Transactions(
-		WhereGivenConstructor[models.QuizAttempt, models.QuizAttempt],
-		Find[models.QuizAttempt, models.QuizAttempt],
-	)
-	return *repo
+func (r *quizRepository) UserUpdateAttemptQuiz(ctx context.Context, attempt *models.QuizAttempt) error {
+	return r.db.Model(&models.QuizAttempt{}).Where("id = ?", attempt.ID).Updates(attempt).Error
 }
 
-func GetAttemptByUserId(userId uint) Repository[models.QuizAttempt, []models.QuizAttempt] {
-	repo := Construct[models.QuizAttempt, []models.QuizAttempt](
-		models.QuizAttempt{
-			AccountID: userId,
-		},
-	)
-	repo.Transactions(
-		WhereGivenConstructor[models.QuizAttempt, []models.QuizAttempt],
-		Find[models.QuizAttempt, []models.QuizAttempt],
-	)
-	return *repo
-}
-func CreateAttempt(quizAttempt models.QuizAttempt) Repository[models.QuizAttempt, models.QuizAttempt] {
-	repo := Construct[models.QuizAttempt, models.QuizAttempt](
-		quizAttempt,
-	)
+func (r *quizRepository) UserGetAttemptQuizQuestionsResponse(ctx context.Context, accountID int64, quizID int64, attemptID int64) ([]models.UserAttemptQuizQuestionsResponse, error) {
+	questions := make([]models.UserAttemptQuizQuestionsResponse, 0)
+
+	rawQuery := `
+		SELECT
+			q.id,
+			COALESCE(ua.is_doubt, FALSE) AS is_doubt,
+			CASE
+				WHEN ua.id IS NOT NULL
+				AND EXISTS (
+					SELECT 1
+					FROM quiz_attempts qa
+					WHERE qa.id = ?
+					AND qa.account_id = ?
+					AND qa.quiz_id = ?
+				) THEN TRUE
+				ELSE FALSE
+			END AS is_answered
+		FROM
+			questions q
+		LEFT JOIN
+			user_answers ua
+			ON q.id = ua.question_id
+			AND ua.quiz_attempt_id = ?
+		WHERE
+			q.quiz_id = ?
+		ORDER BY
+			q.id;
+	`
+
+	err := r.db.Raw(rawQuery, attemptID, accountID, quizID, attemptID, quizID).Scan(&questions).Error
+	if err != nil {
+		return nil, err
+	}
 
-	Create(repo)
-	return *repo
+	return questions, nil
 }
 
-func GetUserAnswerByAttemptQuestionId(attemptId uint, questionId uint) Repository[models.UserAnswer, models.UserAnswer] {
-	repo := Construct[models.UserAnswer, models.UserAnswer](
-		models.UserAnswer{
-			QuizAttemptID: attemptId,
-			QuestionID:    questionId,
-		},
-	)
-	repo.Transactions(
-		WhereGivenConstructor[models.UserAnswer, models.UserAnswer],
-		Find[models.UserAnswer, models.UserAnswer],
-	)
-	return *repo
+func (r *quizRepository) UserCreateAttemptQuiz(ctx context.Context, attempt *models.QuizAttempt) error {
+	return r.db.Create(attempt).Error
 }
 
-func CreateUserAnswer(userAnswer models.UserAnswer) Repository[models.UserAnswer, models.UserAnswer] {
-	repo := Construct[models.UserAnswer, models.UserAnswer](
-		userAnswer,
-	)
+func (r *quizRepository) UserGetTotalAttemptsQuiz(ctx context.Context, accountID int64, quizID int64) (int64, error) {
+	var totalAttempts int64
 
-	Create(repo)
-	return *repo
-}
+	err := r.db.Model(&models.QuizAttempt{}).Where("account_id = ? AND quiz_id = ? AND finished_at IS NOT NULL", accountID, quizID).Count(&totalAttempts).Error
+	if err != nil {
+		return 0, err
+	}
 
-func UpdateUserAnswer(userAnswer models.UserAnswer) Repository[models.UserAnswer, models.UserAnswer] {
-	repo := Construct[models.UserAnswer, models.UserAnswer](
-		userAnswer,
-	)
-	Update(repo)
-	return *repo
+	return totalAttempts, nil
 }
 
-func UpdateQuizAttempt(quizAttempt models.QuizAttempt) Repository[models.QuizAttempt, models.QuizAttempt] {
-	repo := Construct[models.QuizAttempt, models.QuizAttempt](
-		quizAttempt,
-	)
-	Update(repo)
-	return *repo
-}
+func (r *quizRepository) UserGetTotalQuestionQuiz(ctx context.Context, quizID int64) (int64, error) {
+	var totalQuestion int64
+
+	err := r.db.Model(&models.Question{}).Where("quiz_id = ?", quizID).Count(&totalQuestion).Error
+	if err != nil {
+		return 0, err
+	}
 
-func CountUserAttemptScore(attemptId uint) Repository[models.QuizAttempt, models.QuizResult] {
-	repo := Construct[models.QuizAttempt, models.QuizResult](
-		models.QuizAttempt{ID: attemptId},
-	)
-	repo.Transaction.Model(&repo.Constructor).Raw("SELECT quiz_attempt_id,COUNT(*) AS total_questions,SUM(CASE WHEN is_correct = true THEN 1 ELSE 0 END) AS correct_answers,CAST(SUM(CASE WHEN is_correct = true THEN 1 ELSE 0 END) AS FLOAT) / COUNT(*) AS average_score FROM user_answers WHERE quiz_attempt_id = ? GROUP BY quiz_attempt_id", attemptId).Scan(&repo.Result)
-	repo.RowsError = repo.Transaction.Error
-	repo.NoRecord = false
-	return *repo
+	return totalQuestion, nil
 }
 
-func GetUserAnswerByAttemptId(attemptId uint) Repository[models.UserAnswer, []models.OnExamUserAnswerResponse] {
-	repo := Construct[models.UserAnswer, []models.OnExamUserAnswerResponse](
-		models.UserAnswer{QuizAttemptID: attemptId},
-	)
+func (r *quizRepository) UserGetTotalCorrectAnswerQuiz(ctx context.Context, quizAttemptID int64) (int64, error) {
+	var totalCorrectAnswer int64
+
+	err := r.db.Model(&models.UserAnswer{}).Where("quiz_attempt_id = ? AND is_correct = TRUE", quizAttemptID).Count(&totalCorrectAnswer).Error
+	if err != nil {
+		return 0, err
+	}
+
+	return totalCorrectAnswer, nil
+}
 
-	repo.Transaction.Model(&repo.Constructor).Find(&repo.Result)
-	return *repo
+func (r *quizRepository) UserDeleteAttemptQuizByAccountIDAndQuizID(ctx context.Context, accountID int64, quizID int64) error {
+	return r.db.Where("account_id = ? AND quiz_id = ?", accountID, quizID).Delete(&models.QuizAttempt{}).Error
 }

space/space/space/space/space/space/space/router/quiz_route.go

@@ -1,22 +1,14 @@
 package router
 
 import (
-	QuizController "api.qobiltu.id/controller/quiz"
 	"api.qobiltu.id/middleware"
-	"github.com/gin-gonic/gin"
 )
 
-func QuizRoute(router *gin.Engine) {
-	routerGroup := router.Group("/api/v1/quiz")
+func (s *Server) QuizRoute() {
+	userRouterGroup := s.router.Group("/api/v1/quiz")
 	{
-		routerGroup.GET("/:academy_id/list", middleware.AuthUser, QuizController.List)
-		routerGroup.POST("/:academy_id/:quiz_id/attempt", middleware.AuthUser, QuizController.Attempt)
-		routerGroup.GET("/:academy_id/:quiz_id/question", middleware.AuthUser, QuizController.Question)
-		routerGroup.GET("/:academy_id/:quiz_id/review", middleware.AuthUser, QuizController.Review)
-		routerGroup.PUT("/:academy_id/:quiz_id/choose-answer", middleware.AuthUser, QuizController.Answer)
-		routerGroup.GET("result/:attempt_id", middleware.AuthUser, QuizController.Result)
-		routerGroup.GET("result", middleware.AuthUser, QuizController.Result)
-		routerGroup.POST("/submit-attempt/:attempt_id", middleware.AuthUser, QuizController.Submit)
-		routerGroup.GET("/navigation/:attempt_id", middleware.AuthUser, QuizController.Navigation)
+		// :id is academy id
+		userRouterGroup.GET("/:id", middleware.AuthUser, s.quizController.UserGetQuiz)
+		userRouterGroup.POST("/:id/attempt", middleware.AuthUser, s.quizController.UserAttemptQuiz)
 	}
 }

space/space/space/space/space/space/space/router/router.go

@@ -10,11 +10,11 @@ func (s *Server) setupRoutes() {
 
 	AuthRoute(s.router)
 	UserRoute(s.router)
-	QuizRoute(s.router)
 
 	s.OptionsRoute()
 	s.EmailRoute()
 	s.AcademyRoute()
+	s.QuizRoute()
 	s.CVRoute()
 	s.MarriageReadinessProfileRoute()
 	s.PartnerCriteriaRoute()

space/space/space/space/space/space/space/router/server.go

@@ -7,6 +7,7 @@ import (
 	marriage_readiness_profile_controller "api.qobiltu.id/controller/marriage_readiness_profile"
 	options_controller "api.qobiltu.id/controller/options"
 	partner_criteria_controller "api.qobiltu.id/controller/partner_criteria"
+	quiz_controller "api.qobiltu.id/controller/quiz"
 	region_controller "api.qobiltu.id/controller/region"
 	"github.com/gin-gonic/gin"
 )
@@ -17,6 +18,7 @@ type Server struct {
 	optionsController                  options_controller.OptionsController
 	emailController                    email_controller.EmailController
 	academyController                  academy_controller.AcademyController
+	quizController                     quiz_controller.QuizController
 	cvController                       cv_controller.CVController
 	marriageReadinessProfileController marriage_readiness_profile_controller.MarriageReadinessProfileController
 	partnerCriteriaController          partner_criteria_controller.PartnerCriteriaController
@@ -27,6 +29,7 @@ func NewServer(
 	optionsController options_controller.OptionsController,
 	emailController email_controller.EmailController,
 	academyController academy_controller.AcademyController,
+	quizController quiz_controller.QuizController,
 	cvController cv_controller.CVController,
 	marriageReadinessProfileController marriage_readiness_profile_controller.MarriageReadinessProfileController,
 	partnerCriteriaController partner_criteria_controller.PartnerCriteriaController,
@@ -40,6 +43,7 @@ func NewServer(
 		optionsController:                  optionsController,
 		emailController:                    emailController,
 		academyController:                  academyController,
+		quizController:                     quizController,
 		cvController:                       cvController,
 		marriageReadinessProfileController: marriageReadinessProfileController,
 		partnerCriteriaController:          partnerCriteriaController,

space/space/space/space/space/space/space/services/cv_service.go

@@ -3,6 +3,7 @@ package services
 import (
 	"context"
 	"errors"
+	"fmt"
 	"math"
 	"strconv"
 	"strings"
@@ -318,6 +319,7 @@ func (s *cvService) GetPhysicalAndHealth(ctx context.Context, req *models.GetPhy
 
 func (s *cvService) SaveWorshipAndReligiousUnderstanding(ctx context.Context, req *models.SaveWorshipAndReligiousUnderstandingRequest) (*models.WorshipAndReligiousUnderstandingCV, error) {
 	if err := s.validator.Validate(req); err != nil {
+		fmt.Println(err)
 		return nil, response.HandleValidationError(err)
 	}
 
@@ -339,16 +341,19 @@ func (s *cvService) SaveWorshipAndReligiousUnderstanding(ctx context.Context, re
 	utils.AssignIfNotNil(&worshipAndReligiousUnderstanding.CongregationalPrayer, req.CongregationalPrayer)
 	utils.AssignIfNotNil(&worshipAndReligiousUnderstanding.TahajjudPrayer, req.TahajjudPrayer)
 	utils.AssignIfNotNil(&worshipAndReligiousUnderstanding.DhuhaPrayer, req.DhuhaPrayer)
-	utils.AssignIfNotNil(&worshipAndReligiousUnderstanding.QuranMemorization, req.QuranMemorization)
-	utils.AssignIfNotNil(&worshipAndReligiousUnderstanding.QuranReadingAbility, req.QuranReadingAbility)
-	utils.AssignIfNotNil(&worshipAndReligiousUnderstanding.WeeklyReligiousStudyFrequency, req.WeeklyReligiousStudyFrequency)
 	utils.AssignIfNotNil(&worshipAndReligiousUnderstanding.DaudFasting, req.DaudFasting)
 	utils.AssignIfNotNil(&worshipAndReligiousUnderstanding.AyyamulBidhFasting, req.AyyamulBidhFasting)
+	utils.AssignIfNotNil(&worshipAndReligiousUnderstanding.QuranReadingAbility, req.QuranReadingAbility)
+	utils.AssignIfNotNil(&worshipAndReligiousUnderstanding.QuranMemorization, req.QuranMemorization)
+	utils.AssignIfNotNil(&worshipAndReligiousUnderstanding.WeeklyReligiousStudyFrequency, req.WeeklyReligiousStudyFrequency)
 	utils.AssignIfNotNil(&worshipAndReligiousUnderstanding.HajjOrUmrah, req.HajjOrUmrah)
+
 	utils.AssignIfNotNil(&worshipAndReligiousUnderstanding.ListeningToMusic, req.ListeningToMusic)
 	utils.AssignIfNotNil(&worshipAndReligiousUnderstanding.OpinionOnIkhtilat, req.OpinionOnIkhtilat)
 	utils.AssignIfNotNil(&worshipAndReligiousUnderstanding.OpinionOnTouchingNonMahram, req.OpinionOnTouchingNonMahram)
 	utils.AssignIfNotNil(&worshipAndReligiousUnderstanding.OpinionOnVeil, req.OpinionOnVeil)
+	utils.AssignIfNotNil(&worshipAndReligiousUnderstanding.OpinionOnBeard, req.OpinionOnBeard)
+	utils.AssignIfNotNil(&worshipAndReligiousUnderstanding.OpinionOnPantsAboveAnkle, req.OpinionOnPantsAboveAnkle)
 	utils.AssignIfNotNil(&worshipAndReligiousUnderstanding.WeeklyReligiousStudies, req.WeeklyReligiousStudies)
 	utils.AssignIfNotNil(&worshipAndReligiousUnderstanding.FollowedUstadz, req.FollowedUstadz)
 
@@ -694,24 +699,27 @@ func calculateProgress(
 	accountDetailsPercentage := float64(len(accountDetails.GetFilledFields())) / float64(accountDetails.TotalFields()) * 100
 	personalityAndPreferenceCVPercentage := float64(len(personalityAndPreferenceCV.GetFilledFields())) / float64(personalityAndPreferenceCV.TotalFields()) * 100
 	physicalAndHealthCVPercentage := float64(len(physicalAndHealthCV.GetFilledFields())) / float64(physicalAndHealthCV.TotalFields()) * 100
-	worshipAndReligiousUnderstandingCVPercentage := float64(len(worshipAndReligiousUnderstandingCV.GetFilledFields())) / float64(worshipAndReligiousUnderstandingCV.TotalFields()) * 100
+
+	worshipCVPercentage := float64(len(worshipAndReligiousUnderstandingCV.GetFilledFieldsWorship())) / float64(worshipAndReligiousUnderstandingCV.GetTotalFieldsWorship()) * 100
+	religiousUnderstandingCVPercentage := float64(len(worshipAndReligiousUnderstandingCV.GetFilledFieldsReligiousUnderstanding())) / float64(worshipAndReligiousUnderstandingCV.GetTotalFieldsReligiousUnderstanding()) * 100
 
 	educationCVPercentage := fullIfPresent(educationCV)
 	familyMemberCVPercentage := fullIfPresent(familyMemberCV)
 	jobCVPercentage := fullIfPresent(jobCV)
 	achievementCVPercentage := fullIfPresent(achievementCV)
 
-	overallProgress := (accountDetailsPercentage + personalityAndPreferenceCVPercentage + physicalAndHealthCVPercentage + worshipAndReligiousUnderstandingCVPercentage + educationCVPercentage + familyMemberCVPercentage + jobCVPercentage + achievementCVPercentage) / 8
+	overallProgress := (accountDetailsPercentage + personalityAndPreferenceCVPercentage + physicalAndHealthCVPercentage + worshipCVPercentage + religiousUnderstandingCVPercentage + educationCVPercentage + familyMemberCVPercentage + jobCVPercentage + achievementCVPercentage) / 9
 
 	return &models.GetProgressCVResponse{
-		AccountDetailsProgress:                     math.Round(accountDetailsPercentage*100) / 100,
-		PersonalityAndPreferenceCVProgress:         math.Round(personalityAndPreferenceCVPercentage*100) / 100,
-		FamilyMemberCVProgress:                     math.Round(familyMemberCVPercentage*100) / 100,
-		PhysicalAndHealthCVProgress:                math.Round(physicalAndHealthCVPercentage*100) / 100,
-		WorshipAndReligiousUnderstandingCVProgress: math.Round(worshipAndReligiousUnderstandingCVPercentage*100) / 100,
-		EducationCVProgress:                        math.Round(educationCVPercentage*100) / 100,
-		JobCVProgress:                              math.Round(jobCVPercentage*100) / 100,
-		AchievementCVProgress:                      math.Round(achievementCVPercentage*100) / 100,
-		TotalProgress:                              math.Round(overallProgress*100) / 100,
+		AccountDetailsProgress:             math.Round(accountDetailsPercentage*100) / 100,
+		PersonalityAndPreferenceCVProgress: math.Round(personalityAndPreferenceCVPercentage*100) / 100,
+		FamilyMemberCVProgress:             math.Round(familyMemberCVPercentage*100) / 100,
+		PhysicalAndHealthCVProgress:        math.Round(physicalAndHealthCVPercentage*100) / 100,
+		WorshipCVProgress:                  math.Round(worshipCVPercentage*100) / 100,
+		ReligiousUnderstandingCVProgress:   math.Round(religiousUnderstandingCVPercentage*100) / 100,
+		EducationCVProgress:                math.Round(educationCVPercentage*100) / 100,
+		JobCVProgress:                      math.Round(jobCVPercentage*100) / 100,
+		AchievementCVProgress:              math.Round(achievementCVPercentage*100) / 100,
+		TotalProgress:                      math.Round(overallProgress*100) / 100,
 	}
 }

space/space/space/space/space/space/space/services/quiz_service.go

@@ -1,37 +1,200 @@
 package services
 
-// type QuizService interface {
-// 	// === ADMIN ===
-
-// 	// === USER ===
-// 	UserListQuiz(ctx context.Context, req *models.ListQuizRequest) (*models.ListQuizResponse, *models.Paging, error)
-// 	UserAttemptQuiz(ctx context.Context, req *models.AttemptQuizRequest) (*models.AttemptQuizResponse, error)
-// 	UserGetQuestionQuiz(ctx context.Context, req *models.GetQuestionQuizRequest) (*models.GetQuestionQuizResponse, error)
-// 	// UserAnswerQuiz(ctx context.Context, req *models.AnswerQuizRequest) (*models.AnswerQuizResponse, error)
-// 	// UserReviewQuiz(ctx context.Context, req *models.ReviewQuizRequest) (*models.ReviewQuizResponse, error)
-// 	// UserSubmitQuiz(ctx context.Context, req *models.SubmitQuizRequest) (*models.SubmitQuizResponse, error)
-// 	// UserResultQuiz(ctx context.Context, req *models.ResultQuizRequest) (*models.ResultQuizResponse, error)
-// 	// UserListResultQuiz(ctx context.Context, req *models.ListResultQuizRequest) (*models.ListResultQuizResponse, *models.Paging, error)
-// }
-
-// type quizService struct {
-// 	quizRepository repositories.QuizRepository
-// 	validator      *validation.Validator
-// }
-
-// func NewQuizService(quizRepository repositories.QuizRepository, validator *validation.Validator) QuizService {
-// 	return &quizService{quizRepository: quizRepository, validator: validator}
-// }
-
-// func (s *quizService) UserListQuiz(ctx context.Context, req *models.ListQuizRequest) (*models.ListQuizResponse, *models.Paging, error) {
-// 	quiz, paging, err := s.quizRepository.UserListQuiz(ctx, req)
-// 	if err != nil {
-// 		return nil, nil, response.HandleGormError(err, "Internal Server Error")
-// 	}
-
-// 	return quiz, paging, nil
-// }
-
-// func (s *quizService) UserAttemptQuiz(ctx context.Context, req *models.AttemptQuizRequest) (*models.AttemptQuizResponse, error) {
-// 	panic("not implemented")
-// }
+import (
+	"context"
+	"errors"
+	"math/rand"
+	"time"
+
+	"api.qobiltu.id/models"
+	"api.qobiltu.id/pkg/validation"
+	"api.qobiltu.id/repositories"
+	"api.qobiltu.id/response"
+	"gorm.io/gorm"
+)
+
+type QuizService interface {
+	// === ADMIN ===
+
+	// 	// === USER ===
+	UserGetQuiz(ctx context.Context, req *models.UserGetQuizRequest) (*models.UserGetQuizResponse, error)
+	UserAttemptQuiz(ctx context.Context, req *models.UserAttemptQuizRequest) (*models.UserAttemptQuizResponse, error)
+
+	// UserGetQuestionQuiz(ctx context.Context, req *models.GetQuestionQuizRequest) (*models.GetQuestionQuizResponse, error)
+	// UserAnswerQuiz(ctx context.Context, req *models.AnswerQuizRequest) (*models.AnswerQuizResponse, error)
+	// UserReviewQuiz(ctx context.Context, req *models.ReviewQuizRequest) (*models.ReviewQuizResponse, error)
+	// UserSubmitQuiz(ctx context.Context, req *models.SubmitQuizRequest) (*models.SubmitQuizResponse, error)
+	// UserResultQuiz(ctx context.Context, req *models.ResultQuizRequest) (*models.ResultQuizResponse, error)
+	// UserListResultQuiz(ctx context.Context, req *models.ListResultQuizRequest) (*models.ListResultQuizResponse, *models.Paging, error)
+}
+
+type quizService struct {
+	quizRepository    repositories.QuizRepository
+	academyRepository repositories.AcademyRepository
+	validator         *validation.Validator
+}
+
+func NewQuizService(quizRepository repositories.QuizRepository, academyRepository repositories.AcademyRepository, validator *validation.Validator) QuizService {
+	return &quizService{quizRepository: quizRepository, academyRepository: academyRepository, validator: validator}
+}
+
+func (s *quizService) UserGetQuiz(ctx context.Context, req *models.UserGetQuizRequest) (*models.UserGetQuizResponse, error) {
+	quiz, err := s.quizRepository.UserGetQuiz(ctx, req)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+
+	return quiz, nil
+}
+
+func (s *quizService) UserAttemptQuiz(ctx context.Context, req *models.UserAttemptQuizRequest) (*models.UserAttemptQuizResponse, error) {
+	quizAttempt, err := s.quizRepository.UserGetQuiz(ctx, &models.UserGetQuizRequest{
+		AccountID: req.AccountID,
+		AcademyID: req.AcademyID,
+	})
+	if err != nil {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+
+	quiz := &quizAttempt.Quiz
+
+	existingAttempt, err := s.quizRepository.UserGetActiveAttemptQuiz(ctx, req.AccountID, quiz.ID)
+	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+
+	if existingAttempt != nil {
+		return s.handleExistingAttempt(ctx, req, quiz, existingAttempt)
+	}
+
+	return s.handleNewAttempt(ctx, req, quiz)
+}
+
+func (s *quizService) handleExistingAttempt(ctx context.Context, req *models.UserAttemptQuizRequest, quiz *models.Quiz, attempt *models.QuizAttempt) (*models.UserAttemptQuizResponse, error) {
+	now := time.Now()
+
+	if attempt.DueAt.Before(now) {
+		if attempt.FinishedAt == nil {
+			attempt.FinishedAt = &now
+			attempt.Score = s.calculateQuizScore(ctx, attempt)
+
+			if err := s.quizRepository.UserUpdateAttemptQuiz(ctx, attempt); err != nil {
+				return nil, response.HandleGormError(err, "Internal Server Error")
+			}
+
+			totalAttempts, err := s.quizRepository.UserGetTotalAttemptsQuiz(ctx, req.AccountID, quiz.ID)
+			if err != nil {
+				return nil, response.HandleGormError(err, "Internal Server Error")
+			}
+
+			if totalAttempts >= quiz.AttemptLimit {
+				if err := s.academyRepository.UserResetAcademyProgressByID(ctx, req.AccountID, quiz.AcademyID); err != nil {
+					return nil, response.HandleGormError(err, "Internal Server Error")
+				}
+
+				// hapus juga semua attempt quiz by account id dan quiz id
+				if err := s.quizRepository.UserDeleteAttemptQuizByAccountIDAndQuizID(ctx, req.AccountID, quiz.ID); err != nil {
+					return nil, response.HandleGormError(err, "Internal Server Error")
+				}
+			}
+
+			return nil, models.Exception{QuizTimeExpired: true, Message: "Quiz time has expired"}
+		}
+
+		return nil, models.Exception{QuizAlreadyFinished: true, Message: "Quiz already finished"}
+	}
+
+	questions, err := s.quizRepository.UserGetAttemptQuizQuestionsResponse(ctx, req.AccountID, quiz.ID, attempt.ID)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+
+	questions = shuffleWithKey(questions, attempt.ID)
+
+	return &models.UserAttemptQuizResponse{
+		QuizAttempt: *attempt,
+		Questions:   questions,
+	}, nil
+}
+
+func (s *quizService) handleNewAttempt(ctx context.Context, req *models.UserAttemptQuizRequest, quiz *models.Quiz) (*models.UserAttemptQuizResponse, error) {
+	totalAttempts, err := s.quizRepository.UserGetTotalAttemptsQuiz(ctx, req.AccountID, quiz.ID)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+	if totalAttempts >= quiz.AttemptLimit {
+		return nil, models.Exception{QuizAttemptLimit: true, Message: "Attempt limit reached"}
+	}
+
+	percentage, err := s.academyRepository.UserGetPercentageProgressAcademyByID(ctx, req.AccountID, quiz.AcademyID)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+	if percentage < 100 {
+		return nil, models.Exception{AcademyNotFinished: true, Message: "Academy not finished"}
+	}
+
+	quizAttempt := models.QuizAttempt{
+		AccountID: req.AccountID,
+		QuizID:    quiz.ID,
+		StartedAt: time.Now(),
+		DueAt:     time.Now().Add(time.Duration(quiz.TimeLimit) * time.Minute),
+	}
+
+	if err := s.quizRepository.UserCreateAttemptQuiz(ctx, &quizAttempt); err != nil {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+
+	questions, err := s.quizRepository.UserGetAttemptQuizQuestionsResponse(ctx, req.AccountID, quiz.ID, quizAttempt.ID)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+
+	questions = shuffleWithKey(questions, quizAttempt.ID)
+
+	return &models.UserAttemptQuizResponse{
+		QuizAttempt: quizAttempt,
+		Questions:   questions,
+	}, nil
+}
+
+func (s *quizService) calculateQuizScore(ctx context.Context, attempt *models.QuizAttempt) float64 {
+	// ambil total question dari quiz
+	totalQuestion, err := s.quizRepository.UserGetTotalQuestionQuiz(ctx, attempt.QuizID)
+	if err != nil {
+		return 0
+	}
+
+	if totalQuestion == 0 {
+		return 0
+	}
+
+	// ambil semua user answer yang is_correct nya true
+	correctAnswer, err := s.quizRepository.UserGetTotalCorrectAnswerQuiz(ctx, attempt.ID)
+	if err != nil {
+		return 0
+	}
+
+	// hitung score nya
+	score := float64(correctAnswer) / float64(totalQuestion) * 100
+
+	return score
+}
+
+// shuffleWithKey mengacak slice dengan menggunakan integer key sebagai seed
+// untuk memastikan hasil acak yang konsisten untuk key yang sama
+func shuffleWithKey[T any](slice []T, key int64) []T {
+	// Buat salinan slice untuk menghindari modifikasi original
+	shuffled := make([]T, len(slice))
+	copy(shuffled, slice)
+
+	// Buat random source dengan seed dari key
+	r := rand.New(rand.NewSource(key))
+
+	// Lakukan shuffling
+	r.Shuffle(len(shuffled), func(i, j int) {
+		shuffled[i], shuffled[j] = shuffled[j], shuffled[i]
+	})
+
+	return shuffled
+}

space/space/space/space/space/space/space/space/space/controller/academy/academy_controller.go

@@ -349,15 +349,21 @@ func (c *academyController) UserGetAcademyMaterialBySlug(ctx *gin.Context) {
 }
 
 func (c *academyController) UserToggleAcademyMaterialProgress(ctx *gin.Context) {
-	slug := ctx.Param("materialSlug")
+	var req models.ToggleAcademyMaterialProgressRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	academySlug := ctx.Param("slug")
+	materialSlug := ctx.Param("materialSlug")
 
 	accountData := middleware.GetAccountData(ctx)
 	accountID := int64(accountData.UserID)
 
-	req := models.ToggleAcademyMaterialProgressRequest{
-		AccountID: accountID,
-		Slug:      slug,
-	}
+	req.AccountID = accountID
+	req.AcademySlug = academySlug
+	req.MaterialSlug = materialSlug
 
 	err := c.academyService.UserToggleAcademyMaterialProgress(ctx, &req)
 	if err != nil {

space/space/space/space/space/space/space/space/space/models/database_orm_model.go

@@ -80,6 +80,7 @@ type (
 		Slug        string    `gorm:"column:slug;uniqueIndex" json:"slug"`
 		Description string    `gorm:"column:description" json:"description"`
 		Order       uint      `gorm:"column:order" json:"order"`
+		Image       *string   `gorm:"column:image" json:"image"`
 		CreatedAt   time.Time `gorm:"column:created_at;autoCreateTime" json:"created_at"`
 		UpdatedAt   time.Time `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`
 	}
@@ -101,7 +102,8 @@ type (
 		Account           *Account         `gorm:"foreignKey:AccountID;constraint:OnDelete:CASCADE" json:"account,omitempty" counter:"skip"`
 		AcademyMaterialID int64            `gorm:"primaryKey;column:academy_material_id" json:"academy_material_id"`
 		AcademyMaterial   *AcademyMaterial `gorm:"foreignKey:AcademyMaterialID;constraint:OnDelete:CASCADE" json:"academy_material,omitempty"`
-		ReadAt            *time.Time       `gorm:"column:read_at" json:"read_at"`
+		CreatedAt         time.Time        `gorm:"column:created_at;autoCreateTime" json:"created_at"`
+		UpdatedAt         time.Time        `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`
 	}
 )
 

space/space/space/space/space/space/space/space/space/models/request_model.go

@@ -56,8 +56,26 @@ type (
 	}
 
 	UserAcademyMaterialResponse struct {
-		AcademyMaterial
-		IsRead bool `gorm:"is_read" json:"is_read"`
+		ID        int64      `gorm:"column:id" json:"id"`
+		AcademyID int64      `gorm:"column:academy_id" json:"academy_id"`
+		Title     string     `gorm:"column:title" json:"title"`
+		Slug      string     `gorm:"column:slug" json:"slug"`
+		Order     uint       `gorm:"column:order" json:"order"`
+		CreatedAt *time.Time `gorm:"column:read_created_at" json:"created_at"`
+		UpdatedAt *time.Time `gorm:"column:read_updated_at" json:"updated_at"`
+		IsRead    bool       `gorm:"is_read" json:"is_read"`
+	}
+
+	UserAcademyMaterialDetailResponse struct {
+		ID        int64      `gorm:"column:id" json:"id"`
+		AcademyID int64      `gorm:"column:academy_id" json:"academy_id"`
+		Title     string     `gorm:"column:title" json:"title"`
+		Slug      string     `gorm:"column:slug" json:"slug"`
+		Content   string     `gorm:"column:content" json:"content"`
+		Order     uint       `gorm:"column:order" json:"order"`
+		CreatedAt *time.Time `gorm:"column:read_created_at" json:"created_at"`
+		UpdatedAt *time.Time `gorm:"column:read_updated_at" json:"updated_at"`
+		IsRead    bool       `gorm:"is_read" json:"is_read"`
 	}
 
 	CreateAcademyMaterialRequest struct {
@@ -108,8 +126,10 @@ type (
 	}
 
 	ToggleAcademyMaterialProgressRequest struct {
-		AccountID int64  `json:"account_id"`
-		Slug      string `json:"slug"`
+		AccountID    int64  `json:"-"`
+		MaterialSlug string `json:"-"`
+		AcademySlug  string `json:"-"`
+		IsRead       bool   `json:"is_read"`
 	}
 )
 
@@ -131,6 +151,38 @@ func NewListAcademyContentRequest() ListAcademyContentRequest {
 	}
 }
 
+type (
+	ListQuizRequest struct {
+		AccountID int64 `json:"account_id"`
+		AcademyID int64 `json:"academy_id" validate:"required"`
+	}
+
+	ListQuizResponse struct {
+		Quiz []Quiz `json:"quiz"`
+	}
+
+	AttemptQuizRequest struct {
+		AccountID int64 `json:"account_id"`
+		QuizID    int64 `json:"quiz_id" validate:"required"`
+	}
+
+	AttemptQuizResponse struct {
+		QuizAttempt QuizAttempt `json:"quiz_attempt"`
+	}
+
+	GetQuestionQuizRequest struct {
+		AccountID int64 `json:"account_id"`
+		QuizID    int64 `json:"quiz_id" validate:"required"`
+	}
+
+	GetQuestionQuizResponse struct {
+		Question   Question `json:"question"`
+		Answer     []Answer `json:"answer_options"`
+		UserAnswer int      `json:"current_user_answer"`
+		IsDoubt    bool     `json:"is_doubt"`
+	}
+)
+
 type (
 	MultipleOptionsRequest struct {
 		OptionName  string   `json:"option_name" validate:"required"`

space/space/space/space/space/space/space/space/space/repositories/academy_repository.go

@@ -28,7 +28,7 @@ type AcademyRepository interface {
 	UserListAcademy(ctx context.Context, req *models.ListAcademyRequest) ([]models.UserAcademyResponse, *models.Paging, error)
 	UserListAcademyMaterial(ctx context.Context, req *models.ListAcademyMaterialRequest) ([]models.UserAcademyMaterialResponse, *models.Paging, error)
 	UserGetAcademyBySlug(ctx context.Context, slug string) (*models.AcademyResponse, error)
-	UserGetAcademyMaterialBySlug(ctx context.Context, slug string, accountID int64) (*models.UserAcademyMaterialResponse, error)
+	UserGetAcademyMaterialBySlug(ctx context.Context, slug string, accountID int64) (*models.UserAcademyMaterialDetailResponse, error)
 	UserSaveAcademyMaterialProgress(ctx context.Context, req *models.AcademyMaterialProgress) error
 	UserGetAcademyMaterialProgressByAccountID(ctx context.Context, accountID int64, materialID int64) (*models.AcademyMaterialProgress, error)
 	UserDeleteAcademyMaterialProgress(ctx context.Context, accountID int64, materialID int64) error
@@ -245,7 +245,7 @@ func (r *academyRepository) UserListAcademy(ctx context.Context, req *models.Lis
 		Model(&models.Academy{}).
 		Select(`academy.*,
             COUNT(DISTINCT am.id) AS total_material,
-            COUNT(DISTINCT CASE WHEN amp.read_at IS NOT NULL THEN amp.academy_material_id END) AS total_read_material`).
+            COUNT(DISTINCT CASE WHEN amp.created_at IS NOT NULL THEN amp.academy_material_id END) AS total_read_material`).
 		Joins("LEFT JOIN academy_materials am ON am.academy_id = academy.id").
 		Joins(`LEFT JOIN "academy_materials_progress" amp ON amp.academy_material_id = am.id AND amp.account_id = ?`, req.AccountID).
 		Group("academy.id")
@@ -294,14 +294,16 @@ func (r *academyRepository) UserListAcademyMaterial(ctx context.Context, req *mo
 	q := r.db.WithContext(ctx).
 		Model(&models.AcademyMaterial{}).
 		Select(`academy_materials.*,
-			CASE
-				WHEN amp.read_at IS NOT NULL THEN true
-				ELSE false
-			END AS is_read`).
+		amp.created_at AS read_created_at,
+		amp.updated_at AS read_updated_at,
+		CASE
+			WHEN amp.created_at IS NOT NULL THEN true
+			ELSE false
+		END AS is_read`).
 		Joins("JOIN academy ON academy.id = academy_materials.academy_id").
 		Joins(`LEFT JOIN academy_materials_progress amp ON
-			amp.academy_material_id = academy_materials.id AND
-			amp.account_id = ?`, req.AccountID).
+		amp.academy_material_id = academy_materials.id AND
+		amp.account_id = ?`, req.AccountID).
 		Where("academy.slug = ?", req.Slug)
 
 	if req.Filter.HasKeyword() {
@@ -359,8 +361,8 @@ func (r *academyRepository) UserGetAcademyBySlug(ctx context.Context, slug strin
 	return &academy, nil
 }
 
-func (r *academyRepository) UserGetAcademyMaterialBySlug(ctx context.Context, slug string, accountID int64) (*models.UserAcademyMaterialResponse, error) {
-	var result models.UserAcademyMaterialResponse
+func (r *academyRepository) UserGetAcademyMaterialBySlug(ctx context.Context, slug string, accountID int64) (*models.UserAcademyMaterialDetailResponse, error) {
+	var result models.UserAcademyMaterialDetailResponse
 
 	err := r.db.WithContext(ctx).
 		Model(&models.AcademyMaterial{}).
@@ -369,22 +371,28 @@ func (r *academyRepository) UserGetAcademyMaterialBySlug(ctx context.Context, sl
 			academy.title as academy_title,
 			academy.slug as academy_slug,
 			CASE
-				WHEN amp.read_at IS NOT NULL THEN true
+				WHEN amp.created_at IS NOT NULL THEN true
 				ELSE false
-			END AS is_read
+			END AS is_read,
+			amp.created_at AS read_created_at,
+			amp.updated_at AS read_updated_at
 		`).
 		Joins("JOIN academy ON academy.id = academy_materials.academy_id").
 		Joins(`LEFT JOIN academy_materials_progress amp ON
 			amp.academy_material_id = academy_materials.id AND
 			amp.account_id = ?`, accountID).
 		Where("academy_materials.slug = ?", slug).
-		First(&result).
+		Scan(&result).
 		Error
 
 	if err != nil {
 		return nil, err
 	}
 
+	if result.ID == 0 {
+		return nil, gorm.ErrRecordNotFound
+	}
+
 	return &result, nil
 }
 

space/space/space/space/space/space/space/space/space/repositories/quiz_repository.go

@@ -1,9 +1,28 @@
 package repositories
 
 import (
+	"context"
+
 	"api.qobiltu.id/models"
+	"gorm.io/gorm"
 )
 
+type QuizRepository interface {
+	UserListQuiz(ctx context.Context, req *models.ListQuizRequest) (*models.ListQuizResponse, *models.Paging, error)
+}
+
+type quizRepository struct {
+	db *gorm.DB
+}
+
+func NewQuizRepository(db *gorm.DB) QuizRepository {
+	return &quizRepository{db: db}
+}
+
+func (r *quizRepository) UserListQuiz(ctx context.Context, req *models.ListQuizRequest) (*models.ListQuizResponse, *models.Paging, error) {
+	panic("not implemented")
+}
+
 func GetQuizbyAcademyId(academyId uint) Repository[models.Quiz, []models.Quiz] {
 	repo := Construct[models.Quiz, []models.Quiz](
 		models.Quiz{AcademyID: academyId},

space/space/space/space/space/space/space/space/space/router/quiz_route.go

@@ -15,7 +15,7 @@ func QuizRoute(router *gin.Engine) {
 		routerGroup.GET("/:academy_id/:quiz_id/review", middleware.AuthUser, QuizController.Review)
 		routerGroup.PUT("/:academy_id/:quiz_id/choose-answer", middleware.AuthUser, QuizController.Answer)
 		routerGroup.GET("result/:attempt_id", middleware.AuthUser, QuizController.Result)
-		routerGroup.GET("result/", middleware.AuthUser, QuizController.Result)
+		routerGroup.GET("result", middleware.AuthUser, QuizController.Result)
 		routerGroup.POST("/submit-attempt/:attempt_id", middleware.AuthUser, QuizController.Submit)
 		routerGroup.GET("/navigation/:attempt_id", middleware.AuthUser, QuizController.Navigation)
 	}