Deploy files from GitHub repository

controllers/academy_controller.go

@@ -0,0 +1,81 @@
+package controllers
+
+import (
+	"abdanhafidz.com/go-boilerplate/models/dto"
+	"abdanhafidz.com/go-boilerplate/services"
+
+	"github.com/gin-gonic/gin"
+	"github.com/google/uuid"
+)
+
+type AcademyController interface {
+	CreateAcademy(ctx *gin.Context)
+	GetAcademy(ctx *gin.Context)
+	GetAcademyDetail(ctx *gin.Context)
+	ListAcademies(ctx *gin.Context)
+	UpdateAcademy(ctx *gin.Context)
+	DeleteAcademy(ctx *gin.Context)
+
+	CreateMaterial(ctx *gin.Context)
+	CreateContent(ctx *gin.Context)
+}
+
+type academyController struct {
+	academyService services.AcademyService
+}
+
+func NewAcademyController(academyService services.AcademyService) AcademyController {
+	return &academyController{academyService}
+}
+
+func (c *academyController) CreateAcademy(ctx *gin.Context) {
+	req := RequestJSON[dto.CreateAcademyRequest](ctx)
+
+	res, err := c.academyService.CreateAcademy(ctx.Request.Context(), req)
+	ResponseJSON(ctx, req, res, err)
+}
+
+func (c *academyController) GetAcademy(ctx *gin.Context) {
+	id, _ := uuid.Parse(ctx.Param("id"))
+	res, err := c.academyService.GetAcademy(ctx.Request.Context(), id)
+	ResponseJSON(ctx, gin.H{"id": id}, res, err)
+}
+
+func (c *academyController) GetAcademyDetail(ctx *gin.Context) {
+	id, _ := uuid.Parse(ctx.Param("id"))
+	res, err := c.academyService.GetAcademyDetail(ctx.Request.Context(), id)
+	ResponseJSON(ctx, gin.H{"id": id}, res, err)
+}
+
+func (c *academyController) ListAcademies(ctx *gin.Context) {
+	res, err := c.academyService.ListAcademies(ctx.Request.Context())
+	ResponseJSON(ctx, gin.H{}, res, err)
+}
+
+func (c *academyController) UpdateAcademy(ctx *gin.Context) {
+	id, _ := uuid.Parse(ctx.Param("id"))
+	req := RequestJSON[dto.UpdateAcademyRequest](ctx)
+	res, err := c.academyService.UpdateAcademy(ctx.Request.Context(), id, req)
+	ResponseJSON(ctx, req, res, err)
+}
+
+func (c *academyController) DeleteAcademy(ctx *gin.Context) {
+	id, _ := uuid.Parse(ctx.Param("id"))
+	err := c.academyService.DeleteAcademy(ctx.Request.Context(), id)
+
+	ResponseJSON(ctx, gin.H{"id": id}, gin.H{"deleted": true}, err)
+}
+
+func (c *academyController) CreateMaterial(ctx *gin.Context) {
+	req := RequestJSON[dto.CreateMaterialRequest](ctx)
+
+	res, err := c.academyService.CreateMaterial(ctx.Request.Context(), req)
+	ResponseJSON(ctx, req, res, err)
+}
+
+func (c *academyController) CreateContent(ctx *gin.Context) {
+	req := RequestJSON[dto.CreateContentRequest](ctx)
+
+	res, err := c.academyService.CreateContent(ctx.Request.Context(), req)
+	ResponseJSON(ctx, req, res, err)
+}

models/dto/academy_dto.go

@@ -0,0 +1,29 @@
+package dto
+
+import "github.com/google/uuid"
+
+type CreateAcademyRequest struct {
+	Title       string `json:"title" binding:"required"`
+	Slug        string `json:"slug"`
+	Description string `json:"description"`
+}
+
+type UpdateAcademyRequest struct {
+	Title       string `json:"title"`
+	Slug        string `json:"slug"`
+	Description string `json:"description"`
+}
+
+type CreateMaterialRequest struct {
+	AcademyId   uuid.UUID `json:"academy_id" binding:"required"`
+	Title       string    `json:"title" binding:"required"`
+	Slug        string    `json:"slug"`
+	Description string    `json:"description"`
+}
+
+type CreateContentRequest struct {
+	AcademyMaterialId uuid.UUID `json:"academy_material_id" binding:"required"`
+	Title             string    `json:"title" binding:"required"`
+	Contents          string    `json:"contents"`
+	Order             uint      `json:"order"`
+}

models/entity/entity.go

