Deploy files from GitHub repository

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)

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"`

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)
 	}
 }

services/quiz_service.go

@@ -22,6 +22,7 @@ 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)
 }
 
@@ -304,6 +305,22 @@ func (s *quizService) UserSubmitQuiz(ctx context.Context, req *models.SubmitQuiz
 	}, nil
 }
 
+func (s *quizService) UserResultQuiz(ctx context.Context, req *models.ResultQuizRequest) (*models.ResultQuizResponse, error) {
+	attempt, err := s.quizRepository.UseGetLastAttemptQuiz(ctx, 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)
+	if err != nil {
+		return nil, response.HandleGormError(err, "Internal Server Error")
+	}
+
+	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)
 	if err != nil {

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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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/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)
 	}

space/space/space/space/space/space/space/services/academy_service.go

@@ -33,7 +33,7 @@ type AcademyService 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)
 	UserToggleAcademyMaterialProgress(ctx context.Context, req *models.ToggleAcademyMaterialProgressRequest) error
 }
 
@@ -277,7 +277,7 @@ func (s *academyService) UserGetAcademyBySlug(ctx context.Context, slug string)
 	return academy, nil
 }
 
-func (s *academyService) UserGetAcademyMaterialBySlug(ctx context.Context, slug string, accountID int64) (*models.UserAcademyMaterialResponse, error) {
+func (s *academyService) UserGetAcademyMaterialBySlug(ctx context.Context, slug string, accountID int64) (*models.UserAcademyMaterialDetailResponse, error) {
 	academyMaterial, err := s.academyRepository.UserGetAcademyMaterialBySlug(ctx, slug, accountID)
 	if err != nil {
 		return nil, response.HandleGormError(err, "Internal Server Error")
@@ -287,29 +287,29 @@ func (s *academyService) UserGetAcademyMaterialBySlug(ctx context.Context, slug
 }
 
 func (s *academyService) UserToggleAcademyMaterialProgress(ctx context.Context, req *models.ToggleAcademyMaterialProgressRequest) error {
-
-	academyMaterial, err := s.academyRepository.UserGetAcademyMaterialBySlug(ctx, req.Slug, req.AccountID)
+	material, err := s.academyRepository.UserGetAcademyMaterialBySlug(ctx, req.MaterialSlug, req.AccountID)
 	if err != nil {
 		return response.HandleGormError(err, "Internal Server Error")
 	}
 
-	if academyMaterial.IsRead {
-		err = s.academyRepository.UserDeleteAcademyMaterialProgress(ctx, req.AccountID, academyMaterial.ID)
+	// langsung hapus progress jika isRead adalah false
+	if !req.IsRead {
+		err := s.academyRepository.UserDeleteAcademyMaterialProgress(ctx, req.AccountID, material.ID)
 		if err != nil {
 			return response.HandleGormError(err, "Internal Server Error")
 		}
-	} else {
-		now := time.Now()
-		academyMaterialProgress := &models.AcademyMaterialProgress{
-			AccountID:         req.AccountID,
-			AcademyMaterialID: academyMaterial.ID,
-			ReadAt:            &now,
-		}
+		return nil
+	}
 
-		err = s.academyRepository.UserSaveAcademyMaterialProgress(ctx, academyMaterialProgress)
-		if err != nil {
-			return response.HandleGormError(err, "Internal Server Error")
-		}
+	academyMaterialProgress := models.AcademyMaterialProgress{
+		AccountID:         req.AccountID,
+		AcademyMaterialID: material.ID,
+		CreatedAt:         time.Now(),
+	}
+
+	err = s.academyRepository.UserSaveAcademyMaterialProgress(ctx, &academyMaterialProgress)
+	if err != nil {
+		return response.HandleGormError(err, "Internal Server Error")
 	}
 
 	return nil

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

@@ -0,0 +1,37 @@
+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")
+// }

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

@@ -1,7 +1,6 @@
 package models
 
 import (
-	"fmt"
 	"reflect"
 	"time"
 )
@@ -23,7 +22,6 @@ func shouldSkipField(field reflect.StructField) bool {
 	}
 
 	counterTag := field.Tag.Get("counter")
-	fmt.Println(field.Name, "=", counterTag)
 	return counterTag == "skip"
 }
 

space/space/space/space/space/space/space/space/services/partner_criteria_service.go

@@ -59,9 +59,9 @@ func (s *partnerCriteriaService) SavePartnerCriteria(ctx context.Context, req *m
 	utils.AssignIfNotNil(&partnerCriteria.ExpectedMaxHeightLimit, req.ExpectedMaxHeightLimit)
 
 	utils.AssignIfNotNil(&partnerCriteria.ExpectedPartnerIncome, req.ExpectedPartnerIncome)
-	utils.AssignIfNotNil(&partnerCriteria.ExpectedIncomeSources, req.ExpectedIncomeSources)
 	utils.AssignIfNotNil(&partnerCriteria.ExpectedLastEducation, req.ExpectedLastEducation)
-	utils.AssignIfNotNil(&partnerCriteria.ExpectedJobType, req.ExpectedJobType)
+	// utils.AssignIfNotNil(&partnerCriteria.ExpectedIncomeSources, req.ExpectedIncomeSources)
+	// utils.AssignIfNotNil(&partnerCriteria.ExpectedJobType, req.ExpectedJobType)
 
 	res, err := s.partnerCriteriaRepository.SavePartnerCriteria(ctx, partnerCriteria)
 	if err != nil {

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

@@ -57,9 +57,7 @@ func AutoMigrateAll(db *gorm.DB) {
 		&models.ForgotPassword{},
 		&models.Academy{},
 		&models.AcademyMaterial{},
-		&models.AcademyContent{},
 		&models.AcademyMaterialProgress{},
-		&models.AcademyContentProgress{},
 		&models.RegionCity{},
 		&models.RegionProvince{},
 		&models.OptionCategory{},

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

@@ -1,31 +1,369 @@
-package academy
-
-import (
-	"api.qobiltu.id/controller"
-	"api.qobiltu.id/models"
-	"api.qobiltu.id/services"
-	"github.com/gin-gonic/gin"
-)
-
-func List(c *gin.Context) {
-	academy := services.AcademyService{}
-	academyController := controller.Controller[any, models.Academy, []models.Academy]{
-		Service: &academy.Service,
-	}
-	academyController.Service.Constructor.Slug = c.Param("slug")
-	academy.Retrieve()
-	academyController.Response(c)
-
-}
-
-func Create(c *gin.Context) {
-	createAcademy := services.CreateAcademyService{}
-	academyController := controller.Controller[models.AllAcademyResponse, models.AllAcademyResponse, models.AllAcademyResponse]{
-		Service: &createAcademy.Service,
-	}
-	academyController.RequestJSON(c, func() {
-		academyController.Service.Constructor.Academies = academyController.Request.Academies
-		createAcademy.Create()
-	})
-
-}
+package academy_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 AcademyController interface {
+	// === ADMIN ===
+	AdminCreateAcademy(ctx *gin.Context)
+	AdminGetAcademy(ctx *gin.Context)
+	AdminUpdateAcademy(ctx *gin.Context)
+	AdminDeleteAcademy(ctx *gin.Context)
+	AdminListAcademy(ctx *gin.Context)
+	AdminReorderAcademy(ctx *gin.Context)
+
+	AdminCreateAcademyMaterial(ctx *gin.Context)
+	AdminGetAcademyMaterial(ctx *gin.Context)
+	AdminUpdateAcademyMaterial(ctx *gin.Context)
+	AdminDeleteAcademyMaterial(ctx *gin.Context)
+	AdminListAcademyMaterial(ctx *gin.Context)
+	AdminReorderAcademyMaterial(ctx *gin.Context)
+
+	// === USER ===
+	UserListAcademy(ctx *gin.Context)
+	UserListAcademyMaterial(ctx *gin.Context)
+	UserGetAcademyMaterialBySlug(ctx *gin.Context)
+	UserToggleAcademyMaterialProgress(ctx *gin.Context)
+}
+
+type academyController struct {
+	academyService services.AcademyService
+}
+
+func NewAcademyController(academyService services.AcademyService) AcademyController {
+	return &academyController{
+		academyService: academyService,
+	}
+}
+
+func (c *academyController) AdminListAcademy(ctx *gin.Context) {
+	req := models.NewListAcademyRequest()
+	if err := ctx.ShouldBindQuery(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	res, paging, err := c.academyService.AdminListAcademy(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Academy list retrieved successfully", res, paging)
+}
+
+func (c *academyController) AdminCreateAcademy(ctx *gin.Context) {
+	var req models.CreateAcademyRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	accountData := middleware.GetAccountData(ctx)
+	req.AccountID = int64(accountData.UserID)
+
+	res, err := c.academyService.AdminCreateAcademy(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Academy created successfully", res, nil)
+}
+
+func (c *academyController) AdminGetAcademy(ctx *gin.Context) {
+	id := ctx.Param("id")
+	idInt, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	res, err := c.academyService.AdminGetAcademyByID(ctx, idInt)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Academy retrieved successfully", res, nil)
+}
+
+func (c *academyController) AdminUpdateAcademy(ctx *gin.Context) {
+	id := ctx.Param("id")
+	idInt, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	var req models.UpdateAcademyRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	req.ID = idInt
+
+	res, err := c.academyService.AdminUpdateAcademy(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Academy updated successfully", res, nil)
+}
+
+func (c *academyController) AdminDeleteAcademy(ctx *gin.Context) {
+	id := ctx.Param("id")
+	idInt, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	err = c.academyService.AdminDeleteAcademy(ctx, idInt)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Academy deleted successfully", nil, nil)
+}
+
+func (c *academyController) AdminReorderAcademy(ctx *gin.Context) {
+	var req models.ReorderAcademyRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	err := c.academyService.AdminReorderAcademy(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Academy reordered successfully", nil, nil)
+}
+
+func (c *academyController) AdminCreateAcademyMaterial(ctx *gin.Context) {
+	var req models.CreateAcademyMaterialRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	academyID := ctx.Param("id")
+	academyIDInt, err := strconv.ParseInt(academyID, 10, 64)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	req.AcademyID = academyIDInt
+
+	res, err := c.academyService.AdminCreateAcademyMaterial(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Academy material created successfully", res, nil)
+}
+
+func (c *academyController) AdminGetAcademyMaterial(ctx *gin.Context) {
+	id := ctx.Param("materialId")
+	idInt, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	res, err := c.academyService.AdminGetAcademyMaterialByID(ctx, idInt)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Academy material retrieved successfully", res, nil)
+}
+
+func (c *academyController) AdminUpdateAcademyMaterial(ctx *gin.Context) {
+	id := ctx.Param("materialId")
+	idInt, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	var req models.UpdateAcademyMaterialRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	req.ID = idInt
+
+	res, err := c.academyService.AdminUpdateAcademyMaterial(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Academy material updated successfully", res, nil)
+}
+
+func (c *academyController) AdminDeleteAcademyMaterial(ctx *gin.Context) {
+	id := ctx.Param("materialId")
+	idInt, err := strconv.ParseInt(id, 10, 64)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	err = c.academyService.AdminDeleteAcademyMaterial(ctx, idInt)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Academy material deleted successfully", nil, nil)
+}
+
+func (c *academyController) AdminReorderAcademyMaterial(ctx *gin.Context) {
+	req := models.ReorderAcademyMaterialRequest{}
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	academyID := ctx.Param("id")
+	academyIDInt, err := strconv.ParseInt(academyID, 10, 64)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	req.AcademyID = academyIDInt
+
+	err = c.academyService.AdminReorderAcademyMaterial(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Academy material reordered successfully", nil, nil)
+}
+
+func (c *academyController) AdminListAcademyMaterial(ctx *gin.Context) {
+	req := models.NewListAcademyMaterialRequest()
+	if err := ctx.ShouldBindQuery(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	academyID := ctx.Param("id")
+	academyIDInt, err := strconv.ParseInt(academyID, 10, 64)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	accountData := middleware.GetAccountData(ctx)
+	req.AccountID = int64(accountData.UserID)
+	req.AcademyID = academyIDInt
+
+	res, paging, err := c.academyService.AdminListAcademyMaterial(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Academy material list retrieved successfully", res, paging)
+}
+
+// === USER ===
+
+func (c *academyController) UserListAcademy(ctx *gin.Context) {
+	req := models.NewListAcademyRequest()
+	if err := ctx.ShouldBindQuery(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	accountData := middleware.GetAccountData(ctx)
+	req.AccountID = int64(accountData.UserID)
+
+	res, paging, err := c.academyService.UserListAcademy(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Academy list retrieved successfully", res, paging)
+}
+
+func (c *academyController) UserListAcademyMaterial(ctx *gin.Context) {
+	req := models.NewListAcademyMaterialRequest()
+	if err := ctx.ShouldBindQuery(&req); err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	accountData := middleware.GetAccountData(ctx)
+	req.AccountID = int64(accountData.UserID)
+
+	slug := ctx.Param("slug")
+	req.Slug = slug
+
+	res, paging, err := c.academyService.UserListAcademyMaterial(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Academy material list retrieved successfully", res, paging)
+}
+
+func (c *academyController) UserGetAcademyMaterialBySlug(ctx *gin.Context) {
+	slug := ctx.Param("materialSlug")
+
+	accountData := middleware.GetAccountData(ctx)
+	accountID := int64(accountData.UserID)
+
+	res, err := c.academyService.UserGetAcademyMaterialBySlug(ctx, slug, accountID)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Academy material retrieved successfully", res, nil)
+}
+
+func (c *academyController) UserToggleAcademyMaterialProgress(ctx *gin.Context) {
+	slug := ctx.Param("materialSlug")
+
+	accountData := middleware.GetAccountData(ctx)
+	accountID := int64(accountData.UserID)
+
+	req := models.ToggleAcademyMaterialProgressRequest{
+		AccountID: accountID,
+		Slug:      slug,
+	}
+
+	err := c.academyService.UserToggleAcademyMaterialProgress(ctx, &req)
+	if err != nil {
+		response.HandleError(ctx, err)
+		return
+	}
+
+	response.HandleSuccess(ctx, http.StatusOK, "Academy material progress toggled successfully", nil, nil)
+}

space/space/space/space/space/space/space/space/space/controller/cv/cv_controller.go

@@ -66,11 +66,7 @@ func NewCVController(cvService services.CVService) CVController {
 func (c *cvController) SaveAccountDetails(ctx *gin.Context) {
 	var req models.SaveAccountDetailsRequest
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		response.HandleError(ctx, models.Exception{
-			Message:    "Invalid body request",
-			BadRequest: true,
-			Err:        err,
-		})
+		response.HandleError(ctx, err)
 		return
 	}
 
@@ -108,11 +104,7 @@ func (c *cvController) GetAccountDetails(ctx *gin.Context) {
 func (c *cvController) SavePersonalityAndPreference(ctx *gin.Context) {
 	var req models.SavePersonalityAndPreferenceRequest
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		response.HandleError(ctx, models.Exception{
-			Message:    "Invalid body request",
-			BadRequest: true,
-			Err:        err,
-		})
+		response.HandleError(ctx, err)
 		return
 	}
 
@@ -150,11 +142,7 @@ func (c *cvController) GetPersonalityAndPreference(ctx *gin.Context) {
 func (c *cvController) CreateFamilyMember(ctx *gin.Context) {
 	var req models.CreateFamilyMemberRequest
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		response.HandleError(ctx, models.Exception{
-			Message:    "Invalid body request",
-			BadRequest: true,
-			Err:        err,
-		})
+		response.HandleError(ctx, err)
 		return
 	}
 
@@ -180,11 +168,7 @@ func (c *cvController) UpdateFamilyMember(ctx *gin.Context) {
 
 	var req models.UpdateFamilyMemberRequest
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		response.HandleError(ctx, models.Exception{
-			Message:    "Invalid body request",
-			BadRequest: true,
-			Err:        err,
-		})
+		response.HandleError(ctx, err)
 		return
 	}
 
@@ -263,11 +247,7 @@ func (c *cvController) DeleteFamilyMember(ctx *gin.Context) {
 func (c *cvController) SavePhysicalAndHealth(ctx *gin.Context) {
 	var req models.SavePhysicalAndHealthRequest
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		response.HandleError(ctx, models.Exception{
-			Message:    "Invalid body request",
-			BadRequest: true,
-			Err:        err,
-		})
+		response.HandleError(ctx, err)
 		return
 	}
 
@@ -305,11 +285,7 @@ func (c *cvController) GetPhysicalAndHealth(ctx *gin.Context) {
 func (c *cvController) SaveWorshipAndReligiousUnderstanding(ctx *gin.Context) {
 	var req models.SaveWorshipAndReligiousUnderstandingRequest
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		response.HandleError(ctx, models.Exception{
-			Message:    "Invalid body request",
-			BadRequest: true,
-			Err:        err,
-		})
+		response.HandleError(ctx, err)
 		return
 	}
 
@@ -346,11 +322,7 @@ func (c *cvController) GetWorshipAndReligiousUnderstanding(ctx *gin.Context) {
 func (c *cvController) CreateEducation(ctx *gin.Context) {
 	var req models.CreateEducationRequest
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		response.HandleError(ctx, models.Exception{
-			Message:    "Invalid body request",
-			BadRequest: true,
-			Err:        err,
-		})
+		response.HandleError(ctx, err)
 		return
 	}
 
@@ -376,11 +348,7 @@ func (c *cvController) UpdateEducation(ctx *gin.Context) {
 
 	var req models.UpdateEducationRequest
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		response.HandleError(ctx, models.Exception{
-			Message:    "Invalid body request",
-			BadRequest: true,
-			Err:        err,
-		})
+		response.HandleError(ctx, err)
 		return
 	}
 
@@ -458,11 +426,7 @@ func (c *cvController) DeleteEducation(ctx *gin.Context) {
 func (c *cvController) CreateJob(ctx *gin.Context) {
 	var req models.CreateJobRequest
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		response.HandleError(ctx, models.Exception{
-			Message:    "Invalid body request",
-			BadRequest: true,
-			Err:        err,
-		})
+		response.HandleError(ctx, err)
 		return
 	}
 
@@ -488,11 +452,7 @@ func (c *cvController) UpdateJob(ctx *gin.Context) {
 
 	var req models.UpdateJobRequest
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		response.HandleError(ctx, models.Exception{
-			Message:    "Invalid body request",
-			BadRequest: true,
-			Err:        err,
-		})
+		response.HandleError(ctx, err)
 		return
 	}
 
@@ -570,11 +530,7 @@ func (c *cvController) DeleteJob(ctx *gin.Context) {
 func (c *cvController) CreateAchievement(ctx *gin.Context) {
 	var req models.CreateAchievementRequest
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		response.HandleError(ctx, models.Exception{
-			Message:    "Invalid body request",
-			BadRequest: true,
-			Err:        err,
-		})
+		response.HandleError(ctx, err)
 		return
 	}
 
@@ -600,11 +556,7 @@ func (c *cvController) UpdateAchievement(ctx *gin.Context) {
 
 	var req models.UpdateAchievementRequest
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		response.HandleError(ctx, models.Exception{
-			Message:    "Invalid body request",
-			BadRequest: true,
-			Err:        err,
-		})
+		response.HandleError(ctx, err)
 		return
 	}
 

space/space/space/space/space/space/space/space/space/controller/email/email_controller.go

@@ -43,11 +43,7 @@ func (c *emailController) CreateEmailVerification(ctx *gin.Context) {
 func (c *emailController) Verify(ctx *gin.Context) {
 	var req models.ValidateEmailVerificationRequest
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		response.HandleError(ctx, models.Exception{
-			Message:    "Invalid body request",
-			BadRequest: true,
-			Err:        err,
-		})
+		response.HandleError(ctx, err)
 		return
 	}
 

space/space/space/space/space/space/space/space/space/controller/marriage_readiness_profile/marriage_readiness_profile_controller.go

@@ -1,4 +1,4 @@
-package cv_controller
+package marriage_readiness_profile_controller
 
 import (
 	"net/http"
@@ -28,11 +28,7 @@ func NewMarriageReadinessProfileController(marriageReadinessProfileService servi
 func (c *marriageReadinessProfileController) SaveMarriageReadinessProfile(ctx *gin.Context) {
 	var req models.SaveMarriageReadinessProfileRequest
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		response.HandleError(ctx, models.Exception{
-			Message:    "Invalid body request",
-			BadRequest: true,
-			Err:        err,
-		})
+		response.HandleError(ctx, err)
 		return
 	}
 

space/space/space/space/space/space/space/space/space/controller/options/options_controller.go

@@ -28,11 +28,7 @@ func NewOptionsController(optionService services.OptionsService) OptionsControll
 func (c *optionsController) CreateOptions(ctx *gin.Context) {
 	var req []models.MultipleOptionsRequest
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		response.HandleError(ctx, models.Exception{
-			Message:    "Invalid body request",
-			BadRequest: true,
-			Err:        err,
-		})
+		response.HandleError(ctx, err)
 		return
 	}
 

space/space/space/space/space/space/space/space/space/controller/partner_criteria/partner_criteria_controller.go

@@ -28,11 +28,7 @@ func NewPartnerCriteriaController(partnerCriteriaService services.PartnerCriteri
 func (c *partnerCriteriaController) SavePartnerCriteria(ctx *gin.Context) {
 	var req models.SavePartnerCriteriaRequest
 	if err := ctx.ShouldBindJSON(&req); err != nil {
-		response.HandleError(ctx, models.Exception{
-			Message:    "Invalid body request",
-			BadRequest: true,
-			Err:        err,
-		})
+		response.HandleError(ctx, err)
 		return
 	}
 

space/space/space/space/space/space/space/space/space/controller/quiz/list_quiz_controller.go

@@ -16,7 +16,7 @@ func List(c *gin.Context) {
 	}
 	quizListController.HeaderParse(c, func() {
 		academy_id, _ := strconv.Atoi(c.Param("academy_id"))
-		quizList.Constructor.ID = uint(academy_id)
+		quizList.Constructor.ID = int64(academy_id)
 		quizList.Retrieve()
 		quizListController.Response(c)
 	})

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

@@ -6,6 +6,7 @@ import (
 	"strconv"
 
 	"api.qobiltu.id/config"
+	academy_controller "api.qobiltu.id/controller/academy"
 	cv_controller "api.qobiltu.id/controller/cv"
 	email_controller "api.qobiltu.id/controller/email"
 	marriage_readiness_profile_controller "api.qobiltu.id/controller/marriage_readiness_profile"
@@ -70,6 +71,10 @@ func main() {
 	emailService := services.NewEmailService(emailRepository, taskDistributor)
 	emailController := email_controller.NewEmailController(emailService)
 
+	academyRepository := repositories.NewAcademyRepository(config.DB)
+	academyService := services.NewAcademyService(academyRepository, validator)
+	academyController := academy_controller.NewAcademyController(academyService)
+
 	cvRepository := repositories.NewCVRepository(config.DB)
 	cvService := services.NewCVService(cvRepository, localStorage, validator)
 	cvController := cv_controller.NewCVController(cvService)
@@ -92,6 +97,7 @@ func main() {
 		regionController,
 		optionController,
 		emailController,
+		academyController,
 		cvController,
 		marriageReadinessProfileController,
 		partnerCriteriaController,

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

@@ -30,7 +30,7 @@ type AccountDetails struct {
 	Gender        *string    `gorm:"column:gender" json:"gender"`
 	LastEducation *string    `gorm:"column:last_education" json:"last_education"`
 	MaritalStatus *string    `gorm:"column:marital_status" json:"marital_status"`
-	Avatar        *string    `gorm:"column:avatar" json:"avatar"`
+	Avatar        *string    `gorm:"column:avatar" json:"avatar" counter:"skip"`
 	PhoneNumber   *string    `gorm:"column:phone_number" json:"phone_number"`
 	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"`
@@ -73,38 +73,37 @@ type ForgotPassword struct {
 	ExpiredAt time.Time `json:"expired_at"`
 }
 
-type Academy struct {
-	ID                uint      `gorm:"primaryKey" json:"id"`
-	UUID              uuid.UUID `gorm:"type:uuid" json:"uuid"`
-	Title             string    `json:"title"`
-	Slug              string    `json:"slug" gorm:"uniqueIndex" `
-	TotalMaterial     int       `json:"total_material"`
-	CompletedMaterial int       `json:"completed_material"`
-	TotalQuiz         int       `json:"total_quiz"`
-	PassedQuiz        int       `json:"passed_quiz"`
-	IsCompletedRead   bool      `json:"is_read"`
-	IsPassedExam      bool      `json:"is_passed_exam"`
-	Description       string    `json:"description"`
-}
+type (
+	Academy struct {
+		ID          int64     `gorm:"column:id;primaryKey;autoIncrement" json:"id"`
+		Title       string    `gorm:"column:title" json:"title"`
+		Slug        string    `gorm:"column:slug;uniqueIndex" json:"slug"`
+		Description string    `gorm:"column:description" json:"description"`
+		Order       uint      `gorm:"column:order" json:"order"`
+		CreatedAt   time.Time `gorm:"column:created_at;autoCreateTime" json:"created_at"`
+		UpdatedAt   time.Time `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`
+	}
 
-type AcademyMaterial struct {
-	ID          uint      `gorm:"primaryKey" json:"id"`
-	UUID        uuid.UUID `gorm:"type:uuid" json:"uuid"`
-	AcademyID   uint      `json:"academy_id"`
-	Title       string    `json:"title"`
-	Slug        string    `json:"slug" gorm:"uniqueIndex"`
-	IsCompleted bool      `json:"is_completed"`
-	Description string    `json:"description"`
-}
+	AcademyMaterial 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"`
+		Title     string    `gorm:"column:title" json:"title"`
+		Slug      string    `gorm:"column:slug;uniqueIndex" json:"slug"`
+		Content   string    `gorm:"column:content" json:"content"`
+		Order     uint      `gorm:"column:order" json:"order"`
+		CreatedAt time.Time `gorm:"column:created_at;autoCreateTime" json:"created_at"`
+		UpdatedAt time.Time `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`
+	}
 
-type AcademyContent struct {
-	ID                uint      `gorm:"primaryKey" json:"id"`
-	UUID              uuid.UUID `json:"uuid"`
-	Title             string    `json:"title"`
-	Order             uint      `json:"order"`
-	AcademyMaterialID uint      `json:"academy_material_id"`
-	Description       string    `json:"description"`
-}
+	AcademyMaterialProgress struct {
+		AccountID         int64            `gorm:"primaryKey;column:account_id" json:"account_id" counter:"skip"`
+		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"`
+	}
+)
 
 type OptionCategory struct {
 	ID           int64          `gorm:"column:id;primaryKey;autoIncrement" json:"id"`
@@ -119,21 +118,6 @@ type OptionValues struct {
 	OptionValue      string `json:"option_value"`
 }
 
-type AcademyMaterialProgress struct {
-	ID                uint      `gorm:"primaryKey" json:"id"`
-	UUID              uuid.UUID `gorm:"type:uuid" json:"uuid"`
-	AccountID         uint      `json:"account_id"`
-	AcademyMaterialID uint      `json:"academy_material_id"`
-	Progress          uint      `json:"progress"`
-}
-
-type AcademyContentProgress struct {
-	ID        uint      `gorm:"primaryKey" json:"id"`
-	UUID      uuid.UUID `gorm:"type:uuid" json:"uuid"`
-	AccountID uint      `json:"account_id"`
-	AcademyID uint      `json:"academy_id"`
-}
-
 type RegionProvince struct {
 	ID   uint   `json:"id"`
 	Name string `json:"name"`
@@ -424,9 +408,9 @@ type (
 
 		// Pendidikan & Pekerjaan
 		ExpectedPartnerIncome *string         `gorm:"column:expected_partner_income" json:"expected_partner_income"`                     // penghasilan pasangan per bulan yang diharapkan
-		ExpectedIncomeSources *pq.StringArray `gorm:"column:expected_income_sources;type:varchar(255)[]" json:"expected_income_sources"` // sumber penghasilan pasangan
 		ExpectedLastEducation *pq.StringArray `gorm:"column:expected_last_education;type:varchar(255)[]" json:"expected_last_education"` // pendidikan terakhir yang diharapkan
-		ExpectedJobType       *string         `gorm:"column:expected_job_type" json:"expected_job_type"`                                 // jenis pekerjaan pasangan yang diharapkan
+		// ExpectedIncomeSources *pq.StringArray `gorm:"column:expected_income_sources;type:varchar(255)[]" json:"expected_income_sources"` // sumber penghasilan pasangan
+		// ExpectedJobType       *string         `gorm:"column:expected_job_type" json:"expected_job_type"`                                 // jenis pekerjaan pasangan yang diharapkan
 
 		CreatedAt time.Time `gorm:"column:created_at;autoCreateTime" json:"created_at"`
 		UpdatedAt time.Time `gorm:"column:updated_at;autoUpdateTime" json:"updated_at"`
@@ -442,9 +426,7 @@ func (FCM) TableName() string                        { return "fcm" }
 func (ForgotPassword) TableName() string             { return "forgot_password" }
 func (Academy) TableName() string                    { return "academy" }
 func (AcademyMaterial) TableName() string            { return "academy_materials" }
-func (AcademyContent) TableName() string             { return "academy_contents" }
 func (AcademyMaterialProgress) TableName() string    { return "academy_materials_progress" }
-func (AcademyContentProgress) TableName() string     { return "academy_contents_progress" }
 func (RegionProvince) TableName() string             { return "region_provinces" }
 func (RegionCity) TableName() string                 { return "region_cities" }
 func (Answer) TableName() string                     { return "answers" }