Deploy files from GitHub repository

.gitignore

@@ -1,2 +1,2 @@
-/.env
+.env
 go-boilerplate.exe

controllers/academy_controller.go

@@ -8,6 +8,7 @@ import (
 	entity "abdanhafidz.com/go-boilerplate/models/entity"
 	http_error "abdanhafidz.com/go-boilerplate/models/error"
 	"abdanhafidz.com/go-boilerplate/services"
+	"abdanhafidz.com/go-boilerplate/utils"
 	"github.com/gin-gonic/gin"
 	"github.com/google/uuid"
 )
@@ -86,6 +87,13 @@ func (c *academyController) ListAcademy(ctx *gin.Context) {
 	search := ctx.DefaultQuery("search", "")
 	sortBy := ctx.DefaultQuery("sortBy", "")
 	order := ctx.DefaultQuery("order", "")
+
+	var registerStatus *int
+	if val := ctx.Query("registerStatus"); val != "" {
+		if i, err := strconv.Atoi(val); err == nil {
+			registerStatus = &i
+		}
+	}
 	isModified := false
 
 	if limit < 1 {
@@ -101,8 +109,15 @@ func (c *academyController) ListAcademy(ctx *gin.Context) {
 		isModified = true
 	}
 
+	var status *string
+	if val := ctx.Query("status"); val != "" {
+		if val == entity.StatusNotStarted || val == entity.StatusInProgress || val == entity.StatusFinished {
+			status = &val
+		}
+	}
+
 	offset := (page - 1) * limit
-	p := entity.Pagination{Limit: limit, Offset: offset, Search: search, SortBy: sortBy, Order: order}
+	p := entity.Pagination{Limit: limit, Offset: offset, Search: search, SortBy: sortBy, Order: order, RegisterStatus: registerStatus, Status: status}
 	list, total, err := c.academyService.ListAcademy(ctx.Request.Context(), accountId, p)
 
 	if err != nil {
@@ -274,6 +289,10 @@ func (c *academyController) UpdateContentProgress(ctx *gin.Context) {
 
 func (c *academyController) JoinAcademyByCode(ctx *gin.Context) {
 	req := RequestJSON[dto.JoinAcademyByCodeRequest](ctx)
+	if err := utils.ValidateCode(req.Code); err != nil {
+		ResponseJSON[any, any](ctx, req, nil, http_error.INVALID_CODE)
+		return
+	}
 	accountId := ParseAccountId(ctx)
 	res, err := c.academyService.JoinByCode(ctx.Request.Context(), accountId, req.Code)
 	ResponseJSON(ctx, req, res, err)

controllers/event_controller.go

@@ -7,6 +7,7 @@ import (
 	entity "abdanhafidz.com/go-boilerplate/models/entity"
 	http_error "abdanhafidz.com/go-boilerplate/models/error"
 	"abdanhafidz.com/go-boilerplate/services"
+	"abdanhafidz.com/go-boilerplate/utils"
 	"github.com/gin-gonic/gin"
 	"github.com/google/uuid"
 )
@@ -34,6 +35,20 @@ func (c *eventController) List(ctx *gin.Context) {
 	search := ctx.DefaultQuery("search", "")
 	sortBy := ctx.DefaultQuery("sortBy", "")
 	order := ctx.DefaultQuery("order", "")
+
+	var registerStatus *int
+	if val := ctx.Query("registerStatus"); val != "" {
+		if i, err := strconv.Atoi(val); err == nil {
+			registerStatus = &i
+		}
+	}
+
+	var status *string
+	if val := ctx.Query("status"); val != "" {
+		if val == entity.EventStatusUpcoming || val == entity.EventStatusOngoing || val == entity.EventStatusEnded {
+			status = &val
+		}
+	}
 	if limit < 1 {
 		limit = 10
 	} else if limit > 50 {
@@ -43,7 +58,7 @@ func (c *eventController) List(ctx *gin.Context) {
 		page = 1
 	}
 	offset := (page - 1) * limit
-	p := entity.Pagination{Limit: limit, Offset: offset, Search: search, SortBy: sortBy, Order: order}
+	p := entity.Pagination{Limit: limit, Offset: offset, Search: search, SortBy: sortBy, Order: order, RegisterStatus: registerStatus, Status: status}
 	accountId := ParseAccountId(ctx)
 	list, total, err := c.eventService.List(ctx.Request.Context(), accountId, p)
 	var totalPages int
@@ -75,9 +90,13 @@ func (c *eventController) DetailBySlug(ctx *gin.Context) {
 
 func (c *eventController) Join(ctx *gin.Context) {
 	req := RequestJSON[dto.JoinEventRequest](ctx)
+	if err := utils.ValidateCode(req.EventCode); err != nil {
+		ResponseJSON[any, any](ctx, req, nil, err)
+		return
+	}
 	accountId := ParseAccountId(ctx)
 	res, err := c.eventService.JoinByCode(ctx.Request.Context(), accountId, req.EventCode)
-	ResponseJSON(ctx, req, res, err)
+	ResponseJSON[any, any](ctx, req, res, err)
 }
 
 func (c *eventController) CreateEvent(ctx *gin.Context) {

models/entity/contant.go

@@ -1,17 +1,31 @@
 package models
 
+import (
+	"regexp"
+)
+
 const (
 	StatusNotStarted = "NOT_STARTED"
 	StatusInProgress = "IN_PROGRESS"
-	StatusFinished  = "FINISHED"
+	StatusFinished   = "FINISHED"
+)
+
+const (
+	EventStatusUpcoming = "UPCOMING"
+	EventStatusOngoing  = "ONGOING"
+	EventStatusEnded    = "ENDED"
 )
 
 const MB = 1024 * 1024
 
+var CodeRegex = regexp.MustCompile(`^[a-zA-Z0-9]{6,12}$`)
+
 type Pagination struct {
-    Limit  int
-    Offset int
-    Search string
-    SortBy string
-    Order  string
-}
+	Limit          int
+	Offset         int
+	Search         string
+	SortBy         string
+	Order          string
+	RegisterStatus *int
+	Status         *string
+}

models/entity/entity.go

@@ -86,6 +86,7 @@ type Events struct {
 	ImgBanner      string         `json:"img_banner,omitempty"`
 	EventCode      string         `json:"event_code,omitempty"`
 	IsPublic       bool           `json:"is_public,omitempty"`
+	CreatedAt      time.Time      `json:"created_at,omitempty"`
 	DeletedAt      gorm.DeletedAt `json:"deleted_at,omitempty" gorm:"index"`
 	RegisterStatus int            `gorm:"-" json:"register_status"`
 }
@@ -272,6 +273,7 @@ type Academy struct {
 	Materials       []AcademyMaterial `gorm:"foreignKey:AcademyId;references:Id" json:"materials,omitempty"`
 	AcademyProgress AcademyProgress   `gorm:"foreignKey:AcademyId;references:Id" json:"academy_progress,omitempty"`
 	RegisterStatus  int               `gorm:"-" json:"register_status"`
+	CreatedAt       time.Time         `json:"created_at,omitempty"`
 	DeletedAt       gorm.DeletedAt    `json:"deleted_at,omitempty" gorm:"index"`
 }
 
@@ -287,6 +289,7 @@ type AcademyMaterial struct {
 	ContentsCount           int64                   `json:"contents_count,omitempty"`
 	Contents                []AcademyContent        `gorm:"foreignKey:MaterialId;references:Id" json:"contents,omitempty"`
 	AcademyMaterialProgress AcademyMaterialProgress `gorm:"foreignKey:MaterialId;references:Id" json:"academy_material_progress,omitempty"`
+	CreatedAt               time.Time               `json:"created_at,omitempty"`
 	DeletedAt               gorm.DeletedAt          `json:"deleted_at,omitempty" gorm:"index"`
 }
 
@@ -299,6 +302,7 @@ type AcademyContent struct {
 	Order                  uint                   `json:"order,omitempty"`
 	Contents               string                 `json:"contents,omitempty"`
 	AcademyContentProgress AcademyContentProgress `gorm:"foreignKey:ContentId;references:Id" json:"academy_content_progress,omitempty"`
+	CreatedAt              time.Time              `json:"created_at,omitempty"`
 	DeletedAt              gorm.DeletedAt         `json:"deleted_at,omitempty" gorm:"index"`
 }
 

models/error/error.go

@@ -36,7 +36,7 @@ var (
 	IMAGE_REQUIRED              = errors.New("Image is required")
 	DESCRIPTION_REQUIRED        = errors.New("Description is required")
 	CODE_REQUIRED               = errors.New("Code is required")
-	INVALID_CODE                = errors.New("Code is invalid, it must be 6 characters long and contain only letters or numbers")
+	INVALID_CODE                = errors.New("Code must be on range 6-12")
 	EVENT_START_DATE_INVALID    = errors.New("Event start date must be in the future")
 	EVENT_END_DATE_INVALID      = errors.New("Event end date must be after start date")
 	INVALID_DATE_FORMAT         = errors.New("Invalid date format, please use RFC3339")

repositories/academy_repository.go

@@ -159,36 +159,44 @@ func (r *academyRepository) ListVisibleAcademy(ctx context.Context, accountId uu
 
 	sub := r.db.WithContext(ctx).Model(&entity.AcademyAssign{}).Select("academy_id").Where("account_id = ?", accountId)
 
+	// Base query
 	q := r.db.WithContext(ctx).Model(&entity.Academy{}).
-		Where(r.db.Where("is_public = ?", true).Or("id IN (?)", sub))
+		Where(r.db.Where("academy.is_public = ?", true).Or("academy.id IN (?)", sub))
+
+	// Join for status filtering
+	if p != nil && p.Status != nil {
+		q = q.Joins("LEFT JOIN academy_progress ap ON ap.academy_id = academy.id AND ap.account_id = ?", accountId)
+		status := *p.Status
+		if status == entity.StatusNotStarted {
+			q = q.Where("ap.status IS NULL OR ap.status = ?", entity.StatusNotStarted)
+		} else {
+			q = q.Where("ap.status = ?", status)
+		}
+	}
 
 	if p != nil {
+		if p.RegisterStatus != nil {
+			switch *p.RegisterStatus {
+			case 1:
+				q = q.Where("academy.id IN (?)", sub)
+			case 0:
+				q = q.Where("academy.id NOT IN (?)", sub)
+			}
+		}
+
 		sortColumn := "title"
 		switch p.SortBy {
-			case "title":
-				sortColumn = "title"
-			case "slug":
-				sortColumn = "slug"
-			case "description":
-				sortColumn = "description"
-			case "createdAt", "created_at":
-				sortColumn = "created_at"
-			case "updatedAt", "updated_at":
-				sortColumn = "updated_at"
-			case "materials_count", "materialsCount":
-				sortColumn = "materials_count"
+		case "title":
+			sortColumn = "title"
+		case "createdAt", "created_at":
+			sortColumn = "created_at"
 		}
 
 		if s := strings.TrimSpace(p.Search); s != "" {
 			s = strings.Trim(s, "\"'")
 			s = strings.ToLower(s)
 			like := "%" + s + "%"
-
-			if p.SortBy != "" {
-				q = q.Where(fmt.Sprintf("LOWER(%s) LIKE ?", sortColumn), like)
-			} else {
-				q = q.Where("LOWER(title) LIKE ? OR LOWER(slug) LIKE ?", like, like)
-			}
+			q = q.Where("LOWER(academy.title) LIKE ? OR LOWER(academy.slug) LIKE ?", like, like)
 		}
 
 		sortDirection := "DESC"
@@ -196,8 +204,13 @@ func (r *academyRepository) ListVisibleAcademy(ctx context.Context, accountId uu
 			sortDirection = "ASC"
 		}
 
+		// Disambiguate sort column
 		q = q.Order(fmt.Sprintf("%s %s", sortColumn, sortDirection))
 
+		if err := q.Count(&total).Error; err != nil {
+			return nil, 0, err
+		}
+
 		if p.Limit > 0 {
 			q = q.Limit(p.Limit)
 		}
@@ -206,10 +219,6 @@ func (r *academyRepository) ListVisibleAcademy(ctx context.Context, accountId uu
 		}
 	}
 
-	if err := q.Count(&total).Error; err != nil {
-		return nil, 0, err
-	}
-
 	if err := q.Find(&list).Error; err != nil {
 		return nil, 0, err
 	}

repositories/event_repository.go

@@ -3,6 +3,7 @@ package repositories
 import (
 	"context"
 	"strings"
+	"time"
 
 	entity "abdanhafidz.com/go-boilerplate/models/entity"
 	"github.com/google/uuid"
@@ -87,10 +88,8 @@ func (r *eventsRepository) GetAllPaginate(ctx context.Context, p entity.Paginati
 		ord = "asc"
 	}
 	switch col {
-	case "title", "slug", "start_event", "end_event", "event_code", "overview", "is_public":
+	case "title", "start_event", "end_event", "overview", "is_public", "created_at":
 		q = q.Order(col + " " + ord)
-	case "id_event", "id":
-		q = q.Order("id " + ord)
 	default:
 		q = q.Order("title " + ord)
 	}
@@ -129,8 +128,10 @@ func (r *eventsRepository) ListPublic(ctx context.Context, p *entity.Pagination)
 			ord = "asc"
 		}
 		switch col {
-		case "title", "slug", "start_event", "end_event", "event_code", "overview", "is_public":
+		case "title", "slug", "start_event", "end_event", "event_code", "overview", "is_public", "created_at":
 			q = q.Order(col + " " + ord)
+		case "createdat":
+			q = q.Order("created_at " + ord)
 		case "id_event", "id":
 			q = q.Order("id " + ord)
 		default:
@@ -163,6 +164,27 @@ func (r *eventsRepository) ListVisible(ctx context.Context, accountId uuid.UUID,
 	}
 
 	if p != nil {
+		if p.RegisterStatus != nil {
+			switch *p.RegisterStatus {
+			case 1:
+				q = q.Where("academy.id IN (?)", sub)
+			case 0:
+				q = q.Where("academy.id NOT IN (?)", sub)
+			}
+		}
+
+		if p.Status != nil {
+			now := time.Now()
+			switch *p.Status {
+			case entity.EventStatusUpcoming:
+				q = q.Where("start_event > ?", now)
+			case entity.EventStatusOngoing:
+				q = q.Where("start_event <= ? AND end_event >= ?", now, now)
+			case entity.EventStatusEnded:
+				q = q.Where("end_event < ?", now)
+			}
+		}
+
 		if s := strings.TrimSpace(p.Search); s != "" {
 			s = strings.Trim(s, "\"'")
 			s = strings.ToLower(s)
@@ -182,23 +204,25 @@ func (r *eventsRepository) ListVisible(ctx context.Context, accountId uuid.UUID,
 			ord = "asc"
 		}
 		switch col {
-		case "title", "slug", "start_event", "end_event", "overview":
+		case "title", "slug", "start_event", "end_event", "overview", "created_at":
 			q = q.Order(col + " " + ord)
+		case "createdat":
+			q = q.Order("created_at " + ord)
 		case "id_event", "id":
 			q = q.Order("id " + ord)
 		default:
 			q = q.Order("title " + ord)
 		}
+		if err := q.Count(&total).Error; err != nil {
+			return nil, 0, err
+		}
+
 		if p.Limit > 0 {
 			q = q.Limit(p.Limit)
 		}
 		if p.Offset > 0 {
 			q = q.Offset(p.Offset)
 		}
-	} else {
-		if err := q.Count(&total).Error; err != nil {
-			return nil, 0, err
-		}
 	}
 
 	if err := q.Find(&list).Error; err != nil {

router/academy_router.go

@@ -9,34 +9,16 @@ import (
 func AcademyRouter(router *gin.Engine, middleware provider.MiddlewareProvider, controller provider.ControllerProvider) {
 	academyController := controller.ProvideAcademyController()
 	authenticationMiddleware := middleware.ProvideAuthenticationMiddleware()
-	authorizationMiddleware := middleware.ProvideAuthorizationMiddleware()
+
 	routerGroup := router.Group("/api/v1/academy")
 
 	routerGroup.Use(gzip.Gzip(gzip.DefaultCompression))
 	{
-		adminGroup := routerGroup.Group("/admin", authorizationMiddleware.VerifyAdmin)
-
-		adminGroup.POST("/", academyController.CreateAcademy)
-		adminGroup.GET("/id/:id/detail", academyController.GetAcademyDetail)
-		adminGroup.PUT("/id/:id", academyController.UpdateAcademy)
-		adminGroup.DELETE("/id/:id", academyController.DeleteAcademy)
-
-		adminGroup.POST("/materials", academyController.CreateMaterial)
-		adminGroup.DELETE("/materials/:id", academyController.DeleteMaterial)
-
-		adminGroup.POST("/contents", academyController.CreateContent)
-		adminGroup.DELETE("/contents/:id", academyController.DeleteContent)
-
-		adminGroup.POST("/assign", academyController.AssignAccountToAcademy)
-		adminGroup.DELETE("/assign/:id", academyController.UnassignAccountFromAcademy)
-		adminGroup.GET("/assign/:academy_id", academyController.ListAssignmentsByAcademy)
+		routerGroup.GET("/", authenticationMiddleware.VerifyAccount, academyController.ListAcademy)
+		routerGroup.POST("/join", authenticationMiddleware.VerifyAccount, academyController.JoinAcademyByCode)
+		routerGroup.GET("/:academy_slug", authenticationMiddleware.VerifyAccount, academyController.GetAcademy)
+		routerGroup.GET("/:academy_slug/:material_slug", authenticationMiddleware.VerifyAccount, academyController.GetMaterial)
+		routerGroup.GET("/:academy_slug/:material_slug/:order", authenticationMiddleware.VerifyAccount, academyController.GetContent)
+		routerGroup.POST("/:academy_slug/:material_slug/:order", authenticationMiddleware.VerifyAccount, academyController.UpdateContentProgress)
 	}
-
-	routerGroup.GET("/", authenticationMiddleware.VerifyAccount, academyController.ListAcademy)
-	routerGroup.POST("/join", authenticationMiddleware.VerifyAccount, academyController.JoinAcademyByCode)
-	routerGroup.GET("/:academy_slug", authenticationMiddleware.VerifyAccount, academyController.GetAcademy)
-	routerGroup.GET("/:academy_slug/:material_slug", authenticationMiddleware.VerifyAccount, academyController.GetMaterial)
-	routerGroup.GET("/:academy_slug/:material_slug/:order", authenticationMiddleware.VerifyAccount, academyController.GetContent)
-
-	routerGroup.POST("/:academy_slug/:material_slug/:order", authenticationMiddleware.VerifyAccount, academyController.UpdateContentProgress)
 }

router/admin_router.go

@@ -0,0 +1,48 @@
+package router
+
+import (
+	"abdanhafidz.com/go-boilerplate/provider"
+	"github.com/gin-gonic/gin"
+)
+
+func AdminRouter(router *gin.Engine, middleware provider.MiddlewareProvider, controller provider.ControllerProvider) {
+	authenticationMiddleware := middleware.ProvideAuthenticationMiddleware()
+	authorizationMiddleware := middleware.ProvideAuthorizationMiddleware()
+
+	eventController := controller.ProvideEventController()
+	academyController := controller.ProvideAcademyController()
+	authenticationController := controller.ProvideAuthenticationController()
+
+	// Event Admin Routes
+	eventAdminGroup := router.Group("api/v1/admin/events", authenticationMiddleware.VerifyAccount, authorizationMiddleware.VerifyAdmin)
+	{
+		eventAdminGroup.POST("/", eventController.CreateEvent)
+		eventAdminGroup.PUT("/:id", eventController.UpdateEvent)
+		eventAdminGroup.DELETE("/:id", eventController.DeleteEvent)
+	}
+
+	// Academy Admin Routes
+	academyAdminGroup := router.Group("/api/v1/admin/academy", authenticationMiddleware.VerifyAccount, authorizationMiddleware.VerifyAdmin)
+	{
+		academyAdminGroup.POST("/", academyController.CreateAcademy)
+		academyAdminGroup.GET("/id/:id/detail", academyController.GetAcademyDetail)
+		academyAdminGroup.PUT("/id/:id", academyController.UpdateAcademy)
+		academyAdminGroup.DELETE("/id/:id", academyController.DeleteAcademy)
+
+		academyAdminGroup.POST("/materials", academyController.CreateMaterial)
+		academyAdminGroup.DELETE("/materials/:id", academyController.DeleteMaterial)
+
+		academyAdminGroup.POST("/contents", academyController.CreateContent)
+		academyAdminGroup.DELETE("/contents/:id", academyController.DeleteContent)
+
+		academyAdminGroup.POST("/assign", academyController.AssignAccountToAcademy)
+		academyAdminGroup.DELETE("/assign/:id", academyController.UnassignAccountFromAcademy)
+		academyAdminGroup.GET("/assign/:academy_id", academyController.ListAssignmentsByAcademy)
+	}
+
+	// Authentication Admin Routes 
+	authAdminGroup := router.Group("/api/v1/admin/authentication", authenticationMiddleware.VerifyAccount, authorizationMiddleware.VerifySuperAdmin)
+	{
+		authAdminGroup.PUT("/:account_id/assign", authenticationController.UpdateUserRole)
+	}
+}

router/authentication_router.go

@@ -2,6 +2,7 @@ package router
 
 import (
 	"abdanhafidz.com/go-boilerplate/provider"
+	"github.com/gin-contrib/gzip"
 	"github.com/gin-gonic/gin"
 )
 
@@ -9,16 +10,12 @@ func AuthenticationRouter(router *gin.Engine, middleware provider.MiddlewareProv
 	routerGroup := router.Group("/api/v1/authentication")
 	authenticationController := controller.ProvideAuthenticationController()
 	authenticationmiddleware := middleware.ProvideAuthenticationMiddleware()
-	authorizationMiddleware := middleware.ProvideAuthorizationMiddleware()
+
+	routerGroup.Use(gzip.Gzip(gzip.DefaultCompression))
 	{
 		routerGroup.POST("/external-login", authenticationController.ExternalAuth)
 		routerGroup.POST("/login", authenticationController.SignIn)
 		routerGroup.POST("/register", authenticationController.SignUp)
 		routerGroup.PUT("/change-password", authenticationmiddleware.VerifyAccount, authenticationController.ChangePassword)
 	}
-
-	userGroup := router.Group("/api/v1/users")
-	{
-		userGroup.PUT("/:account_id/assign", authorizationMiddleware.VerifySuperAdmin, authenticationController.UpdateUserRole)
-	}
 }

router/event_router.go

@@ -2,22 +2,20 @@ package router
 
 import (
 	"abdanhafidz.com/go-boilerplate/provider"
+	"github.com/gin-contrib/gzip"
 	"github.com/gin-gonic/gin"
 )
 
 func EventRouter(router *gin.Engine, middleware provider.MiddlewareProvider, controller provider.ControllerProvider) {
 	eventController := controller.ProvideEventController()
 	authenticationMiddleware := middleware.ProvideAuthenticationMiddleware()
-	authorizationMiddleware := middleware.ProvideAuthorizationMiddleware()
+
 	routerGroup := router.Group("api/v1/events")
+
+	routerGroup.Use(gzip.Gzip(gzip.DefaultCompression))
 	{
 		routerGroup.GET("/", authenticationMiddleware.VerifyAccount, eventController.List)
 		routerGroup.GET("/:event_slug", authenticationMiddleware.VerifyAccount, eventController.DetailBySlug)
 		routerGroup.POST("/register-event", authenticationMiddleware.VerifyAccount, eventController.Join)
-
-		adminGroup := routerGroup.Group("/admin", authorizationMiddleware.VerifyAdmin)
-		adminGroup.POST("/", eventController.CreateEvent)
-		adminGroup.PUT("/:id", eventController.UpdateEvent)
-		adminGroup.DELETE("/:id", eventController.DeleteEvent)
 	}
 }

router/router.go

@@ -13,8 +13,9 @@ func RunRouter(appProvider provider.AppProvider) {
 	EventRouter(router, middleware, controller)
 	OptionsRouter(router, controller)
 	AcademyRouter(router, middleware, controller)
-    ExamEventRouter(router, middleware, controller)
-    AcademyExamRouter(router, middleware, controller)
-    UploadRouter(router,middleware, controller)
-    router.Run(config.ProvideEnvConfig().GetTCPAddress())
+	ExamEventRouter(router, middleware, controller)
+	AcademyExamRouter(router, middleware, controller)
+	UploadRouter(router, middleware, controller)
+	AdminRouter(router, middleware, controller)
+	router.Run(config.ProvideEnvConfig().GetTCPAddress())
 }

services/academy_service.go

@@ -79,13 +79,8 @@ func (s *academyService) CreateAcademy(ctx context.Context, req dto.CreateAcadem
 	if strings.TrimSpace(req.ImageUrl) == "" {
 		return entity.Academy{}, http_error.IMAGE_REQUIRED
 	}
-	if len(req.Code) != 6 {
-		return entity.Academy{}, http_error.INVALID_CODE
-	}
-	for i := 0; i < 6; i++ {
-		if !((req.Code[i] >= 'A' && req.Code[i] <= 'Z') || (req.Code[i] >= '0' && req.Code[i] <= '9')) {
-			return entity.Academy{}, http_error.INVALID_CODE
-		}
+	if err := utils.ValidateCode(req.Code); err != nil {
+		return entity.Academy{}, err
 	}
 
 	slugVal := req.Slug
@@ -824,15 +819,6 @@ func (s *academyService) ListAssignmentsByAcademy(ctx context.Context, academyId
 	return s.academyRepo.ListAssignmentsByAcademy(ctx, academyId)
 }
 func (s *academyService) JoinByCode(ctx context.Context, accountId uuid.UUID, code string) (entity.AcademyAssign, error) {
-	if len(code) != 6 {
-		return entity.AcademyAssign{}, http_error.BAD_REQUEST_ERROR
-	}
-	for i := 0; i < 6; i++ {
-		ch := code[i]
-		if !((ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9')) {
-			return entity.AcademyAssign{}, http_error.BAD_REQUEST_ERROR
-		}
-	}
 	ac, err := s.academyRepo.GetAcademyByCode(ctx, code)
 	if err != nil {
 		return entity.AcademyAssign{}, http_error.ACADEMY_NOT_FOUND

services/event_service.go

@@ -9,6 +9,7 @@ import (
 	entity "abdanhafidz.com/go-boilerplate/models/entity"
 	http_error "abdanhafidz.com/go-boilerplate/models/error"
 	"abdanhafidz.com/go-boilerplate/repositories"
+	"abdanhafidz.com/go-boilerplate/utils"
 	"github.com/google/uuid"
 )
 
@@ -104,7 +105,7 @@ func (s *eventService) GetStatus(ctx context.Context, slug string, accountId uui
 	event, err := s.DetailBySlug(ctx, slug, accountId)
 	currentTime := time.Now()
 	eventStatus.IsHasNotStarted = currentTime.Before(event.Data.StartEvent)
-	eventStatus.IsFinished = currentTime.Before(event.Data.EndEvent)
+	eventStatus.IsFinished = currentTime.After(event.Data.EndEvent)
 	eventStatus.IsOnGoing = !(eventStatus.IsHasNotStarted) && !(eventStatus.IsFinished)
 	return eventStatus, err
 }
@@ -125,14 +126,8 @@ func (s *eventService) CreateEvent(ctx context.Context, req dto.CreateEventReque
 		return entity.Events{}, http_error.INVALID_DATE_FORMAT
 	}
 
-	if len(req.EventCode) != 6 {
-		return entity.Events{}, http_error.INVALID_CODE
-	}
-	for i := 0; i < 6; i++ {
-		c := req.EventCode[i]
-		if !((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z') || (c >= '0' && c <= '9')) {
-			return entity.Events{}, http_error.INVALID_CODE
-		}
+	if err := utils.ValidateCode(req.EventCode); err != nil {
+		return entity.Events{}, err
 	}
 
 	slugVal := strings.ToLower(strings.ReplaceAll(req.Title, " ", "-"))

services/exam_event_service.go

@@ -125,13 +125,14 @@ func (s *examService) GetExamEventAttempt(ctx context.Context, eventSlug string,
 
 	examEventAttempt, err := s.examEventAttemptRepo.GetByExamEvent(ctx, ev.Data.Id, exam.Id, accountId)
 	fmt.Println("Error Exam Event Attempt", errors.Is(err, gorm.ErrRecordNotFound))
+	
 	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
 		return dto.UserExamStatus{}, entity.ExamEventAttempt{}, err
 	}
 
 	var attemptStatus dto.UserExamStatus
 	attemptStatus.IsNotAttempt = errors.Is(err, gorm.ErrRecordNotFound)
-	attemptStatus.IsTimeOut = (utils.CalculateRemainingTime(examEventAttempt.CreatedAt, examEventAttempt.DueAt) == 0) || false
+	attemptStatus.IsTimeOut = !attemptStatus.IsNotAttempt && (utils.CalculateRemainingTime(examEventAttempt.CreatedAt, examEventAttempt.DueAt) == 0)
 	attemptStatus.IsSubmitted = examEventAttempt.Submitted
 	attemptStatus.IsOnAttempt = !attemptStatus.IsNotAttempt && !attemptStatus.IsTimeOut && !attemptStatus.IsSubmitted
 	return attemptStatus, examEventAttempt, nil
@@ -235,7 +236,9 @@ func (s *examService) AttemptExamEvent(ctx context.Context, eventSlug string, ex
 		return entity.ExamEventAttempt{}, err
 	}
 	attemptStatus, examEventAttempt, err := s.GetExamEventAttempt(ctx, eventSlug, examSlug, accountId)
-
+	
+	fmt.Println("Get AttemptStatus = ", attemptStatus, "Err =", err)
+	
 	if err != nil {
 		return entity.ExamEventAttempt{}, err
 	}
@@ -246,10 +249,11 @@ func (s *examService) AttemptExamEvent(ctx context.Context, eventSlug string, ex
 	if err != nil {
 		return entity.ExamEventAttempt{}, err
 	}
+	
 	if attemptStatus.IsNotAttempt {
 
 		if eventStatus.IsFinished {
-			return entity.ExamEventAttempt{}, err.EVENT_FINISHED
+			return entity.ExamEventAttempt{}, err
 		}
 
 		startTime, dueTime := s.SetupExamTimer(ctx, exam)
@@ -406,3 +410,4 @@ func (s *examService) AnswerExamEvent(ctx context.Context, eventSlug string, att
 	return CPQuestionVerdict, err
 }
 
+

space/.gitignore

@@ -1,2 +1,2 @@
-/.env
+.env
 go-boilerplate.exe

utils/response_util.go

@@ -59,7 +59,7 @@ func ResponseFAILED[TMetaData any](c *gin.Context, metaData TMetaData, err error
 			MetaData: metaData,
 		})
 		return
-	} else if errors.Is(err, http_error.FORBIDDEN_ERROR) {
+	} else if errors.Is(err, http_error.FORBIDDEN_ERROR) || errors.Is(err, http_error.INVALID_CODE) {
 		c.JSON(403, dto.ErrorResponse{
 			Status:   "error",
 			Error:    err,
@@ -70,8 +70,7 @@ func ResponseFAILED[TMetaData any](c *gin.Context, metaData TMetaData, err error
 	} else if errors.Is(err, http_error.EVENT_START_DATE_IN_PAST) ||
 		errors.Is(err, http_error.EVENT_START_DATE_INVALID) ||
 		errors.Is(err, http_error.EVENT_END_DATE_INVALID) ||
-		errors.Is(err, http_error.INVALID_DATE_FORMAT) ||
-		errors.Is(err, http_error.INVALID_CODE) {
+		errors.Is(err, http_error.INVALID_DATE_FORMAT) {
 		c.JSON(400, dto.ErrorResponse{
 			Status:   "error",
 			Error:    err,

utils/utils.go

@@ -3,6 +3,7 @@ package utils
 import (
 	"time"
 
+	models "abdanhafidz.com/go-boilerplate/models/entity"
 	http_error "abdanhafidz.com/go-boilerplate/models/error"
 	"github.com/google/uuid"
 )
@@ -43,3 +44,11 @@ func TimePtrToString(t *time.Time) *string {
 	s := t.Format(time.RFC3339)
 	return &s
 }
+
+func ValidateCode(code string) error {
+	if !models.CodeRegex.MatchString(code) {
+		return http_error.INVALID_CODE
+	}
+	return nil
+}
+