@@ -171,8 +171,8 @@ type Academy struct {
 }
 
 type AcademyMaterial struct {
-	ID          uuid.UUID `gorm:"primaryKey" json:"id"`
-	AcademyId   uint      `json:"academy_id"`
+	Id          uuid.UUID `gorm:"primaryKey" json:"id"`
+	AcademyId   uuid.UUID `json:"academy_id"`
 	Title       string    `json:"title"`
 	Slug        string    `json:"slug"`
 	Description string    `json:"description"`
@@ -182,25 +182,14 @@ type AcademyContent struct {
 	Id                uuid.UUID `gorm:"primaryKey" json:"id"`
 	Title             string    `json:"title"`
 	Order             uint      `json:"order"`
-	AcademyMaterialId uint      `json:"academy_material_id"`
+	AcademyMaterialId uuid.UUID `json:"academy_material_id"`
 	Contents          string    `json:"contents"`
 }
 
-type OptionCategory struct {
-	Id         uint   `gorm:"primaryKey" json:"id"`
-	OptionName string `json:"option_name"`
-	OptionSlug string `json:"option_slug"`
-}
-
-type OptionValues struct {
-	Id               uint   `gorm:"primaryKey" json:"id"`
-	OptionCategoryId uint   `json:"option_category_id"`
-	OptionValue      string `json:"option_value"`
-}
 type AcademyMaterialProgress struct {
 	Id                uuid.UUID `gorm:"primaryKey" json:"id"`
 	AccountId         uint      `json:"account_id"`
-	AcademyMaterialId uint      `json:"academy_material_id"`
+	AcademyMaterialId uuid.UUID `json:"academy_material_id"`
 	Progress          uint      `json:"progress"`
 }
 
@@ -210,6 +199,18 @@ type AcademyContentProgress struct {
 	AcademyId uuid.UUID `json:"academy_id"`
 }
 
+type OptionCategory struct {
+	Id         uint   `gorm:"primaryKey" json:"id"`
+	OptionName string `json:"option_name"`
+	OptionSlug string `json:"option_slug"`
+}
+
+type OptionValues struct {
+	Id               uint   `gorm:"primaryKey" json:"id"`
+	OptionCategoryId uint   `json:"option_category_id"`
+	OptionValue      string `json:"option_value"`
+}
+
 type RegionProvince struct {
 	Id   uint   `json:"id"`
 	Name string `json:"name"`

provider/controller_provider.go

@@ -12,6 +12,7 @@ type ControllerProvider interface {
 	ProvideForgotPasswordController() controllers.ForgotPasswordController
 	ProvideOptionController() controllers.OptionController
 	ProvideRegionController() controllers.RegionController
+	ProvideAcademyController() controllers.AcademyController
 }
 
 type controllerProvider struct {
@@ -22,6 +23,7 @@ type controllerProvider struct {
 	forgotPasswordController    controllers.ForgotPasswordController
 	optionController            controllers.OptionController
 	regionController            controllers.RegionController
+	academyController           controllers.AcademyController
 }
 
 func NewControllerProvider(servicesProvider ServicesProvider) ControllerProvider {
@@ -33,7 +35,7 @@ func NewControllerProvider(servicesProvider ServicesProvider) ControllerProvider
 	forgotPasswordController := controllers.NewForgotPasswordController(servicesProvider.ProvideForgotPasswordService())
 	optionController := controllers.NewOptionController(servicesProvider.ProvideOptionService())
 	regionController := controllers.NewRegionController(servicesProvider.ProvideRegionService())
-
+	academyController := controllers.NewAcademyController(servicesProvider.ProvideAcademyService())
 	return &controllerProvider{
 		accountDetailController:     accountDetailController,
 		authenticationController:    authenticationController,
@@ -42,6 +44,7 @@ func NewControllerProvider(servicesProvider ServicesProvider) ControllerProvider
 		forgotPasswordController:    forgotPasswordController,
 		optionController:            optionController,
 		regionController:            regionController,
+		academyController:           academyController,
 	}
 }
 
@@ -74,3 +77,7 @@ func (c *controllerProvider) ProvideOptionController() controllers.OptionControl
 func (c *controllerProvider) ProvideRegionController() controllers.RegionController {
 	return c.regionController
 }
+
+func (c *controllerProvider) ProvideAcademyController() controllers.AcademyController {
+	return c.academyController
+}

provider/repositories_provider.go

@@ -15,6 +15,7 @@ type RepositoriesProvider interface {
 	ProvideForgotPasswordRepository() repositories.ForgotPasswordRepository
 	ProvideOptionRepository() repositories.OptionRepository
 	ProvideRegionRepository() repositories.RegionRepository
+	ProvideAcademyRepository() repositories.AcademyRepository
 }
 
 type repositoriesProvider struct {
@@ -28,6 +29,7 @@ type repositoriesProvider struct {
 	forgotPasswordRepository    repositories.ForgotPasswordRepository
 	optionRepository            repositories.OptionRepository
 	regionRepository            repositories.RegionRepository
+	academyRepository           repositories.AcademyRepository
 }
 
 // NewRepositoriesProvider akan membuat semua repository dan inject konfigurasi database-nya.
@@ -45,8 +47,8 @@ func NewRepositoriesProvider(cfg ConfigProvider) RepositoriesProvider {
 	forgotPasswordRepo := repositories.NewForgotPasswordRepository(db)
 	optionRepo := repositories.NewOptionRepository(db)
 	regionRepo := repositories.NewRegionRepository(db)
+	academyRepo := repositories.NewAcademyRepository(db)
 
-	
 	return &repositoriesProvider{
 		accountRepository:           accountRepo,
 		accountDetailRepository:     accountDetailRepo,
@@ -58,6 +60,7 @@ func NewRepositoriesProvider(cfg ConfigProvider) RepositoriesProvider {
 		forgotPasswordRepository:    forgotPasswordRepo,
 		optionRepository:            optionRepo,
 		regionRepository:            regionRepo,
+		academyRepository:           academyRepo,
 	}
 }
 
@@ -102,3 +105,7 @@ func (r *repositoriesProvider) ProvideOptionRepository() repositories.OptionRepo
 func (r *repositoriesProvider) ProvideRegionRepository() repositories.RegionRepository {
 	return r.regionRepository
 }
+
+func (r *repositoriesProvider) ProvideAcademyRepository() repositories.AcademyRepository {
+	return r.academyRepository
+}

provider/services_provider.go

@@ -12,6 +12,7 @@ type ServicesProvider interface {
 	ProvideJWTService() services.JWTService
 	ProvideOptionService() services.OptionService
 	ProvideRegionService() services.RegionService
+	ProvideAcademyService() services.AcademyService
 }
 
 type servicesProvider struct {
@@ -22,6 +23,7 @@ type servicesProvider struct {
 	jwtService               services.JWTService
 	optionService            services.OptionService
 	regionService            services.RegionService
+	academyService           services.AcademyService
 }
 
 // Konstruktor utama yang menginisialisasi semua service
@@ -33,6 +35,7 @@ func NewServicesProvider(repoProvider RepositoriesProvider, configProvider Confi
 	forgotPasswordService := services.NewForgotPasswordService(jwtService, repoProvider.ProvideAccountRepository(), repoProvider.ProvideForgotPasswordRepository())
 	optionService := services.NewOptionService(repoProvider.ProvideOptionRepository())
 	regionService := services.NewRegionService(repoProvider.ProvideRegionRepository())
+	academyService := services.NewAcademyService(repoProvider.ProvideAcademyRepository())
 	return &servicesProvider{
 		accountService:           accountService,
 		emailVerificationService: emailVerificationService,
@@ -41,6 +44,7 @@ func NewServicesProvider(repoProvider RepositoriesProvider, configProvider Confi
 		jwtService:               jwtService,
 		optionService:            optionService,
 		regionService:            regionService,
+		academyService:           academyService,
 	}
 }
 
@@ -72,3 +76,7 @@ func (s *servicesProvider) ProvideOptionService() services.OptionService {
 func (s *servicesProvider) ProvideRegionService() services.RegionService {
 	return s.regionService
 }
+
+func (s *servicesProvider) ProvideAcademyService() services.AcademyService {
+	return s.academyService
+}

repositories/academy_repository.go

@@ -17,207 +17,169 @@ type AcademyRepository interface {
 	UpdateAcademy(ctx context.Context, a entity.Academy) (entity.Academy, error)
 	DeleteAcademy(ctx context.Context, id uuid.UUID) error
 
+	GetAcademyWithMaterials(ctx context.Context, id uuid.UUID) (entity.Academy, []entity.AcademyMaterial, error)
+
 	// Material
 	CreateMaterial(ctx context.Context, m entity.AcademyMaterial) (entity.AcademyMaterial, error)
 	GetMaterialByID(ctx context.Context, id uuid.UUID) (entity.AcademyMaterial, error)
 	GetMaterialBySlug(ctx context.Context, slug string) (entity.AcademyMaterial, error)
-	ListMaterialsByAcademyID(ctx context.Context, academyId uint) ([]entity.AcademyMaterial, error)
+	ListMaterialsByAcademyID(ctx context.Context, academyId uuid.UUID) ([]entity.AcademyMaterial, error)
 	UpdateMaterial(ctx context.Context, m entity.AcademyMaterial) (entity.AcademyMaterial, error)
 	DeleteMaterial(ctx context.Context, id uuid.UUID) error
 
+	GetMaterialWithContents(ctx context.Context, id uuid.UUID) (entity.AcademyMaterial, []entity.AcademyContent, error)
+
 	// Content
 	CreateContent(ctx context.Context, c entity.AcademyContent) (entity.AcademyContent, error)
 	GetContentByID(ctx context.Context, id uuid.UUID) (entity.AcademyContent, error)
-	ListContentsByMaterialID(ctx context.Context, materialId uint) ([]entity.AcademyContent, error)
+	ListContentsByMaterialID(ctx context.Context, materialId uuid.UUID) ([]entity.AcademyContent, error)
 	UpdateContent(ctx context.Context, c entity.AcademyContent) (entity.AcademyContent, error)
 	DeleteContent(ctx context.Context, id uuid.UUID) error
 
 	// Progress
 	UpsertMaterialProgress(ctx context.Context, p entity.AcademyMaterialProgress) (entity.AcademyMaterialProgress, error)
-	GetMaterialProgress(ctx context.Context, accountId uint, materialId uint) (entity.AcademyMaterialProgress, error)
+	GetMaterialProgress(ctx context.Context, accountId uuid.UUID, materialId uuid.UUID) (entity.AcademyMaterialProgress, error)
 
 	UpsertContentProgress(ctx context.Context, p entity.AcademyContentProgress) (entity.AcademyContentProgress, error)
 	GetContentProgress(ctx context.Context, accountId uuid.UUID, academyId uuid.UUID) (entity.AcademyContentProgress, error)
 }
 
-type academyRepository struct {
-	db *gorm.DB
-}
+type academyRepository struct{ db *gorm.DB }
 
 func NewAcademyRepository(db *gorm.DB) AcademyRepository {
 	return &academyRepository{db: db}
 }
 
-// Academy
+// ========== ACADEMY ==========
 func (r *academyRepository) CreateAcademy(ctx context.Context, a entity.Academy) (entity.Academy, error) {
-	if err := r.db.WithContext(ctx).Create(&a).Error; err != nil {
-		return entity.Academy{}, err
-	}
-	return a, nil
+	return a, r.db.WithContext(ctx).Create(&a).Error
 }
 
 func (r *academyRepository) GetAcademyByID(ctx context.Context, id uuid.UUID) (entity.Academy, error) {
 	var a entity.Academy
-	if err := r.db.WithContext(ctx).First(&a, "id = ?", id).Error; err != nil {
-		return entity.Academy{}, err
-	}
-	return a, nil
+	return a, r.db.WithContext(ctx).First(&a, "id = ?", id).Error
 }
 
 func (r *academyRepository) GetAcademyBySlug(ctx context.Context, slug string) (entity.Academy, error) {
 	var a entity.Academy
-	if err := r.db.WithContext(ctx).First(&a, "slug = ?", slug).Error; err != nil {
-		return entity.Academy{}, err
-	}
-	return a, nil
+	return a, r.db.WithContext(ctx).First(&a, "slug = ?", slug).Error
 }
 
 func (r *academyRepository) ListAcademy(ctx context.Context) ([]entity.Academy, error) {
 	var list []entity.Academy
-	if err := r.db.WithContext(ctx).Find(&list).Error; err != nil {
-		return nil, err
-	}
-	return list, nil
+	return list, r.db.WithContext(ctx).Find(&list).Error
 }
 
 func (r *academyRepository) UpdateAcademy(ctx context.Context, a entity.Academy) (entity.Academy, error) {
-	if err := r.db.WithContext(ctx).Save(&a).Error; err != nil {
-		return entity.Academy{}, err
-	}
-	return a, nil
+	return a, r.db.WithContext(ctx).Save(&a).Error
 }
 
 func (r *academyRepository) DeleteAcademy(ctx context.Context, id uuid.UUID) error {
 	return r.db.WithContext(ctx).Delete(&entity.Academy{}, "id = ?", id).Error
 }
 
-// Material
-func (r *academyRepository) CreateMaterial(ctx context.Context, m entity.AcademyMaterial) (entity.AcademyMaterial, error) {
-	if err := r.db.WithContext(ctx).Create(&m).Error; err != nil {
-		return entity.AcademyMaterial{}, err
+func (r *academyRepository) GetAcademyWithMaterials(ctx context.Context, id uuid.UUID) (entity.Academy, []entity.AcademyMaterial, error) {
+	var a entity.Academy
+	err := r.db.WithContext(ctx).First(&a, "id = ?", id).Error
+	if err != nil {
+		return entity.Academy{}, nil, err
 	}
-	return m, nil
+
+	var m []entity.AcademyMaterial
+	return a, m, r.db.WithContext(ctx).Where("academy_id = ?", id).Find(&m).Error
+}
+
+// ========== MATERIAL ==========
+func (r *academyRepository) CreateMaterial(ctx context.Context, m entity.AcademyMaterial) (entity.AcademyMaterial, error) {
+	return m, r.db.WithContext(ctx).Create(&m).Error
 }
 
 func (r *academyRepository) GetMaterialByID(ctx context.Context, id uuid.UUID) (entity.AcademyMaterial, error) {
 	var m entity.AcademyMaterial
-	if err := r.db.WithContext(ctx).First(&m, "id = ?", id).Error; err != nil {
-		return entity.AcademyMaterial{}, err
-	}
-	return m, nil
+	return m, r.db.WithContext(ctx).First(&m, "id = ?", id).Error
 }
 
 func (r *academyRepository) GetMaterialBySlug(ctx context.Context, slug string) (entity.AcademyMaterial, error) {
 	var m entity.AcademyMaterial
-	if err := r.db.WithContext(ctx).First(&m, "slug = ?", slug).Error; err != nil {
-		return entity.AcademyMaterial{}, err
-	}
-	return m, nil
+	return m, r.db.WithContext(ctx).First(&m, "slug = ?", slug).Error
 }
 
-func (r *academyRepository) ListMaterialsByAcademyID(ctx context.Context, academyId uint) ([]entity.AcademyMaterial, error) {
+func (r *academyRepository) ListMaterialsByAcademyID(ctx context.Context, academyId uuid.UUID) ([]entity.AcademyMaterial, error) {
 	var list []entity.AcademyMaterial
-	if err := r.db.WithContext(ctx).Where("academy_id = ?", academyId).Find(&list).Error; err != nil {
-		return nil, err
-	}
-	return list, nil
+	return list, r.db.WithContext(ctx).Where("academy_id = ?", academyId).Find(&list).Error
 }
 
 func (r *academyRepository) UpdateMaterial(ctx context.Context, m entity.AcademyMaterial) (entity.AcademyMaterial, error) {
-	if err := r.db.WithContext(ctx).Save(&m).Error; err != nil {
-		return entity.AcademyMaterial{}, err
-	}
-	return m, nil
+	return m, r.db.WithContext(ctx).Save(&m).Error
 }
 
 func (r *academyRepository) DeleteMaterial(ctx context.Context, id uuid.UUID) error {
 	return r.db.WithContext(ctx).Delete(&entity.AcademyMaterial{}, "id = ?", id).Error
 }
 
-// Content
-func (r *academyRepository) CreateContent(ctx context.Context, c entity.AcademyContent) (entity.AcademyContent, error) {
-	if err := r.db.WithContext(ctx).Create(&c).Error; err != nil {
-		return entity.AcademyContent{}, err
+func (r *academyRepository) GetMaterialWithContents(ctx context.Context, id uuid.UUID) (entity.AcademyMaterial, []entity.AcademyContent, error) {
+	var m entity.AcademyMaterial
+	err := r.db.WithContext(ctx).First(&m, "id = ?", id).Error
+	if err != nil {
+		return entity.AcademyMaterial{}, nil, err
 	}
-	return c, nil
+
+	var c []entity.AcademyContent
+	return m, c, r.db.WithContext(ctx).Where("academy_material_id = ?", id).Order("order asc").Find(&c).Error
+}
+
+// ========== CONTENT ==========
+func (r *academyRepository) CreateContent(ctx context.Context, c entity.AcademyContent) (entity.AcademyContent, error) {
+	return c, r.db.WithContext(ctx).Create(&c).Error
 }
 
 func (r *academyRepository) GetContentByID(ctx context.Context, id uuid.UUID) (entity.AcademyContent, error) {
 	var c entity.AcademyContent
-	if err := r.db.WithContext(ctx).First(&c, "id = ?", id).Error; err != nil {
-		return entity.AcademyContent{}, err
-	}
-	return c, nil
+	return c, r.db.WithContext(ctx).First(&c, "id = ?", id).Error
 }
 
-func (r *academyRepository) ListContentsByMaterialID(ctx context.Context, materialId uint) ([]entity.AcademyContent, error) {
+func (r *academyRepository) ListContentsByMaterialID(ctx context.Context, materialId uuid.UUID) ([]entity.AcademyContent, error) {
 	var list []entity.AcademyContent
-	if err := r.db.WithContext(ctx).Where("academy_material_id = ?", materialId).Order("order ASC").Find(&list).Error; err != nil {
-		return nil, err
-	}
-	return list, nil
+	return list, r.db.WithContext(ctx).Where("academy_material_id = ?", materialId).Order("order asc").Find(&list).Error
 }
 
 func (r *academyRepository) UpdateContent(ctx context.Context, c entity.AcademyContent) (entity.AcademyContent, error) {
-	if err := r.db.WithContext(ctx).Save(&c).Error; err != nil {
-		return entity.AcademyContent{}, err
-	}
-	return c, nil
+	return c, r.db.WithContext(ctx).Save(&c).Error
 }
 
 func (r *academyRepository) DeleteContent(ctx context.Context, id uuid.UUID) error {
 	return r.db.WithContext(ctx).Delete(&entity.AcademyContent{}, "id = ?", id).Error
 }
 
-// Progress
+// ========== PROGRESS ==========
 func (r *academyRepository) UpsertMaterialProgress(ctx context.Context, p entity.AcademyMaterialProgress) (entity.AcademyMaterialProgress, error) {
 	var existing entity.AcademyMaterialProgress
 	err := r.db.WithContext(ctx).First(&existing, "account_id = ? AND academy_material_id = ?", p.AccountId, p.AcademyMaterialId).Error
-	if err != nil {
-		if err == gorm.ErrRecordNotFound {
-			if err := r.db.WithContext(ctx).Create(&p).Error; err != nil {
-				return entity.AcademyMaterialProgress{}, err
-			}
-			return p, nil
-		}
-		return entity.AcademyMaterialProgress{}, err
-	}
-	if err := r.db.WithContext(ctx).Model(&existing).Updates(p).Error; err != nil {
-		return entity.AcademyMaterialProgress{}, err
+
+	if err == gorm.ErrRecordNotFound {
+		return p, r.db.WithContext(ctx).Create(&p).Error
 	}
-	return existing, nil
+
+	return p, r.db.WithContext(ctx).Model(&existing).Updates(p).Error
 }
 
-func (r *academyRepository) GetMaterialProgress(ctx context.Context, accountId uint, materialId uint) (entity.AcademyMaterialProgress, error) {
-	var res entity.AcademyMaterialProgress
-	if err := r.db.WithContext(ctx).First(&res, "account_id = ? AND academy_material_id = ?", accountId, materialId).Error; err != nil {
-		return entity.AcademyMaterialProgress{}, err
-	}
-	return res, nil
+func (r *academyRepository) GetMaterialProgress(ctx context.Context, accountId uuid.UUID, materialId uuid.UUID) (entity.AcademyMaterialProgress, error) {
+	var p entity.AcademyMaterialProgress
+	return p, r.db.WithContext(ctx).First(&p, "account_id = ? AND academy_material_id = ?", accountId, materialId).Error
 }
 
 func (r *academyRepository) UpsertContentProgress(ctx context.Context, p entity.AcademyContentProgress) (entity.AcademyContentProgress, error) {
 	var existing entity.AcademyContentProgress
 	err := r.db.WithContext(ctx).First(&existing, "account_id = ? AND academy_id = ?", p.AccountId, p.AcademyId).Error
-	if err != nil {
-		if err == gorm.ErrRecordNotFound {
-			if err := r.db.WithContext(ctx).Create(&p).Error; err != nil {
-				return entity.AcademyContentProgress{}, err
-			}
-			return p, nil
-		}
-		return entity.AcademyContentProgress{}, err
-	}
-	if err := r.db.WithContext(ctx).Model(&existing).Updates(p).Error; err != nil {
-		return entity.AcademyContentProgress{}, err
+
+	if err == gorm.ErrRecordNotFound {
+		return p, r.db.WithContext(ctx).Create(&p).Error
 	}
-	return existing, nil
+
+	return p, r.db.WithContext(ctx).Model(&existing).Updates(p).Error
 }
 
 func (r *academyRepository) GetContentProgress(ctx context.Context, accountId uuid.UUID, academyId uuid.UUID) (entity.AcademyContentProgress, error) {
-	var res entity.AcademyContentProgress
-	if err := r.db.WithContext(ctx).First(&res, "account_id = ? AND academy_id = ?", accountId, academyId).Error; err != nil {
-		return entity.AcademyContentProgress{}, err
-	}
-	return res, nil
+	var p entity.AcademyContentProgress
+	return p, r.db.WithContext(ctx).First(&p, "account_id = ? AND academy_id = ?", accountId, academyId).Error
 }

router/academy_router.go

@@ -0,0 +1,23 @@
+package router
+
+import (
+	"abdanhafidz.com/go-boilerplate/provider"
+	"github.com/gin-gonic/gin"
+)
+
+func AcademyRouter(router *gin.Engine, middleware provider.MiddlewareProvider, controller provider.ControllerProvider) {
+	academyController := controller.ProvideAcademyController()
+	authenticationMiddleware := middleware.ProvideAuthenticationMiddleware()
+	routerGroup := router.Group("/api/v1/academies")
+	{
+
+		routerGroup.GET("/", academyController.ListAcademies)
+		routerGroup.POST("/", authenticationMiddleware.VerifyAccount, academyController.CreateAcademy)
+		routerGroup.PUT("/:id", authenticationMiddleware.VerifyAccount, academyController.UpdateAcademy)
+		routerGroup.DELETE("/:id", authenticationMiddleware.VerifyAccount, academyController.DeleteAcademy)
+		routerGroup.GET("/:id", academyController.GetAcademy)
+		routerGroup.GET("/:id/detail", academyController.GetAcademyDetail)
+		routerGroup.POST("/materials", authenticationMiddleware.VerifyAccount, academyController.CreateMaterial)
+		routerGroup.POST("/contents", authenticationMiddleware.VerifyAccount, academyController.CreateContent)
+	}
+}

router/email_router.go

@@ -5,7 +5,7 @@ import (
 	"github.com/gin-gonic/gin"
 )
 
-func EmailVerificationRoute(router *gin.Engine, controller provider.ControllerProvider) {
+func EmailVerificationRouter(router *gin.Engine, controller provider.ControllerProvider) {
 	emailVerificationController := controller.ProvideEmailVerificationController()
 	routerGroup := router.Group("/api/v1/email")
 	{

router/router.go

@@ -8,8 +8,9 @@ func RunRouter(appProvider provider.AppProvider) {
 	router, controller, config, middleware := appProvider.ProvideRouter(), appProvider.ProvideControllers(), appProvider.ProvideConfig(), appProvider.ProvideMiddlewares()
 	AuthenticationRouter(router, middleware, controller)
 	AccountDetailRouter(router, middleware, controller)
-	EmailVerificationRoute(router, controller)
+	EmailVerificationRouter(router, controller)
 	EventRouter(router, middleware, controller)
 	OptionsRouter(router, controller)
+	AcademyRouter(router, middleware, controller)
 	router.Run(config.ProvideEnvConfig().GetTCPAddress())
 }

services/academy_service.go

@@ -0,0 +1,166 @@
+package services
+
+import (
+	"context"
+	"errors"
+	"strings"
+
+	"abdanhafidz.com/go-boilerplate/models/dto"
+	entity "abdanhafidz.com/go-boilerplate/models/entity"
+	"abdanhafidz.com/go-boilerplate/repositories"
+	"github.com/google/uuid"
+	"github.com/gosimple/slug"
+)
+
+type AcademyService interface {
+	// Academy
+	CreateAcademy(ctx context.Context, req dto.CreateAcademyRequest) (entity.Academy, error)
+	GetAcademy(ctx context.Context, id uuid.UUID) (entity.Academy, error)
+	ListAcademies(ctx context.Context) ([]entity.Academy, error)
+	GetAcademyDetail(ctx context.Context, id uuid.UUID) (entity.Academy, error)
+	UpdateAcademy(ctx context.Context, id uuid.UUID, req dto.UpdateAcademyRequest) (entity.Academy, error)
+	DeleteAcademy(ctx context.Context, id uuid.UUID) error
+
+	// Material
+	CreateMaterial(ctx context.Context, req dto.CreateMaterialRequest) (entity.AcademyMaterial, error)
+
+	// Content
+	CreateContent(ctx context.Context, req dto.CreateContentRequest) (entity.AcademyContent, error)
+}
+type academyService struct {
+	repo repositories.AcademyRepository
+}
+
+func NewAcademyService(repo repositories.AcademyRepository) AcademyService {
+	return &academyService{repo: repo}
+}
+
+//
+// ===== Academy =====
+//
+
+func (s *academyService) CreateAcademy(ctx context.Context, req dto.CreateAcademyRequest) (entity.Academy, error) {
+	if strings.TrimSpace(req.Title) == "" {
+		return entity.Academy{}, errors.New("title required")
+	}
+
+	slugVal := req.Slug
+	if slugVal == "" {
+		slugVal = slug.Make(req.Title)
+	}
+
+	if _, err := s.repo.GetAcademyBySlug(ctx, slugVal); err == nil {
+		return entity.Academy{}, errors.New("slug already exists")
+	}
+
+	a := entity.Academy{
+		Title:       req.Title,
+		Slug:        slugVal,
+		Description: req.Description,
+	}
+
+	return s.repo.CreateAcademy(ctx, a)
+}
+
+func (s *academyService) GetAcademy(ctx context.Context, id uuid.UUID) (entity.Academy, error) {
+	return s.repo.GetAcademyByID(ctx, id)
+}
+
+func (s *academyService) ListAcademies(ctx context.Context) ([]entity.Academy, error) {
+	return s.repo.ListAcademy(ctx)
+}
+
+func (s *academyService) GetAcademyDetail(ctx context.Context, id uuid.UUID) (entity.Academy, error) {
+	a, _, err := s.repo.GetAcademyWithMaterials(ctx, id)
+	return a, err
+}
+
+func (s *academyService) UpdateAcademy(ctx context.Context, id uuid.UUID, req dto.UpdateAcademyRequest) (entity.Academy, error) {
+	existing, err := s.repo.GetAcademyByID(ctx, id)
+	if err != nil {
+		return entity.Academy{}, errors.New("academy not found")
+	}
+
+	if req.Title != "" {
+		existing.Title = req.Title
+	}
+	if req.Description != "" {
+		existing.Description = req.Description
+	}
+
+	if req.Slug != "" {
+		existing.Slug = req.Slug
+	} else {
+		existing.Slug = slug.Make(existing.Title)
+	}
+
+	return s.repo.UpdateAcademy(ctx, existing)
+}
+
+func (s *academyService) DeleteAcademy(ctx context.Context, id uuid.UUID) error {
+	_, mats, err := s.repo.GetAcademyWithMaterials(ctx, id)
+	if err != nil {
+		return errors.New("academy not found")
+	}
+	if len(mats) > 0 {
+		return errors.New("cannot delete academy with materials")
+	}
+	return s.repo.DeleteAcademy(ctx, id)
+}
+
+//
+// ===== Material =====
+//
+
+func (s *academyService) CreateMaterial(ctx context.Context, req dto.CreateMaterialRequest) (entity.AcademyMaterial, error) {
+	if req.AcademyId == uuid.Nil {
+		return entity.AcademyMaterial{}, errors.New("academy_id required")
+	}
+	if _, err := s.repo.GetAcademyByID(ctx, req.AcademyId); err != nil {
+		return entity.AcademyMaterial{}, errors.New("academy not found")
+	}
+
+	slugVal := req.Slug
+	if slugVal == "" {
+		slugVal = slug.Make(req.Title)
+	}
+
+	m := entity.AcademyMaterial{
+		AcademyId:   req.AcademyId,
+		Title:       req.Title,
+		Slug:        slugVal,
+		Description: req.Description,
+	}
+
+	return s.repo.CreateMaterial(ctx, m)
+}
+
+//
+// ===== Content =====
+//
+
+func (s *academyService) CreateContent(ctx context.Context, req dto.CreateContentRequest) (entity.AcademyContent, error) {
+	if req.AcademyMaterialId == uuid.Nil {
+		return entity.AcademyContent{}, errors.New("academy_material_id required")
+	}
+
+	if _, err := s.repo.GetMaterialByID(ctx, req.AcademyMaterialId); err != nil {
+		return entity.AcademyContent{}, errors.New("material not found")
+	}
+
+	// auto order last++
+	list, _ := s.repo.ListContentsByMaterialID(ctx, req.AcademyMaterialId)
+	order := req.Order
+	if order == 0 {
+		order = uint(len(list) + 1)
+	}
+
+	c := entity.AcademyContent{
+		AcademyMaterialId: req.AcademyMaterialId,
+		Title:             req.Title,
+		Contents:          req.Contents,
+		Order:             order,
+	}
+
+	return s.repo.CreateContent(ctx, c)
+}

services/external_auth_service.go

@@ -2,10 +2,13 @@ package services
 
 import (
 	"context"
+	"errors"
 
 	"abdanhafidz.com/go-boilerplate/models/dto"
+	entity "abdanhafidz.com/go-boilerplate/models/entity"
 	"abdanhafidz.com/go-boilerplate/repositories"
 	"google.golang.org/api/idtoken"
+	"gorm.io/gorm"
 )
 
 type ExternalAuthService interface {
@@ -14,36 +17,36 @@ type ExternalAuthService interface {
 
 type externalAuthService struct {
 	jwtService       JWTService
-	accountRepo      repositories.AccountRepository
+	accountService   AccountService
 	externalAuthRepo repositories.ExternalAuthRepository
 }
 
-func NewExternalAuthService(jwtService JWTService, accountRepo repositories.AccountRepository, externalAuthRepo repositories.ExternalAuthRepository) ExternalAuthService {
+func NewExternalAuthService(jwtService JWTService, accountService AccountService, externalAuthRepo repositories.ExternalAuthRepository) ExternalAuthService {
 	return &externalAuthService{
 		jwtService:       jwtService,
-		accountRepo:      accountRepo,
+		accountService:   accountService,
 		externalAuthRepo: externalAuthRepo,
 	}
 }
 
 func (s *externalAuthService) GoogleAuth(ctx context.Context, idToken string) (dto.AuthenticatedUser, error) {
-	_, err := s.externalAuthRepo.GetByOauthId(ctx, idToken)
-
-	if err != nil {
-		return dto.AuthenticatedUser{}, err
-	}
-
-	payload, err := idtoken.Validate(context.Background(), idToken, "")
 
-	if err != nil {
-		return dto.AuthenticatedUser{}, err
-	}
+	var (
+		acc    entity.Account
+		errAcc error
+	)
+	_, err := s.externalAuthRepo.GetByOauthId(ctx, idToken)
+	payload, _ := idtoken.Validate(context.Background(), idToken, "")
 
+	name := payload.Claims["name"].(string)
 	email := payload.Claims["email"].(string)
+	password := payload.Claims["sub"].(string)
 
-	acc, err := s.accountRepo.GetAccountByEmail(ctx, email)
+	if errors.Is(err, gorm.ErrRecordNotFound) {
+		acc, errAcc = s.accountService.Create(ctx, name, email, name, password)
+	}
 
-	if err != nil {
+	if errAcc != nil {
 		return dto.AuthenticatedUser{}, err
 	}