Deploy files from GitHub repository

controller/quiz/answer_quiz_controller.go

@@ -17,9 +17,9 @@ func Answer(c *gin.Context) {
 	quizAnswerController.RequestJSON(c, func() {
 		quizId, _ := strconv.Atoi(c.Param("quiz_id"))
 		academyId, _ := strconv.Atoi(c.Param("academy_id"))
-		questionNo, _ := strconv.Atoi(c.Query("question_no"))
+
 		quizAnswerController.Service.Constructor.ID = uint(quizId)
 		quizAnswerController.Service.Constructor.AcademyID = uint(academyId)
-		quizAnswer.Update(quizAnswerController.AccountData.UserID, questionNo, quizAnswerController.Request.Answer)
+		quizAnswer.Update(quizAnswerController.AccountData.UserID, quizAnswerController.Request.QuestionNo, quizAnswerController.Request.Answer)
 	})
 }

controller/quiz/question_quiz_controller.go

@@ -11,15 +11,17 @@ import (
 
 func Question(c *gin.Context) {
 	questionQuiz := services.QuestionQuizService{}
-	questionQuizController := controller.Controller[models.QuestionQuizRequest, models.Quiz, models.QuestionResponse]{
+	questionQuizController := controller.Controller[any, models.Quiz, models.QuestionResponse]{
 		Service: &questionQuiz.Service,
 	}
-	questionQuizController.RequestJSON(c, func() {
+	questionQuizController.HeaderParse(c, func() {
 		quizId, _ := strconv.Atoi(c.Param("quiz_id"))
 		academyId, _ := strconv.Atoi(c.Param("academy_id"))
+		questionNo, _ := strconv.Atoi(c.Query("question_no"))
 		questionQuizController.Service.Constructor.ID = uint(quizId)
 		questionQuizController.Service.Constructor.AcademyID = uint(academyId)
-		questionQuiz.Retrieve(questionQuizController.AccountData.UserID, questionQuizController.Request.QuestionNo)
+		questionQuiz.Retrieve(questionQuizController.AccountData.UserID, questionNo)
+		questionQuizController.Response(c)
 
 	})
 }

space/controller/quiz/answer_quiz_controller.go

@@ -17,8 +17,9 @@ func Answer(c *gin.Context) {
 	quizAnswerController.RequestJSON(c, func() {
 		quizId, _ := strconv.Atoi(c.Param("quiz_id"))
 		academyId, _ := strconv.Atoi(c.Param("academy_id"))
+		questionNo, _ := strconv.Atoi(c.Query("question_no"))
 		quizAnswerController.Service.Constructor.ID = uint(quizId)
 		quizAnswerController.Service.Constructor.AcademyID = uint(academyId)
-		quizAnswer.Update(quizAnswerController.AccountData.UserID, quizAnswerController.Request.QuestionNo, quizAnswerController.Request.Answer)
+		quizAnswer.Update(quizAnswerController.AccountData.UserID, questionNo, quizAnswerController.Request.Answer)
 	})
 }

space/space/controller/quiz/attempt_quiz_controller.go

@@ -14,11 +14,12 @@ func Attempt(c *gin.Context) {
 	attemptQuizController := controller.Controller[any, models.Quiz, models.QuizAttempt]{
 		Service: &attemptQuiz.Service,
 	}
-	attemptQuizController.RequestJSON(c, func() {
+	attemptQuizController.HeaderParse(c, func() {
 		quizId, _ := strconv.Atoi(c.Param("quiz_id"))
 		academyId, _ := strconv.Atoi(c.Param("academy_id"))
 		attemptQuizController.Service.Constructor.ID = uint(quizId)
 		attemptQuizController.Service.Constructor.AcademyID = uint(academyId)
 		attemptQuiz.Create(attemptQuizController.AccountData.UserID)
+		attemptQuizController.Response(c)
 	})
 }

space/space/controller/quiz/submit_quiz_controller.go

@@ -0,0 +1,23 @@
+package controller
+
+import (
+	"strconv"
+
+	"api.qobiltu.id/controller"
+	"api.qobiltu.id/models"
+	"api.qobiltu.id/services"
+	"github.com/gin-gonic/gin"
+)
+
+func Submit(c *gin.Context) {
+	submitQuiz := services.SubmitQuizService{}
+	submitQuizController := controller.Controller[any, models.QuizAttempt, models.QuizResultResponse]{
+		Service: &submitQuiz.Service,
+	}
+	submitQuizController.HeaderParse(c, func() {
+		quizId, _ := strconv.Atoi(c.Param("attempt_id"))
+		submitQuizController.Service.Constructor.ID = uint(quizId)
+		submitQuiz.Create(submitQuizController.AccountData.UserID)
+		submitQuizController.Response(c)
+	})
+}

space/space/models/database_orm_model.go

@@ -177,6 +177,12 @@ type UserAnswer struct {
 	SelectedAnswer uint `json:"selected_answer"`
 	IsCorrect      bool `json:"is_correct"`
 }
+type QuizResult struct {
+	QuizAttemptID  uint    `gorm:"column:quiz_attempt_id"`
+	TotalQuestions int     `gorm:"column:total_questions"`
+	CorrectAnswers int     `gorm:"column:correct_answers"`
+	AverageScore   float64 `gorm:"column:average_score"`
+}
 
 // Gorm table name settings
 func (Account) TableName() string                 { return "account" }

space/space/models/response_model.go

@@ -54,3 +54,8 @@ type QuestionResponse struct {
 	Answer     []Answer `json:"answer_options"`
 	UserAnswer int      `json:"current_user_answer"`
 }
+
+type QuizResultResponse struct {
+	QuizAttempt QuizAttempt `json:"quiz_attempt"`
+	Result      QuizResult  `json:"result"`
+}

space/space/repositories/quiz_repository.go

@@ -99,3 +99,21 @@ func UpdateUserAnswer(userAnswer models.UserAnswer) Repository[models.UserAnswer
 	Update(repo)
 	return *repo
 }
+
+func UpdateQuizAttempt(quizAttempt models.QuizAttempt) Repository[models.QuizAttempt, models.QuizAttempt] {
+	repo := Construct[models.QuizAttempt, models.QuizAttempt](
+		quizAttempt,
+	)
+	Update(repo)
+	return *repo
+}
+
+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 = true
+	return *repo
+}

space/space/router/quiz_route.go

@@ -12,5 +12,6 @@ func QuizRoute(router *gin.Engine) {
 		routerGroup.POST("/:academy_id/:quiz_id/attempt", middleware.AuthUser, QuizController.Attempt)
 		routerGroup.GET("/:academy_id/:quiz_id/question", middleware.AuthUser, QuizController.Question)
 		routerGroup.PUT("/:academy_id/:quiz_id/choose-answer", middleware.AuthUser, QuizController.Answer)
+		routerGroup.POST("/submit-attempt/:attempt_id", middleware.AuthUser, QuizController.Submit)
 	}
 }

space/space/services/academy_quiz_service.go

@@ -13,6 +13,10 @@ type AttemptQuizService struct {
 	Service[models.Quiz, models.QuizAttempt]
 }
 
+type SubmitQuizService struct {
+	Service[models.QuizAttempt, models.QuizResultResponse]
+}
+
 func AuthorizeQuizwithAcademy(s *AttemptQuizService, next func()) {
 	academyRepo := repositories.GetAcademyByID(s.Constructor.AcademyID)
 	s.Error = academyRepo.RowsError
@@ -122,3 +126,29 @@ func (s *AttemptQuizService) Create(userID uint) {
 		}
 	})
 }
+func (s *SubmitQuizService) Create(userID uint) {
+	quizAttemptRepo := repositories.GetAttemptById(s.Constructor.ID)
+	if quizAttemptRepo.NoRecord {
+		s.Exception.DataNotFound = true
+		s.Exception.Message = "There is no quiz attempt with given user!"
+		return
+	}
+	s.Error = errors.Join(s.Error, quizAttemptRepo.RowsError)
+	countScoreRepo := repositories.CountUserAttemptScore(s.Constructor.ID)
+	s.Error = errors.Join(s.Error, countScoreRepo.RowsError)
+
+	if quizAttemptRepo.Result.FinishedAt == nil {
+		finishTime := time.Now()
+		quizAttemptRepo.Result.FinishedAt = &finishTime
+		quizAttemptRepo.Result.Score = countScoreRepo.Result.AverageScore * 100
+		updateAttemptRepo := repositories.UpdateQuizAttempt(quizAttemptRepo.Result)
+		s.Error = errors.Join(s.Error, updateAttemptRepo.RowsError)
+	}
+
+	s.Result = models.QuizResultResponse{
+		QuizAttempt: quizAttemptRepo.Result,
+		Result:      countScoreRepo.Result,
+	}
+
+	return
+}

space/space/space/config/database_connection_config.go

@@ -64,6 +64,11 @@ func AutoMigrateAll(db *gorm.DB) {
 		&models.RegionProvince{},
 		&models.OptionCategory{},
 		&models.OptionValues{},
+		&models.Quiz{},
+		&models.QuizAttempt{},
+		&models.Question{},
+		&models.Answer{},
+		&models.UserAnswer{},
 	)
 
 	if err != nil {

space/space/space/controller/quiz/answer_quiz_controller.go

@@ -0,0 +1,24 @@
+package controller
+
+import (
+	"strconv"
+
+	"api.qobiltu.id/controller"
+	"api.qobiltu.id/models"
+	"api.qobiltu.id/services"
+	"github.com/gin-gonic/gin"
+)
+
+func Answer(c *gin.Context) {
+	quizAnswer := services.AnswerQuizService{}
+	quizAnswerController := controller.Controller[models.AnswerQuizRequest, models.Quiz, models.QuestionResponse]{
+		Service: &quizAnswer.Service,
+	}
+	quizAnswerController.RequestJSON(c, func() {
+		quizId, _ := strconv.Atoi(c.Param("quiz_id"))
+		academyId, _ := strconv.Atoi(c.Param("academy_id"))
+		quizAnswerController.Service.Constructor.ID = uint(quizId)
+		quizAnswerController.Service.Constructor.AcademyID = uint(academyId)
+		quizAnswer.Update(quizAnswerController.AccountData.UserID, quizAnswerController.Request.QuestionNo, quizAnswerController.Request.Answer)
+	})
+}

space/space/space/controller/quiz/attempt_quiz_controller.go

@@ -0,0 +1,24 @@
+package controller
+
+import (
+	"strconv"
+
+	"api.qobiltu.id/controller"
+	"api.qobiltu.id/models"
+	"api.qobiltu.id/services"
+	"github.com/gin-gonic/gin"
+)
+
+func Attempt(c *gin.Context) {
+	attemptQuiz := services.AttemptQuizService{}
+	attemptQuizController := controller.Controller[any, models.Quiz, models.QuizAttempt]{
+		Service: &attemptQuiz.Service,
+	}
+	attemptQuizController.RequestJSON(c, func() {
+		quizId, _ := strconv.Atoi(c.Param("quiz_id"))
+		academyId, _ := strconv.Atoi(c.Param("academy_id"))
+		attemptQuizController.Service.Constructor.ID = uint(quizId)
+		attemptQuizController.Service.Constructor.AcademyID = uint(academyId)
+		attemptQuiz.Create(attemptQuizController.AccountData.UserID)
+	})
+}

space/space/space/controller/quiz/question_quiz_controller.go

@@ -0,0 +1,25 @@
+package controller
+
+import (
+	"strconv"
+
+	"api.qobiltu.id/controller"
+	"api.qobiltu.id/models"
+	"api.qobiltu.id/services"
+	"github.com/gin-gonic/gin"
+)
+
+func Question(c *gin.Context) {
+	questionQuiz := services.QuestionQuizService{}
+	questionQuizController := controller.Controller[models.QuestionQuizRequest, models.Quiz, models.QuestionResponse]{
+		Service: &questionQuiz.Service,
+	}
+	questionQuizController.RequestJSON(c, func() {
+		quizId, _ := strconv.Atoi(c.Param("quiz_id"))
+		academyId, _ := strconv.Atoi(c.Param("academy_id"))
+		questionQuizController.Service.Constructor.ID = uint(quizId)
+		questionQuizController.Service.Constructor.AcademyID = uint(academyId)
+		questionQuiz.Retrieve(questionQuizController.AccountData.UserID, questionQuizController.Request.QuestionNo)
+
+	})
+}

space/space/space/models/database_orm_model.go

@@ -137,6 +137,46 @@ type RegionCity struct {
 	FullCode   string `json:"full_code"`
 	ProvinceID uint   `json:"province_id"`
 }
+type Answer struct {
+	ID         uint   `gorm:"primaryKey"`
+	QuestionID uint   `json:"question_id"`
+	Content    string `json:"content"`
+	IsCorrect  bool   `json:"-"`
+}
+type Question struct {
+	ID            uint   `gorm:"primaryKey"`
+	QuizID        uint   `json:"quiz_id"`
+	Content       string `json:"content"`
+	Order         int    `json:"order"`
+	CorrectAnswer uint   `json:"-"`
+}
+type Quiz struct {
+	ID           uint      `gorm:"primaryKey" json:"id"`
+	AcademyID    uint      `json:"academy_id"`
+	Title        string    `json:"title"`
+	Description  string    `json:"description"`
+	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"`
+	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"`
+	QuizAttemptID  uint `json:"quiz_attempt_id"`
+	QuestionID     uint `json:"question_id"`
+	SelectedAnswer uint `json:"selected_answer"`
+	IsCorrect      bool `json:"is_correct"`
+}
 
 // Gorm table name settings
 func (Account) TableName() string                 { return "account" }
@@ -152,3 +192,10 @@ func (AcademyMaterialProgress) TableName() string { return "academy_materials_pr
 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" }
+func (Question) TableName() string                { return "questions" }
+func (Quiz) TableName() string                    { return "quizzes" }
+func (QuizAttempt) TableName() string             { return "quiz_attempts" }
+func (UserAnswer) TableName() string              { return "user_answers" }
+func (OptionCategory) TableName() string          { return "option_categories" }
+func (OptionValues) TableName() string            { return "option_values" }

space/space/space/models/exception_model.go

@@ -8,5 +8,8 @@ type Exception struct {
 	DataDuplicate         bool   `json:"data_duplicate,omitempty"`
 	QueryError            bool   `json:"query_error,omitempty"`
 	InvalidPasswordLength bool   `json:"invalid_password_length,omitempty"`
+	IsPassTheLimit        bool   `json:"is_pass_the_limit,omitempty"`
+	IsTimeOut             bool   `json:"is_time_out,omitempty"`
+	AttemptNotFound       bool   `json:"attempt_not_found,omitempty"`
 	Message               string `json:"message,omitempty"`
 }

space/space/space/models/request_model.go

@@ -40,3 +40,12 @@ type ValidateForgotPasswordRequest struct {
 	Token       uint   `json:"token" binding:"required"`
 	NewPassword string `json:"new_password"`
 }
+
+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"`
+}

space/space/space/models/response_model.go

@@ -43,3 +43,14 @@ type AcademyResponse struct {
 type AllAcademyResponse struct {
 	Academies []AcademyResponse `json:"academy_dasar"`
 }
+
+type AttemptExamResponse struct {
+	Exam      Quiz       `json:"exam"`
+	Questions []Question `json:"questions"`
+}
+
+type QuestionResponse struct {
+	Question   Question `json:"question"`
+	Answer     []Answer `json:"answer_options"`
+	UserAnswer int      `json:"current_user_answer"`
+}

space/space/space/repositories/academy_repository.go

@@ -82,3 +82,14 @@ func GetAcademyMaterialBySlug(slug string) Repository[models.AcademyMaterial, mo
 	)
 	return *repo
 }
+
+func GetAcademyByID(id uint) Repository[models.Academy, models.Academy] {
+	repo := Construct[models.Academy, models.Academy](
+		models.Academy{ID: id},
+	)
+	repo.Transactions(
+		WhereGivenConstructor[models.Academy, models.Academy],
+		Find[models.Academy, models.Academy],
+	)
+	return *repo
+}

space/space/space/repositories/question_repository.go

@@ -0,0 +1,36 @@
+package repositories
+
+import "api.qobiltu.id/models"
+
+func GetQuestionByQuizId(quizId uint) Repository[models.Question, []models.Question] {
+	repo := Construct[models.Question, []models.Question](
+		models.Question{QuizID: quizId},
+	)
+	repo.Transactions(
+		WhereGivenConstructor[models.Question, []models.Question],
+		Find[models.Question, []models.Question],
+	)
+	return *repo
+}
+
+func GetQuestionByOrder(quizId uint, order int) Repository[models.Question, models.Question] {
+	repo := Construct[models.Question, models.Question](
+		models.Question{QuizID: quizId, Order: order},
+	)
+	repo.Transactions(
+		WhereGivenConstructor[models.Question, models.Question],
+		Find[models.Question, models.Question],
+	)
+	return *repo
+}
+
+func GetAnswerByQuestionId(questionId uint) Repository[models.Answer, []models.Answer] {
+	repo := Construct[models.Answer, []models.Answer](
+		models.Answer{QuestionID: questionId},
+	)
+	repo.Transactions(
+		WhereGivenConstructor[models.Answer, []models.Answer],
+		Find[models.Answer, []models.Answer],
+	)
+	return *repo
+}

space/space/space/repositories/quiz_repository.go

@@ -0,0 +1,101 @@
+package repositories
+
+import (
+	"api.qobiltu.id/models"
+)
+
+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
+}
+
+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
+}
+
+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],
+	)
+
+	return *repo
+}
+
+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
+}
+
+func GetAttemptById(attemptId uint) Repository[models.QuizAttempt, models.QuizAttempt] {
+	repo := Construct[models.QuizAttempt, models.QuizAttempt](
+		models.QuizAttempt{ID: attemptId},
+	)
+	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,
+	)
+
+	Create(repo)
+	return *repo
+}
+
+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 CreateUserAnswer(userAnswer models.UserAnswer) Repository[models.UserAnswer, models.UserAnswer] {
+	repo := Construct[models.UserAnswer, models.UserAnswer](
+		userAnswer,
+	)
+
+	Create(repo)
+	return *repo
+}
+
+func UpdateUserAnswer(userAnswer models.UserAnswer) Repository[models.UserAnswer, models.UserAnswer] {
+	repo := Construct[models.UserAnswer, models.UserAnswer](
+		userAnswer,
+	)
+	Update(repo)
+	return *repo
+}

space/space/space/router/quiz_route.go

@@ -0,0 +1,16 @@
+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")
+	{
+		routerGroup.POST("/:academy_id/:quiz_id/attempt", middleware.AuthUser, QuizController.Attempt)
+		routerGroup.GET("/:academy_id/:quiz_id/question", middleware.AuthUser, QuizController.Question)
+		routerGroup.PUT("/:academy_id/:quiz_id/choose-answer", middleware.AuthUser, QuizController.Answer)
+	}
+}

space/space/space/router/router.go

@@ -11,12 +11,12 @@ import (
 func StartService() {
 	router := gin.Default()
 	router.GET("/", controller.HomeController)
-
 	AuthRoute(router)
 	UserRoute(router)
 	EmailRoute(router)
 	OptionsRoute(router)
 	AcademyRoute(router)
+	QuizRoute(router)
 	err := router.Run(config.TCP_ADDRESS)
 	if err != nil {
 		log.Fatalf("Failed to run server: %v", err)

space/space/space/services/academy_quiz_answer_service.go

@@ -0,0 +1,56 @@
+package services
+
+import (
+	"errors"
+
+	"api.qobiltu.id/models"
+	"api.qobiltu.id/repositories"
+)
+
+type AnswerQuizService struct {
+	Service[models.Quiz, models.QuestionResponse]
+}
+
+func (s *AnswerQuizService) Update(userID uint, questionNo int, answer int) {
+	QuizAttemptService := AttemptQuizService{}
+	QuizAttemptService.Constructor = s.Constructor
+	QuizAttemptService.Validate(userID, func(latestAttemptRepo repositories.Repository[models.QuizAttempt, models.QuizAttempt], quizRepo repositories.Repository[models.Quiz, models.Quiz]) {
+
+		questionRepo := repositories.GetQuestionByOrder(latestAttemptRepo.Result.QuizID, questionNo)
+		if questionRepo.NoRecord {
+			s.Exception.DataNotFound = true
+			s.Exception.Message = "There is no quiz with given academy!"
+			return
+		}
+
+		s.Error = questionRepo.RowsError
+		answerRepo := repositories.GetUserAnswerByAttemptQuestionId(latestAttemptRepo.Result.ID, questionRepo.Result.ID)
+		if answerRepo.NoRecord {
+			s.Exception.DataNotFound = true
+			s.Exception.Message = "There is no Answer with given AttemptId!"
+			return
+		}
+		s.Error = errors.Join(s.Error, answerRepo.RowsError)
+
+		answerRepo.Result.SelectedAnswer = uint(answer)
+		answerRepo.Result.IsCorrect = (questionRepo.Result.CorrectAnswer == uint(answer))
+
+		updatedAnswer := repositories.UpdateUserAnswer(answerRepo.Result)
+
+		s.Error = errors.Join(s.Error, updatedAnswer.RowsError)
+
+		questionRepo.Result.CorrectAnswer = uint(0)
+		answerOptionRepo := repositories.GetAnswerByQuestionId(questionRepo.Result.ID)
+		if answerOptionRepo.NoRecord {
+			s.Exception.DataNotFound = true
+			s.Exception.Message = "There is no Answer Option with given QuestionId!"
+			return
+		}
+		s.Result = models.QuestionResponse{
+			Question:   questionRepo.Result,
+			Answer:     answerOptionRepo.Result,
+			UserAnswer: int(answerRepo.Result.SelectedAnswer),
+		}
+		return
+	})
+}

space/space/space/services/academy_quiz_question_service.go

@@ -0,0 +1,42 @@
+package services
+
+import (
+	"api.qobiltu.id/models"
+	"api.qobiltu.id/repositories"
+)
+
+type QuestionQuizService struct {
+	Service[models.Quiz, models.QuestionResponse]
+}
+
+func (s *QuestionQuizService) Retrieve(userID uint, questionNo int) {
+	QuizAttemptService := AttemptQuizService{}
+	QuizAttemptService.Constructor = s.Constructor
+	QuizAttemptService.Validate(userID, func(latestAttemptRepo repositories.Repository[models.QuizAttempt, models.QuizAttempt], quizRepo repositories.Repository[models.Quiz, models.Quiz]) {
+		questionRepo := repositories.GetQuestionByOrder(s.Constructor.ID, questionNo)
+		s.Error = questionRepo.RowsError
+		if questionRepo.NoRecord {
+			s.Exception.DataNotFound = true
+			s.Exception.Message = "There is no quiz with given academy!"
+			return
+		}
+		answerRepo := repositories.GetUserAnswerByAttemptQuestionId(latestAttemptRepo.Result.ID, questionRepo.Result.ID)
+		if answerRepo.NoRecord {
+			s.Exception.DataNotFound = true
+			s.Exception.Message = "There is no Answer with given AttemptId!"
+			return
+		}
+		answerOptionRepo := repositories.GetAnswerByQuestionId(questionRepo.Result.ID)
+		if answerOptionRepo.NoRecord {
+			s.Exception.DataNotFound = true
+			s.Exception.Message = "There is no Answer Option with given QuestionId!"
+			return
+		}
+		s.Result = models.QuestionResponse{
+			Question:   questionRepo.Result,
+			Answer:     answerOptionRepo.Result,
+			UserAnswer: int(answerRepo.Result.SelectedAnswer),
+		}
+		return
+	})
+}

space/space/space/services/academy_quiz_service.go

@@ -0,0 +1,124 @@
+package services
+
+import (
+	"errors"
+	"fmt"
+	"time"
+
+	"api.qobiltu.id/models"
+	"api.qobiltu.id/repositories"
+)
+
+type AttemptQuizService struct {
+	Service[models.Quiz, models.QuizAttempt]
+}
+
+func AuthorizeQuizwithAcademy(s *AttemptQuizService, next func()) {
+	academyRepo := repositories.GetAcademyByID(s.Constructor.AcademyID)
+	s.Error = academyRepo.RowsError
+	if academyRepo.NoRecord {
+		s.Exception.DataNotFound = true
+		s.Exception.Message = "There is no academy with given slug!"
+		return
+	}
+	quizRepo := repositories.GetQuizbyAcademyId(academyRepo.Result.ID)
+	s.Error = quizRepo.RowsError
+	if quizRepo.NoRecord {
+		s.Exception.DataNotFound = true
+		s.Exception.Message = "There is no quiz with given academy!"
+		return
+	}
+	next()
+}
+func CheckUserAttemptLimit(s *AttemptQuizService, allAttemptsRepo repositories.Repository[models.QuizAttempt, []models.QuizAttempt], quizRepo repositories.Repository[models.Quiz, models.Quiz], userID uint, next func()) {
+	if (allAttemptsRepo.RowsCount >= quizRepo.Result.AttemptLimit) && (allAttemptsRepo.Result[allAttemptsRepo.RowsCount-1].FinishedAt != nil) {
+		s.Exception.IsPassTheLimit = true
+		s.Exception.Message = "You have reached the attempt limit!"
+		return
+	}
+	next()
+}
+
+func CheckUserLatestAttempt(s *AttemptQuizService, latestAttemptRepo repositories.Repository[models.QuizAttempt, models.QuizAttempt], quizRepo repositories.Repository[models.Quiz, models.Quiz], userID uint, next func()) {
+	currentTime := time.Now()
+	if currentTime.After(latestAttemptRepo.Result.DueAt) {
+		s.Exception.IsTimeOut = true
+		s.Exception.Message = "Your latest attempt is timeout!"
+		// Submit
+		return
+	}
+	next()
+}
+
+func CheckUserAttemptable(s *AttemptQuizService, latestAttemptRepo repositories.Repository[models.QuizAttempt, []models.QuizAttempt], quizRepo repositories.Repository[models.Quiz, models.Quiz], userID uint, next func()) {
+	s.Error = errors.Join(s.Error, latestAttemptRepo.RowsError, quizRepo.RowsError)
+	if latestAttemptRepo.Result[latestAttemptRepo.RowsCount-1].FinishedAt != nil {
+		s.Exception.IsPassTheLimit = true
+		s.Exception.Message = "You have reached the attempt limit!"
+		return
+	}
+	next()
+}
+func (s *AttemptQuizService) Validate(userID uint, next func(latestAttemptRepo repositories.Repository[models.QuizAttempt, models.QuizAttempt], quizRepo repositories.Repository[models.Quiz, models.Quiz])) {
+	AuthorizeQuizwithAcademy(s, func() {
+		quizRepo := repositories.GetQuizbyId(s.Constructor.ID)
+		if quizRepo.NoRecord {
+			s.Exception.DataNotFound = true
+			s.Exception.Message = "There is no quiz data with given Id!"
+			return
+		}
+		allAttemptsRepo := repositories.GetAllUserAttempt(userID, s.Constructor.ID)
+		if allAttemptsRepo.NoRecord {
+			Attempt(s, quizRepo, userID)
+			allAttemptsRepo = repositories.GetAllUserAttempt(userID, s.Constructor.ID)
+		}
+		s.Error = errors.Join(allAttemptsRepo.RowsError, quizRepo.RowsError)
+		CheckUserAttemptLimit(s, allAttemptsRepo, quizRepo, userID, func() {
+			fmt.Println("accountID", userID)
+			fmt.Println("quizID", s.Constructor.ID)
+			latestAttemptRepo := repositories.GetUserLastAttempt(userID, s.Constructor.ID)
+			if latestAttemptRepo.NoRecord {
+				s.Exception.DataNotFound = true
+				s.Exception.Message = "There is no quiz attempt with given user!"
+				return
+			}
+			s.Error = errors.Join(s.Error, latestAttemptRepo.RowsError)
+			CheckUserLatestAttempt(s, latestAttemptRepo, quizRepo, userID, func() {
+				next(latestAttemptRepo, quizRepo)
+			})
+		})
+	})
+}
+
+func Attempt(s *AttemptQuizService, quizRepo repositories.Repository[models.Quiz, models.Quiz], userID uint) {
+	startTime := time.Now()
+	dueTime := startTime.Add(time.Duration(quizRepo.Result.TimeLimit) * time.Minute)
+	createdAttemptRepo := repositories.CreateAttempt(models.QuizAttempt{
+		AccountID: userID,
+		QuizID:    s.Constructor.ID,
+		StartedAt: startTime,
+		DueAt:     dueTime,
+	})
+	s.Error = createdAttemptRepo.RowsError
+	questionsRepo := repositories.GetQuestionByQuizId(s.Constructor.ID)
+	for _, question := range questionsRepo.Result {
+		createdUserAnswer := repositories.CreateUserAnswer(models.UserAnswer{
+			QuizAttemptID: createdAttemptRepo.Result.ID,
+			QuestionID:    question.ID,
+		})
+		if createdUserAnswer.RowsError != nil {
+			s.Error = createdUserAnswer.RowsError
+			return
+		}
+	}
+	s.Result = createdAttemptRepo.Result
+}
+func (s *AttemptQuizService) Create(userID uint) {
+	s.Validate(userID, func(latestAttemptRepo repositories.Repository[models.QuizAttempt, models.QuizAttempt], quizRepo repositories.Repository[models.Quiz, models.Quiz]) {
+		if latestAttemptRepo.Result.FinishedAt != nil {
+			Attempt(s, quizRepo, userID)
+		} else {
+			s.Result = latestAttemptRepo.Result
+		}
+	})
+}

space/space/space/space/controller/academy/academy_contents_controller.go

@@ -9,7 +9,7 @@ import (
 
 func ContentList(c *gin.Context) {
 	academyContent := services.AcademyContentService{}
-	academyController := controller.Controller[any, models.AcademyMaterial, []models.AcademyContent]{
+	academyController := controller.Controller[any, models.AcademyMaterial, models.AcademyContent]{
 		Service: &academyContent.Service,
 	}
 	academyController.Service.Constructor.Slug = c.Param("slug_material")

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

@@ -71,9 +71,11 @@ 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"`
+	Slug              string    `json:"slug" gorm:"uniqueIndex" `
 	TotalMaterial     int       `json:"total_material"`
 	CompletedMaterial int       `json:"completed_material"`
+	IsCompletedRead   bool      `json:"is_read"`
+	IsPassedExam      bool      `json:"is_exam"`
 	Description       string    `json:"description"`
 }
 
@@ -82,7 +84,7 @@ type AcademyMaterial struct {
 	UUID        uuid.UUID `gorm:"type:uuid" json:"uuid"`
 	AcademyID   uint      `json:"academy_id"`
 	Title       string    `json:"title"`
-	Slug        string    `json:"slug"`
+	Slug        string    `json:"slug" gorm:"uniqueIndex"`
 	IsCompleted bool      `json:"is_completed"`
 	Description string    `json:"description"`
 }
@@ -98,7 +100,7 @@ type AcademyContent struct {
 type OptionCategory struct {
 	ID         uint   `gorm:"primaryKey" json:"id"`
 	OptionName string `json:"option_name"`
-	OptionSlug string `json:"option_slug"`
+	OptionSlug string `json:"option_slug" gorm:"uniqueIndex"`
 }
 
 type OptionValues struct {

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

@@ -33,7 +33,7 @@ type UserProfileResponse struct {
 
 type AcademyMaterialResponse struct {
 	Materials AcademyMaterial
-	Contents  []AcademyContent
+	Contents  AcademyContent
 }
 type AcademyResponse struct {
 	Academy   Academy                   `json:"academy"`

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

@@ -35,13 +35,13 @@ func GetAllAcademyMaterialsByAcademyID(acaddemyId uint) Repository[models.Academ
 	return *repo
 }
 
-func GetAllAcademyContentsByMaterialID(materialId uint) Repository[models.AcademyContent, []models.AcademyContent] {
-	repo := Construct[models.AcademyContent, []models.AcademyContent](
+func GetAllAcademyContentsByMaterialID(materialId uint) Repository[models.AcademyContent, models.AcademyContent] {
+	repo := Construct[models.AcademyContent, models.AcademyContent](
 		models.AcademyContent{AcademyMaterialID: materialId},
 	)
 	repo.Transactions(
-		WhereGivenConstructor[models.AcademyContent, []models.AcademyContent],
-		Find[models.AcademyContent, []models.AcademyContent],
+		WhereGivenConstructor[models.AcademyContent, models.AcademyContent],
+		Find[models.AcademyContent, models.AcademyContent],
 	)
 	return *repo
 }

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

@@ -1,6 +1,8 @@
 package services
 
 import (
+	"errors"
+
 	"api.qobiltu.id/models"
 	"api.qobiltu.id/repositories"
 	"github.com/gosimple/slug"
@@ -20,12 +22,13 @@ type AcademyMaterialService struct {
 }
 
 type AcademyContentService struct {
-	Service[models.AcademyMaterial, []models.AcademyContent]
+	Service[models.AcademyMaterial, models.AcademyContent]
 }
 
 func castAcademyMaterials(academyId uint) []models.AcademyMaterialResponse {
 	var ArrMaterials []models.AcademyMaterialResponse
-	for _, academyMaterial := range repositories.GetAllAcademyMaterialsByAcademyID(academyId).Result {
+	academyMaterialsRepo := repositories.GetAllAcademyMaterialsByAcademyID(academyId)
+	for _, academyMaterial := range academyMaterialsRepo.Result {
 		ArrMaterials = append(ArrMaterials, models.AcademyMaterialResponse{
 			Materials: academyMaterial,
 			Contents:  repositories.GetAllAcademyContentsByMaterialID(academyMaterial.ID).Result,
@@ -78,7 +81,7 @@ func (s *CreateAcademyService) Create() {
 				s.Error = createdMaterial.RowsError
 				return
 			}
-			for _, content := range material.Contents {
+			for _, content := range []models.AcademyContent{material.Contents} {
 				content.UUID = uuid.NewV4()
 				content.AcademyMaterialID = createdMaterial.Result.ID
 				createdContent := repositories.CreateAcademyContent(content)
@@ -98,9 +101,15 @@ func (s *CreateAcademyService) Create() {
 }
 
 func (s *AcademyMaterialService) Retrieve() {
-	academyId := repositories.GetAcademyDataBySlug(s.Constructor.Slug).Result.ID
-	academyMaterialRepo := repositories.GetAllAcademyMaterialsByAcademyID(academyId)
-	s.Error = academyMaterialRepo.RowsError
+	academyRepo := repositories.GetAcademyDataBySlug(s.Constructor.Slug)
+	if academyRepo.NoRecord {
+		s.Exception.DataNotFound = true
+		s.Exception.Message = "There is no Academy found with given Slug!"
+		return
+	}
+	s.Error = academyRepo.RowsError
+	academyMaterialRepo := repositories.GetAllAcademyMaterialsByAcademyID(academyRepo.Result.ID)
+	s.Error = errors.Join(s.Error, academyMaterialRepo.RowsError)
 	if academyMaterialRepo.NoRecord {
 		s.Exception.DataNotFound = true
 		s.Exception.Message = "There is no Academy Material with given ID"
@@ -110,9 +119,15 @@ func (s *AcademyMaterialService) Retrieve() {
 }
 
 func (s *AcademyContentService) Retrieve() {
-	academyMaterialId := repositories.GetAcademyMaterialBySlug(s.Constructor.Slug).Result.ID
-	academyContentRepo := repositories.GetAllAcademyContentsByMaterialID(academyMaterialId)
-	s.Error = academyContentRepo.RowsError
+	academyMaterialRepo := repositories.GetAcademyMaterialBySlug(s.Constructor.Slug)
+	s.Error = academyMaterialRepo.RowsError
+	if academyMaterialRepo.NoRecord {
+		s.Exception.DataNotFound = true
+		s.Exception.Message = "There is no Academy Material with given Slug"
+		return
+	}
+	academyContentRepo := repositories.GetAllAcademyContentsByMaterialID(academyMaterialRepo.Result.ID)
+	s.Error = errors.Join(s.Error, academyContentRepo.RowsError)
 	if academyContentRepo.NoRecord {
 		s.Exception.DataNotFound = true
 		s.Exception.Message = "There is no Academy Contents with given Material ID"

space/space/space/space/services/register_service.go

@@ -2,6 +2,7 @@ package services
 
 import (
 	"errors"
+	"unicode"
 
 	"api.qobiltu.id/models"
 	"api.qobiltu.id/repositories"
@@ -13,10 +14,49 @@ type RegisterService struct {
 	Service[models.Account, models.Account]
 }
 
+func ValidatePassword(password string) models.Exception {
+	var (
+		hasMinLen  = false
+		hasUpper   = false
+		hasLower   = false
+		hasNumber  = false
+		hasSpecial = false
+	)
+
+	if len(password) >= 8 {
+		hasMinLen = true
+	}
+
+	for _, char := range password {
+		switch {
+		case unicode.IsUpper(char):
+			hasUpper = true
+			break
+		case unicode.IsLower(char):
+			hasLower = true
+			break
+		case unicode.IsDigit(char):
+			hasNumber = true
+			break
+		case unicode.IsPunct(char) || unicode.IsSymbol(char):
+			hasSpecial = true
+			break
+		}
+	}
+	approve := hasMinLen && hasUpper && hasLower && hasNumber && hasSpecial
+	if !approve {
+		return models.Exception{
+			BadRequest: true,
+			Message:    "Password must contain at least 8 characters, including uppercase, lowercase, number, and special character!",
+		}
+	}
+	return models.Exception{}
+}
+
 func (s *RegisterService) Create() {
-	if len(s.Constructor.Password) < 8 {
-		s.Exception.InvalidPasswordLength = true
-		s.Exception.Message = "Password must have at least 8 characters!"
+	validatePassword := ValidatePassword(s.Constructor.Password)
+	if validatePassword.BadRequest {
+		s.Exception = validatePassword
 		return
 	}
 	hashed_password, err_hash := HashPassword(s.Constructor.Password)

space/space/space/space/space/controller/academy/academy_contents_controller.go

@@ -0,0 +1,19 @@
+package academy
+
+import (
+	"api.qobiltu.id/controller"
+	"api.qobiltu.id/models"
+	"api.qobiltu.id/services"
+	"github.com/gin-gonic/gin"
+)
+
+func ContentList(c *gin.Context) {
+	academyContent := services.AcademyContentService{}
+	academyController := controller.Controller[any, models.AcademyMaterial, []models.AcademyContent]{
+		Service: &academyContent.Service,
+	}
+	academyController.Service.Constructor.Slug = c.Param("slug_material")
+	academyContent.Retrieve()
+	academyController.Response(c)
+
+}

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

@@ -9,7 +9,7 @@ import (
 
 func List(c *gin.Context) {
 	academy := services.AcademyService{}
-	academyController := controller.Controller[any, models.Academy, models.AllAcademyResponse]{
+	academyController := controller.Controller[any, models.Academy, []models.Academy]{
 		Service: &academy.Service,
 	}
 	academyController.Service.Constructor.Slug = c.Param("slug")

space/space/space/space/space/controller/academy/academy_materials_controller.go

@@ -0,0 +1,19 @@
+package academy
+
+import (
+	"api.qobiltu.id/controller"
+	"api.qobiltu.id/models"
+	"api.qobiltu.id/services"
+	"github.com/gin-gonic/gin"
+)
+
+func MaterialsList(c *gin.Context) {
+	academyMaterial := services.AcademyMaterialService{}
+	academyController := controller.Controller[any, models.Academy, []models.AcademyMaterial]{
+		Service: &academyMaterial.Service,
+	}
+	academyController.Service.Constructor.Slug = c.Param("slug")
+	academyMaterial.Retrieve()
+	academyController.Response(c)
+
+}

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

@@ -68,11 +68,13 @@ type ForgotPassword struct {
 }
 
 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"`
-	Description string    `json:"description"`
+	ID                uint      `gorm:"primaryKey" json:"id"`
+	UUID              uuid.UUID `gorm:"type:uuid" json:"uuid"`
+	Title             string    `json:"title"`
+	Slug              string    `json:"slug"`
+	TotalMaterial     int       `json:"total_material"`
+	CompletedMaterial int       `json:"completed_material"`
+	Description       string    `json:"description"`
 }
 
 type AcademyMaterial struct {
@@ -81,6 +83,7 @@ type AcademyMaterial struct {
 	AcademyID   uint      `json:"academy_id"`
 	Title       string    `json:"title"`
 	Slug        string    `json:"slug"`
+	IsCompleted bool      `json:"is_completed"`
 	Description string    `json:"description"`
 }
 

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

@@ -71,3 +71,14 @@ func CreateAcademyContent(academyContent models.AcademyContent) Repository[model
 	Create(repo)
 	return *repo
 }
+
+func GetAcademyMaterialBySlug(slug string) Repository[models.AcademyMaterial, models.AcademyMaterial] {
+	repo := Construct[models.AcademyMaterial, models.AcademyMaterial](
+		models.AcademyMaterial{Slug: slug},
+	)
+	repo.Transactions(
+		WhereGivenConstructor[models.AcademyMaterial, models.AcademyMaterial],
+		Find[models.AcademyMaterial, models.AcademyMaterial],
+	)
+	return *repo
+}

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

@@ -9,7 +9,8 @@ import (
 func AcademyRoute(router *gin.Engine) {
 	routerGroup := router.Group("/api/v1/academy")
 	{
-		routerGroup.GET("/list/:slug", middleware.AuthUser, AcademyController.List)
+		routerGroup.GET("/:slug", middleware.AuthUser, AcademyController.MaterialsList)
+		routerGroup.GET("/:slug/:slug_material", middleware.AuthUser, AcademyController.ContentList)
 		routerGroup.GET("/list", middleware.AuthUser, AcademyController.List)
 		routerGroup.POST("/create", middleware.AuthUser, AcademyController.Create)
 	}

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

@@ -8,13 +8,21 @@ import (
 )
 
 type AcademyService struct {
-	Service[models.Academy, models.AllAcademyResponse]
+	Service[models.Academy, []models.Academy]
 }
 
 type CreateAcademyService struct {
 	Service[models.AllAcademyResponse, models.AllAcademyResponse]
 }
 
+type AcademyMaterialService struct {
+	Service[models.Academy, []models.AcademyMaterial]
+}
+
+type AcademyContentService struct {
+	Service[models.AcademyMaterial, []models.AcademyContent]
+}
+
 func castAcademyMaterials(academyId uint) []models.AcademyMaterialResponse {
 	var ArrMaterials []models.AcademyMaterialResponse
 	for _, academyMaterial := range repositories.GetAllAcademyMaterialsByAcademyID(academyId).Result {
@@ -35,27 +43,13 @@ func (s *AcademyService) Retrieve() {
 			return
 		}
 
-		s.Result = models.AllAcademyResponse{
-			Academies: []models.AcademyResponse{
-				models.AcademyResponse{
-					Academy:   AcademyRepo.Result,
-					Materials: castAcademyMaterials(s.Constructor.ID),
-				},
-			},
+		s.Result = []models.Academy{
+			AcademyRepo.Result,
 		}
 	} else {
 		AcademyRepo := repositories.GetAllAcademy()
 		s.Error = AcademyRepo.RowsError
-		var ArrAcademy []models.AcademyResponse
-		for _, academy := range AcademyRepo.Result {
-			ArrAcademy = append(ArrAcademy, models.AcademyResponse{
-				Academy:   academy,
-				Materials: castAcademyMaterials(academy.ID),
-			})
-		}
-		s.Result = models.AllAcademyResponse{
-			Academies: ArrAcademy,
-		}
+		s.Result = AcademyRepo.Result
 	}
 
 }
@@ -102,3 +96,27 @@ func (s *CreateAcademyService) Create() {
 	s.Result = models.AllAcademyResponse{Academies: ArrAcademy}
 
 }
+
+func (s *AcademyMaterialService) Retrieve() {
+	academyId := repositories.GetAcademyDataBySlug(s.Constructor.Slug).Result.ID
+	academyMaterialRepo := repositories.GetAllAcademyMaterialsByAcademyID(academyId)
+	s.Error = academyMaterialRepo.RowsError
+	if academyMaterialRepo.NoRecord {
+		s.Exception.DataNotFound = true
+		s.Exception.Message = "There is no Academy Material with given ID"
+		return
+	}
+	s.Result = academyMaterialRepo.Result
+}
+
+func (s *AcademyContentService) Retrieve() {
+	academyMaterialId := repositories.GetAcademyMaterialBySlug(s.Constructor.Slug).Result.ID
+	academyContentRepo := repositories.GetAllAcademyContentsByMaterialID(academyMaterialId)
+	s.Error = academyContentRepo.RowsError
+	if academyContentRepo.NoRecord {
+		s.Exception.DataNotFound = true
+		s.Exception.Message = "There is no Academy Contents with given Material ID"
+		return
+	}
+	s.Result = academyContentRepo.Result
+}

space/space/space/space/space/services/jwt_service.go

@@ -20,7 +20,7 @@ func GenerateToken(user *models.Account) (string, error) {
 		RegisteredClaims: jwt.RegisteredClaims{
 			ExpiresAt: jwt.NewNumericDate(time.Now().Add(time.Hour * 24)), // Token berlaku 24 jam
 			IssuedAt:  jwt.NewNumericDate(time.Now()),
-			Issuer:    "qobiltu.id",
+			Issuer:    "apqobiltu.id",
 		},
 	}
 

space/space/space/space/space/services/service.go

@@ -16,6 +16,9 @@ type (
 		Authenticate()
 		Authorize()
 	}
+	IService interface {
+		Implements()
+	}
 	Service[TConstructor any, TResult any] struct {
 		Constructor TConstructor
 		Result      TResult

space/space/space/space/space/space/services/email_verification_service.go

@@ -75,18 +75,7 @@ func (s *EmailVerificationService) Create() {
 			return
 		}
 
-		// 2. Start TLS
-		tlsconfig := &tls.Config{
-			ServerName: smtpHost,
-		}
-
-		if err = c.StartTLS(tlsconfig); err != nil {
-			s.Error = err
-			log.Printf("Error start TLS: %v", err)
-			return
-		}
-
-		// 3. Auth
+		// 2. Auth
 		auth := smtp.PlainAuth("", from, password, smtpHost)
 		if err = c.Auth(auth); err != nil {
 			s.Error = err
@@ -94,7 +83,7 @@ func (s *EmailVerificationService) Create() {
 			return
 		}
 
-		// 4. Set From and To
+		// 3. Set From and To
 		if err = c.Mail(from); err != nil {
 			s.Error = err
 			log.Printf("Error set mail from to: %v", err)
@@ -109,7 +98,7 @@ func (s *EmailVerificationService) Create() {
 			}
 		}
 
-		// 5. Send message
+		// 4. Send message
 		wc, err := c.Data()
 		if err != nil {
 			s.Error = err

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

@@ -7,6 +7,7 @@ import (
 	"github.com/joho/godotenv"
 )
 
+var ENV string
 var TCP_ADDRESS string
 var LOG_PATH string
 
@@ -21,6 +22,7 @@ var SMTP_PORT string
 
 func init() {
 	godotenv.Load()
+	ENV = os.Getenv("ENV")
 	HOST_ADDRESS = os.Getenv("HOST_ADDRESS")
 	HOST_PORT = os.Getenv("HOST_PORT")
 	TCP_ADDRESS = HOST_ADDRESS + ":" + HOST_PORT

space/space/space/space/space/space/space/space/services/email_verification_service.go

@@ -1,6 +1,7 @@
 package services
 
 import (
+	"crypto/tls"
 	"fmt"
 	"log"
 	"math/rand/v2"
@@ -39,27 +40,118 @@ func (s *EmailVerificationService) Create() {
 
 	// ⬇ Kirim token ke email user menggunakan SMTP
 	go func(toEmail string, token uint) {
+		env := config.ENV
 		from := config.SMTP_SENDER_EMAIL
 		password := config.SMTP_SENDER_PASSWORD
 		smtpHost := config.SMTP_HOST
 		smtpPort := config.SMTP_PORT
+		to := []string{toEmail}
 
-		auth := smtp.PlainAuth("", from, password, smtpHost)
-
-		subject := "Email Verification Token"
+		subject := "Verification token"
 		body := fmt.Sprintf("Your verification token is: %06d\nPlease use it before it expires.", token)
 
-		msg := []byte("To: " + toEmail + "\r\n" +
-			"Subject: " + subject + "\r\n" +
-			"\r\n" +
-			body + "\r\n")
+		msg := []byte(fmt.Sprintf("From: %s\r\n", from) +
+			fmt.Sprintf("To: %s\r\n", toEmail) +
+			fmt.Sprintf("Subject: %s\r\n", subject) +
+			"\r\n" + body)
+
+		// 1. Connect to the server
+		conn, err := tls.Dial("tcp", fmt.Sprintf("[%s]:%s", smtpHost, smtpPort), &tls.Config{
+			InsecureSkipVerify: env != "production", // ⚠️ set false di production
+			ServerName:         smtpHost,
+		})
 
-		err := smtp.SendMail(smtpHost+":"+smtpPort, auth, from, []string{toEmail}, msg)
+		// conn, err := net.Dial("tcp", fmt.Sprintf("[%s]:%s", smtpHost, smtpPort))
 		if err != nil {
 			s.Error = err
 			log.Printf("Error sending verification email: %v", err)
 			return
 		}
+
+		c, err := smtp.NewClient(conn, smtpHost)
+		if err != nil {
+			s.Error = err
+			log.Printf("Error create new client mail: %v", err)
+			return
+		}
+
+		// 2. Start TLS
+		tlsconfig := &tls.Config{
+			ServerName: smtpHost,
+		}
+
+		if err = c.StartTLS(tlsconfig); err != nil {
+			s.Error = err
+			log.Printf("Error start TLS: %v", err)
+			return
+		}
+
+		// 3. Auth
+		auth := smtp.PlainAuth("", from, password, smtpHost)
+		if err = c.Auth(auth); err != nil {
+			s.Error = err
+			log.Printf("Error auth mail: %v", err)
+			return
+		}
+
+		// 4. Set From and To
+		if err = c.Mail(from); err != nil {
+			s.Error = err
+			log.Printf("Error set mail from to: %v", err)
+			return
+		}
+
+		for _, addr := range to {
+			if err = c.Rcpt(addr); err != nil {
+				s.Error = err
+				log.Printf("Error receipt addr: %v", err)
+				return
+			}
+		}
+
+		// 5. Send message
+		wc, err := c.Data()
+		if err != nil {
+			s.Error = err
+			log.Printf("Error data Send Message: %v", err)
+			return
+		}
+
+		_, err = wc.Write(msg)
+		if err != nil {
+			s.Error = err
+			log.Printf("Error write Send Message: %v", err)
+			return
+		}
+
+		err = wc.Close()
+		if err != nil {
+			s.Error = err
+			log.Printf("Error close Send Message: %v", err)
+			return
+		}
+
+		c.Quit()
+		fmt.Println("Email sent successfully!")
+
+		// auth := smtp.PlainAuth("", from, password, smtpHost)
+
+		// subject := "Email Verification Token"
+		// body := fmt.Sprintf("Your verification token is: %06d\nPlease use it before it expires.", token)
+
+		// msg := []byte("To: " + toEmail + "\r\n" +
+		// 	"Subject: " + subject + "\r\n" +
+		// 	"\r\n" +
+		// 	body + "\r\n")
+
+		// err := smtp.SendMail(smtpHost+":"+smtpPort, auth, from, []string{toEmail}, msg)
+		// if err != nil {
+		// 	s.Error = err
+		// 	log.Printf("Error sending verification email: %v", err)
+		// 	return
+		// } else {
+		// 	log.Printf("Successfully sending verification email: %v", err)
+		// }
 	}(accountRepo.Result.Email, token)
 	// s.Result.Token = 0
 }

space/space/space/space/space/space/space/space/space/services/external_authentication_service.go

@@ -24,6 +24,16 @@ func (s *GoogleAuthService) Authenticate(isAgree bool) {
 		return
 	}
 	email := payload.Claims["email"]
+	checkRegisteredEmail := repositories.GetAccountbyEmail(email.(string))
+	if !checkRegisteredEmail.NoRecord {
+		token, _ := GenerateToken(&checkRegisteredEmail.Result)
+		checkRegisteredEmail.Result.Password = "SECRET"
+		s.Result = models.AuthenticatedUser{
+			Account: checkRegisteredEmail.Result,
+			Token:   token,
+		}
+		return
+	}
 	if GoogleAuth.NoRecord {
 		if !isAgree {
 			s.Exception.BadRequest = true
@@ -32,12 +42,6 @@ func (s *GoogleAuthService) Authenticate(isAgree bool) {
 		}
 		s.Constructor.UUID = uuid.NewV4()
 		s.Constructor.OauthProvider = "Google"
-		checkRegisteredEmail := repositories.GetAccountbyEmail(email.(string))
-		if !checkRegisteredEmail.NoRecord {
-			s.Exception.DataDuplicate = true
-			s.Exception.Message = "Account with email" + email.(string) + "already registered!"
-			return
-		}
 
 		createAccount := repositories.CreateAccount(models.Account{
 			UUID:            uuid.NewV4(),

space/space/space/space/space/space/space/space/space/space/services/email_verification_service.go

@@ -29,10 +29,7 @@ func (s *EmailVerificationService) Create() {
 	remainingTime := time.Duration(config.EMAIL_VERIFICATION_DURATION) * time.Hour
 	dueTime := CalculateDueTime(remainingTime)
 
-	token := uint(rand.IntN(1000000))
-	for token < 1000000 {
-		token = uint(rand.IntN(1000000))
-	}
+	token := uint(rand.IntN(999999-100000) + 100000)
 	s.Constructor.UUID = uuid.NewV4()
 
 	repo := repositories.CreateEmailVerification(s.Constructor.UUID, s.Constructor.AccountID, dueTime, token)

space/space/space/space/space/space/space/space/space/space/services/forgot_password_service.go

@@ -34,10 +34,7 @@ func (s *ForgotPasswordService) Create(email string) {
 	remainingTime := time.Duration(config.EMAIL_VERIFICATION_DURATION) * time.Hour
 	dueTime := CalculateDueTime(remainingTime)
 
-	token := uint(rand.IntN(1000000))
-	for token < 1000000 {
-		token = uint(rand.IntN(1000000))
-	}
+	token := uint(rand.IntN(999999-100000) + 100000)
 	s.Constructor.UUID = uuid.NewV4()
 	s.Constructor.ExpiredAt = dueTime
 	s.Constructor.AccountID = accountRepo.Result.Id

space/space/space/space/space/space/space/space/space/space/space/services/external_authentication_service.go

@@ -32,17 +32,34 @@ func (s *GoogleAuthService) Authenticate(isAgree bool) {
 		}
 		s.Constructor.UUID = uuid.NewV4()
 		s.Constructor.OauthProvider = "Google"
+		checkRegisteredEmail := repositories.GetAccountbyEmail(email.(string))
+		if !checkRegisteredEmail.NoRecord {
+			s.Exception.DataDuplicate = true
+			s.Exception.Message = "Account with email" + email.(string) + "already registered!"
+			return
+		}
+
 		createAccount := repositories.CreateAccount(models.Account{
 			UUID:            uuid.NewV4(),
 			Email:           email.(string),
 			IsEmailVerified: true,
 		})
+
 		s.Constructor.AccountID = createAccount.Result.Id
 		createGoogleAuth := repositories.CreateExternalAuth(s.Constructor)
-		GoogleAuth.Result.AccountID = createGoogleAuth.Result.ID
+
+		GoogleAuth.Result.AccountID = createGoogleAuth.Result.AccountID
+		userProfile := UserProfileService{}
+		userProfile.Constructor.AccountID = GoogleAuth.Result.AccountID
+		userProfile.Create()
+		if userProfile.Error != nil {
+			s.Error = userProfile.Error
+			return
+		}
 		s.Error = createGoogleAuth.RowsError
 		s.Error = errors.Join(s.Error, createAccount.RowsError)
 	}
+
 	accountData := repositories.GetAccountById(GoogleAuth.Result.AccountID)
 	token, err_tok := GenerateToken(&accountData.Result)
 

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

@@ -0,0 +1,31 @@
+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.AllAcademyResponse]{
+		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()
+	})
+
+}

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

@@ -30,7 +30,7 @@ type AccountDetails struct {
 	LastEducation *string    `json:"last_education"`
 	MaritalStatus *string    `json:"marital_status"`
 	Avatar        *string    `json:"avatar"`
-	PhoneNumber   *uint      `json:"phone_number"`
+	PhoneNumber   *string    `json:"phone_number"`
 }
 
 type EmailVerification struct {
@@ -85,12 +85,12 @@ type AcademyMaterial struct {
 }
 
 type AcademyContent struct {
-	ID                uint   `gorm:"primaryKey" json:"id"`
-	UUID              uint   `json:"uuid"`
-	Title             string `json:"title"`
-	Order             uint   `json:"order"`
-	AcademyMaterialID uint   `json:"academy_material_id"`
-	Description       string `json:"description"`
+	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"`
 }
 type OptionCategory struct {
 	ID         uint   `gorm:"primaryKey" json:"id"`