Deploy files from GitHub repository

controllers/academy_exam_controller.go

@@ -14,15 +14,15 @@ type AcademyExamController interface {
     List(ctx *gin.Context)
 }
 
-type academyExamController struct { service services.AcademyExamService }
+type academyExamController struct { academyExamService services.AcademyExamService }
 
-func NewAcademyExamController(service services.AcademyExamService) AcademyExamController { return &academyExamController{ service: service } }
+func NewAcademyExamController(academyExamService services.AcademyExamService) AcademyExamController { return &academyExamController{ academyExamService: academyExamService } }
 
 func (c *academyExamController) Attempt(ctx *gin.Context) {
     academySlug := ctx.Param("academy_slug")
     examSlug := ctx.Param("exam_slug")
     accountId := ParseAccountId(ctx)
-    res, err := c.service.AttemptExamAcademy(ctx.Request.Context(), academySlug, examSlug, accountId)
+    res, err := c.academyExamService.AttemptExamAcademy(ctx.Request.Context(), academySlug, examSlug, accountId)
     ResponseJSON(ctx, gin.H{"academy_slug": academySlug, "exam_slug": examSlug}, res, err)
 }
 
@@ -30,19 +30,19 @@ func (c *academyExamController) Answer(ctx *gin.Context) {
     academySlug := ctx.Param("academy_slug")
     attemptId, _ := utils.ToUUID(ctx.Param("attempt_id"))
     req := RequestJSON[dto.AnswerExamEventRequest](ctx)
-    res, err := c.service.AnswerExamAcademy(ctx.Request.Context(), academySlug, attemptId, req.QuestionId, req.Answer)
+    res, err := c.academyExamService.AnswerExamAcademy(ctx.Request.Context(), academySlug, attemptId, req.QuestionId, req.Answer)
     ResponseJSON(ctx, gin.H{"cp_grader_result": res}, req, err)
 }
 
 func (c *academyExamController) Submit(ctx *gin.Context) {
     attemptId, _ := utils.ToUUID(ctx.Param("attempt_id"))
-    res, err := c.service.SubmitExamAcademy(ctx.Request.Context(), attemptId)
+    res, err := c.academyExamService.SubmitExamAcademy(ctx.Request.Context(), attemptId)
     ResponseJSON(ctx, gin.H{}, res, err)
 }
 
 func (c *academyExamController) List(ctx *gin.Context) {
     academySlug := ctx.Param("academy_slug")
     accountId := ParseAccountId(ctx)
-    res, err := c.service.ListExamByAcademy(ctx.Request.Context(), academySlug, accountId)
+    res, err := c.academyExamService.ListExamByAcademy(ctx.Request.Context(), academySlug, accountId)
     ResponseJSON(ctx, gin.H{}, res, err)
 }

controllers/upload_controller.go

@@ -17,13 +17,16 @@ import (
     "abdanhafidz.com/go-boilerplate/services"
 )
 
-type UploadController struct {
-    uploadService services.UploadService
+type UploadController interface{
+	Upload(ctx *gin.Context)
+	GetFileByID(ctx *gin.Context)
 }
 
-func NewUploadController(s services.UploadService) *UploadController { return &UploadController{ uploadService: s } }
+type uploadController struct{uploadService services.UploadService}
 
-func (c *UploadController) Upload(ctx *gin.Context) {
+func NewUploadController(uploadService services.UploadService) UploadController { return &uploadController{ uploadService: uploadService } }
+
+func (c *uploadController) Upload(ctx *gin.Context) {
     fmt.Println("👉 Content-Type:", ctx.GetHeader("Content-Type"))
 
     if !strings.Contains(ctx.GetHeader("Content-Type"), "multipart/form-data") {
@@ -162,7 +165,7 @@ func (c *UploadController) Upload(ctx *gin.Context) {
 	})
 }
 
-func (c *UploadController) GetFileByID(ctx *gin.Context) {
+func (c *uploadController) GetFileByID(ctx *gin.Context) {
 	fileIDStr := ctx.Param("id")
 	fileID, err := uuid.Parse(fileIDStr)
 	if err != nil {
@@ -224,7 +227,7 @@ func (c *UploadController) GetFileByID(ctx *gin.Context) {
 	})
 }
 
-func (c *UploadController) inferContextFromExt(ext string) string {
+func (c *uploadController) inferContextFromExt(ext string) string {
 	images := map[string]bool{
 		".jpg": true, ".jpeg": true, ".png": true, ".webp": true,
 	}

models/dto/academy_dto.go

@@ -5,6 +5,7 @@ import "github.com/google/uuid"
 type CreateAcademyRequest struct {
 	Title       string `json:"title" binding:"required"`
 	Slug        string `json:"slug"`
+	Code        string `json:"code"`
 	Description string `json:"description"`
 	ImageUrl    string `json:"image_url"`
 }
@@ -65,6 +66,7 @@ type AcademyDetailResponse struct {
 	Id             uuid.UUID                 `json:"id"`
 	Title          string                    `json:"title"`
 	Slug           string                    `json:"slug"`
+	Code           string                    `json:"code"`
 	Description    string                    `json:"description"`
 	ImageUrl       string                    `json:"image_url"`
 	MaterialsCount int64                     `json:"materials_count"`

models/entity/entity.go

@@ -263,6 +263,7 @@ type Academy struct {
 	Id               uuid.UUID         `gorm:"type:uuid;primaryKey" json:"id"`
 	Title            string            `json:"title,omitempty"`
 	Slug             string            `gorm:"unique" json:"slug,omitempty"`
+	Code             string            `gorm:"unique" json:"code,omitempty"`
 	Description      string            `json:"description,omitempty"`
 	ImageUrl         string            `json:"image_url,omitempty"`
 	MaterialsCount   int64             `json:"materials_count,omitempty"`

models/error/error.go

@@ -30,6 +30,9 @@ var (
 	EVENT_FINISHED              = errors.New("The event has ended, you are disallowed to take the exam")
 	EVENT_NOT_STARTED           = errors.New("Take it easy, event hasn't started yet! You cannot take the exam")
 	EXAMS_SUBMITTED             = errors.New("You have submitted the exam, you are disallowed to answer the question")
+	IMAGE_REQUIRED              = errors.New("Image is required")
+	DESCRIPTION_REQUIRED        = errors.New("Description is required")
+	CODE_REQUIRED               = errors.New("Code is required")
 
 	// ================= FILE UPLOAD =================
 	FILE_TOO_LARGE         = errors.New("File size exceeds the maximum limit")

provider/controller_provider.go

@@ -12,7 +12,7 @@ type ControllerProvider interface {
 	ProvideForgotPasswordController() controllers.ForgotPasswordController
 	ProvideOptionController() controllers.OptionController
     ProvideRegionController() controllers.RegionController
-    ProvideUploadController() *controllers.UploadController 
+    ProvideUploadController() controllers.UploadController 
     ProvideAcademyExamController() controllers.AcademyExamController
 }
 
@@ -26,7 +26,7 @@ type controllerProvider struct {
 	forgotPasswordController    controllers.ForgotPasswordController
 	optionController            controllers.OptionController
 	regionController            controllers.RegionController
-    uploadController            *controllers.UploadController 
+    uploadController            controllers.UploadController 
     academyExamController       controllers.AcademyExamController
 }
 
@@ -96,7 +96,7 @@ func (c *controllerProvider) ProvideRegionController() controllers.RegionControl
 	return c.regionController
 }
 
-func (c *controllerProvider) ProvideUploadController() *controllers.UploadController {
+func (c *controllerProvider) ProvideUploadController() controllers.UploadController {
     return c.uploadController
 }
 

services/academy_service.go

@@ -37,7 +37,6 @@ type AcademyService interface {
 	GetAcademyResponse(ctx context.Context, accountId uuid.UUID, slug string) (*dto.AcademyDetailResponse, error)
 	GetMaterialResponse(ctx context.Context, accountId uuid.UUID, academySlug string, materialSlug string) (*dto.MaterialDetailResponse, error)
 }
-
 type academyService struct {
 	academyRepo repositories.AcademyRepository
 }
@@ -46,14 +45,6 @@ func NewAcademyService(academyRepo repositories.AcademyRepository) AcademyServic
 	return &academyService{academyRepo: academyRepo}
 }
 
-func timePtrToString(t *time.Time) *string {
-	if t == nil {
-		return nil
-	}
-	s := t.Format(time.RFC3339)
-	return &s
-}
-
 func (s *academyService) GetAcademy(ctx context.Context, accountId uuid.UUID, slug string) (entity.Academy, error) {
 	return s.academyRepo.GetAcademyWithProgress(ctx, accountId, slug)
 }
@@ -64,25 +55,42 @@ func (s *academyService) GetAcademyDetail(ctx context.Context, id uuid.UUID) (en
 }
 
 func (s *academyService) CreateAcademy(ctx context.Context, req dto.CreateAcademyRequest) (entity.Academy, error) {
-	if strings.TrimSpace(req.Title) == "" {
-		return entity.Academy{}, http_error.TITLE_REQUIRED
-	}
-	slugVal := req.Slug
-	if slugVal == "" {
-		slugVal = slug.Make(req.Title)
-	}
-	if _, err := s.academyRepo.GetAcademyBySlug(ctx, slugVal); err == nil {
-		return entity.Academy{}, http_error.DUPLICATE_DATA
-	}
-	a := entity.Academy{
-		Id:             uuid.New(),
-		Title:          req.Title,
-		Slug:           slugVal,
-		Description:    req.Description,
-		ImageUrl:       req.ImageUrl,
-		MaterialsCount: 0,
-	}
-	return s.academyRepo.CreateAcademy(ctx, a)
+    if strings.TrimSpace(req.Title) == "" {
+        return entity.Academy{}, http_error.TITLE_REQUIRED
+    }
+
+    if strings.TrimSpace(req.Code) == "" {
+        return entity.Academy{}, http_error.CODE_REQUIRED 
+    }
+
+    if strings.TrimSpace(req.Description) == "" {
+        return entity.Academy{}, http_error.DESCRIPTION_REQUIRED
+    }
+
+    if strings.TrimSpace(req.ImageUrl) == "" {
+        return entity.Academy{}, http_error.IMAGE_REQUIRED
+    }
+
+    slugVal := req.Slug
+    if slugVal == "" {
+        slugVal = slug.Make(req.Title)
+    }
+
+    if _, err := s.academyRepo.GetAcademyBySlug(ctx, slugVal); err == nil {
+        return entity.Academy{}, http_error.DUPLICATE_DATA
+    }
+
+    a := entity.Academy{
+        Id:             uuid.New(),
+        Title:          req.Title,
+        Slug:           slugVal,
+        Code:           req.Code,
+        Description:    req.Description,
+        ImageUrl:       req.ImageUrl,
+        MaterialsCount: 0,
+    }
+
+    return s.academyRepo.CreateAcademy(ctx, a)
 }
 
 func (s *academyService) UpdateAcademy(ctx context.Context, id uuid.UUID, req dto.UpdateAcademyRequest) (entity.Academy, error) {
@@ -490,6 +498,7 @@ func (s *academyService) GetAcademyResponse(ctx context.Context, accountId uuid.
 		Id:             academy.Id,
 		Title:          academy.Title,
 		Slug:           academy.Slug,
+		Code:           academy.Code,
 		Description:    academy.Description,
 		ImageUrl:       academy.ImageUrl,
 		MaterialsCount: academy.MaterialsCount,
@@ -500,7 +509,7 @@ func (s *academyService) GetAcademyResponse(ctx context.Context, accountId uuid.
 			Status:                  academyProgress.Status,
 			Progress:                academyProgress.Progress,
 			TotalCompletedMaterials: academyProgress.TotalCompletedMaterials,
-			CompletedAt:             timePtrToString(academyProgress.CompletedAt),
+			CompletedAt:             utils.TimePtrToString(academyProgress.CompletedAt),
 		},
 	}
 
@@ -594,7 +603,7 @@ func (s *academyService) GetMaterialResponse(ctx context.Context, accountId uuid
 			Progress:               materialProgress.Progress,
 			TotalCompletedContents: materialProgress.TotalCompletedContents,
 			Status:                 materialProgress.Status,
-			CompletedAt:            timePtrToString(materialProgress.CompletedAt),
+			CompletedAt:            utils.TimePtrToString(materialProgress.CompletedAt),
 		},
 	}
 

services/academy_service_helpers.go

@@ -1,353 +0,0 @@
-package services
-
-import (
-	"context"
-	"math"
-	"time"
-
-	"github.com/google/uuid"
-
-	"abdanhafidz.com/go-boilerplate/models/dto"
-	entity "abdanhafidz.com/go-boilerplate/models/entity"
-	"abdanhafidz.com/go-boilerplate/repositories"
-	"abdanhafidz.com/go-boilerplate/utils"
-)
-
-func (s *academyService) getOrCreateID(id uuid.UUID) uuid.UUID {
-	if id == uuid.Nil {
-		return uuid.New()
-	}
-	return id
-}
-
-func (s *academyService) calculateProgress(completed, total int64) float64 {
-	if total <= 0 {
-		return 0
-	}
-	progress := (float64(completed) / float64(total)) * 100
-	return math.Round(progress*100) / 100
-}
-
-func (s *academyService) getProgressStatus(progress float64, completed, total int64) string {
-	if progress >= 100 || (total > 0 && completed >= total) {
-		return entity.StatusCompleted
-	}
-	if progress > 0 {
-		return entity.StatusInProgress
-	}
-	return entity.StatusNotStarted
-}
-
-func (s *academyService) upsertContentProgressSimplified(
-    ctx context.Context,
-    txRepo repositories.AcademyRepository,
-    accountId, academyId, materialId, contentId uuid.UUID,
-) (entity.AcademyContentProgress, error) {
-    existing, err := txRepo.GetContentProgress(ctx, accountId, academyId, materialId, contentId)
-    if err != nil {
-        // propagate non-not-found errors
-        return entity.AcademyContentProgress{}, err
-    }
-
-	acp := entity.AcademyContentProgress{
-		Id:          s.getOrCreateID(existing.Id),
-		AccountId:   accountId,
-		AcademyId:   academyId,
-		MaterialId:  materialId,
-		ContentId:   contentId,
-		Status:      entity.StatusCompleted,
-		CompletedAt: utils.Ptr(time.Now()),
-	}
-
-    if _, err := txRepo.UpsertContentProgress(ctx, acp); err != nil {
-        return entity.AcademyContentProgress{}, err
-    }
-    return acp, nil
-}
-
-func (s *academyService) calculateMaterialProgress(
-	ctx context.Context,
-	txRepo repositories.AcademyRepository,
-	accountId, academyId, materialId uuid.UUID,
-	totalCompleted, totalContents int64,
-) entity.AcademyMaterialProgress {
-	existing, _ := txRepo.GetMaterialProgress(ctx, accountId, academyId, materialId)
-
-	progress := s.calculateProgress(totalCompleted, totalContents)
-	status := s.getProgressStatus(progress, totalCompleted, totalContents)
-
-	var completedAt *time.Time
-	if status == entity.StatusCompleted {
-		completedAt = utils.Ptr(time.Now())
-		progress = 100
-	}
-
-	return entity.AcademyMaterialProgress{
-		Id:                     s.getOrCreateID(existing.Id),
-		AccountId:              accountId,
-		AcademyId:              academyId,
-		MaterialId:             materialId,
-		Progress:               progress,
-		TotalCompletedContents: uint(totalCompleted),
-		Status:                 status,
-		CompletedAt:            completedAt,
-	}
-}
-
-
-func (s *academyService) calculateAcademyProgress(
-	ctx context.Context,
-	txRepo repositories.AcademyRepository,
-	accountId, academyId uuid.UUID,
-	accumulatedProgress float64,
-	totalMaterials int64,
-) entity.AcademyProgress {
-	existing, _ := txRepo.GetAcademyProgress(ctx, accountId, academyId)
-
-	var progress float64
-	if totalMaterials > 0 {
-		progress = math.Round((accumulatedProgress/float64(totalMaterials))*100) / 100
-	}
-
-	status := s.getProgressStatus(progress, 0, totalMaterials)
-
-	var completedAt *time.Time
-	if status == entity.StatusCompleted {
-		completedAt = utils.Ptr(time.Now())
-		progress = 100
-	}
-
-	totalCompleted, _ := txRepo.CountCompletedMaterialsByAcademyAndAccount(ctx, accountId, academyId)
-
-	return entity.AcademyProgress{
-		Id:                      s.getOrCreateID(existing.Id),
-		AccountId:               accountId,
-		AcademyId:               academyId,
-		Progress:                progress,
-		TotalCompletedMaterials: uint(totalCompleted),
-		Status:                  status,
-		CompletedAt:             completedAt,
-	}
-}
-
-func (s *academyService) updateAcademyMaterialCount(ctx context.Context, txRepo repositories.AcademyRepository, academyId uuid.UUID) error {
-    count, err := txRepo.CountMaterialsByAcademyID(ctx, academyId)
-    if err != nil { return err }
-    academy, err := txRepo.GetAcademyByID(ctx, academyId)
-    if err != nil { return err }
-    academy.MaterialsCount = count
-    _, err = txRepo.UpdateAcademy(ctx, academy)
-    return err
-}
-
-
-func (s *academyService) updateMaterialContentCount(ctx context.Context, txRepo repositories.AcademyRepository, materialId uuid.UUID) error {
-    count, err := txRepo.CountContentsByMaterialID(ctx, materialId)
-    if err != nil { return err }
-    material, err := txRepo.GetMaterialByID(ctx, materialId)
-    if err != nil { return err }
-    material.ContentsCount = count
-    _, err = txRepo.UpdateMaterial(ctx, material)
-    return err
-}
-
-func formatTime(t *time.Time) *string {
-	if t == nil {
-		return nil
-	}
-	formatted := t.Format("2006-01-02T15:04:05Z07:00")
-	return &formatted
-}
-
-
-func buildAcademyProgressResponse(ap entity.AcademyProgress) *dto.AcademyProgressResponse {
-	if ap.Id == uuid.Nil {
-		return nil
-	}
-	return &dto.AcademyProgressResponse{
-		Id:                      ap.Id,
-		AccountId:               ap.AccountId,
-		AcademyId:               ap.AcademyId,
-		Status:                  ap.Status,
-		Progress:                ap.Progress,
-		TotalCompletedMaterials: ap.TotalCompletedMaterials,
-		CompletedAt:             formatTime(ap.CompletedAt),
-	}
-}
-
-func buildAcademyContentResponse(content entity.AcademyContent, progress entity.AcademyContentProgress) dto.AcademyContentResponse {
-	status := entity.StatusNotStarted
-	if progress.Id != uuid.Nil {
-		status = progress.Status
-	}
-	return dto.AcademyContentResponse{
-		Id:     content.Id,
-		Order:  content.Order,
-		Title:  content.Title,
-		Status: status,
-	}
-}
-
-
-func buildAcademyMaterialResponse(
-	material entity.AcademyMaterial,
-	contents []entity.AcademyContent,
-	progressMap map[uuid.UUID]entity.AcademyContentProgress,
-	progress entity.AcademyMaterialProgress,
-) dto.AcademyMaterialResponse {
-	status := entity.StatusNotStarted
-	if progress.Id != uuid.Nil {
-		status = progress.Status
-	}
-
-	contentDTOs := make([]dto.AcademyContentResponse, 0)
-	for _, content := range contents {
-		contentProgress := progressMap[content.Id]
-		contentDTOs = append(contentDTOs, buildAcademyContentResponse(content, contentProgress))
-	}
-
-	return dto.AcademyMaterialResponse{
-		Id:                     material.Id,
-		Order:                  material.Order,
-		Title:                  material.Title,
-		Slug:                   material.Slug,
-		Status:                 status,
-		Progress:               progress.Progress,
-		TotalCompletedContents: progress.TotalCompletedContents,
-		ContentsCount:          material.ContentsCount,
-		Contents:               contentDTOs,
-	}
-}
-
-func buildAcademyDetailResponse(
-	academy entity.Academy,
-	materials []entity.AcademyMaterial,
-	academyProgress entity.AcademyProgress,
-	ctx context.Context,
-	repo repositories.AcademyRepository,
-) *dto.AcademyDetailResponse {
-	materialDTOs := make([]dto.AcademyMaterialResponse, 0)
-
-	materialIds := make([]uuid.UUID, 0)
-	contentIds := make([]uuid.UUID, 0)
-
-	for _, material := range materials {
-		materialIds = append(materialIds, material.Id)
-		for _, content := range material.Contents {
-			contentIds = append(contentIds, content.Id)
-		}
-	}
-
-	materialProgressMap, _ := repo.GetMaterialProgressBatch(ctx, academyProgress.AccountId, academyProgress.AcademyId, materialIds)
-	contentProgressMap, _ := repo.GetContentProgressBatch(ctx, academyProgress.AccountId, academyProgress.AcademyId, contentIds)
-
-	for _, material := range materials {
-		materialProgress := materialProgressMap[material.Id]
-		contentDTOs := make([]dto.AcademyContentResponse, 0)
-
-		for _, content := range material.Contents {
-			contentProgress := contentProgressMap[content.Id]
-			contentDTOs = append(contentDTOs, buildAcademyContentResponse(content, contentProgress))
-		}
-
-		materialDTOs = append(materialDTOs, dto.AcademyMaterialResponse{
-			Id:                     material.Id,
-			Order:                  material.Order,
-			Title:                  material.Title,
-			Slug:                   material.Slug,
-			Status:                 getContentStatus(materialProgress),
-			Progress:               materialProgress.Progress,
-			TotalCompletedContents: materialProgress.TotalCompletedContents,
-			ContentsCount:          material.ContentsCount,
-			Contents:               contentDTOs,
-		})
-	}
-
-	return &dto.AcademyDetailResponse{
-		Id:             academy.Id,
-		Title:          academy.Title,
-		Slug:           academy.Slug,
-		Description:    academy.Description,
-		ImageUrl:       academy.ImageUrl,
-		MaterialsCount: academy.MaterialsCount,
-		UserProgress:   buildAcademyProgressResponse(academyProgress),
-		Materials:      materialDTOs,
-	}
-}
-
-func getContentStatus(progress entity.AcademyMaterialProgress) string {
-	if progress.Id != uuid.Nil {
-		return progress.Status
-	}
-	return entity.StatusNotStarted
-}
-
-func buildMaterialProgressResponse(mp entity.AcademyMaterialProgress) *dto.MaterialProgressResponse {
-	if mp.Id == uuid.Nil {
-		return nil
-	}
-	return &dto.MaterialProgressResponse{
-		Id:                     mp.Id,
-		AccountId:              mp.AccountId,
-		AcademyId:              mp.AcademyId,
-		MaterialId:             mp.MaterialId,
-		Progress:               mp.Progress,
-		TotalCompletedContents: mp.TotalCompletedContents,
-		Status:                 mp.Status,
-		CompletedAt:            formatTime(mp.CompletedAt),
-	}
-}
-
-func buildContentDetailResponse(content entity.AcademyContent, progress entity.AcademyContentProgress) dto.ContentDetailResponse {
-	status := entity.StatusNotStarted
-	if progress.Id != uuid.Nil {
-		status = progress.Status
-	}
-
-	return dto.ContentDetailResponse{
-		Id:     content.Id,
-		Order:  content.Order,
-		Title:  content.Title,
-		Status: status,
-	}
-}
-
-
-func buildMaterialDetailResponse(
-	material entity.AcademyMaterial,
-	contents []entity.AcademyContent,
-	materialProgress entity.AcademyMaterialProgress,
-	accountId, academyId uuid.UUID,
-	ctx context.Context,
-	repo repositories.AcademyRepository,
-	academySlug, materialSlug string,
-) *dto.MaterialDetailResponse {
-	contentDTOs := make([]dto.ContentDetailResponse, 0)
-	contentIds := make([]uuid.UUID, len(contents))
-	for i, c := range contents {
-		contentIds[i] = c.Id
-	}
-
-	contentProgressMap, _ := repo.GetContentProgressBatch(ctx, accountId, academyId, contentIds)
-
-	for _, content := range contents {
-		contentProgress := contentProgressMap[content.Id]
-		contentDTOs = append(contentDTOs, buildContentDetailResponse(content, contentProgress))
-	}
-
-	return &dto.MaterialDetailResponse{
-		Id:            material.Id,
-		AcademyId:     material.AcademyId,
-		Title:         material.Title,
-		Slug:          material.Slug,
-		Description:   material.Description,
-		Order:         material.Order,
-		ContentsCount: material.ContentsCount,
-		Progress:      buildMaterialProgressResponse(materialProgress),
-		Contents:      contentDTOs,
-		Meta: map[string]string{
-			"academy_slug":  academySlug,
-			"material_slug": materialSlug,
-		},
-	}
-}

services/upload_service.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"io"
 	"mime/multipart"
+	"net/http"
 	"path/filepath"
 	"regexp"
 	"strings"
@@ -89,7 +90,8 @@ func (s *uploadService) GetFileByID(ctx context.Context, fileID uuid.UUID, accou
 }
 
 func (s *uploadService) processSingleFile(ctx context.Context, fileHeader *multipart.FileHeader, config config.UploadRule, uploadContext string, accountID uuid.UUID) (*entity.File, error) {
-	if err := s.validateFile(fileHeader, config); err != nil {
+	detectedMimeType, err := s.validateFile(fileHeader, config)
+	if err != nil {
 		return nil, err
 	}
 
@@ -103,8 +105,7 @@ func (s *uploadService) processSingleFile(ctx context.Context, fileHeader *multi
 	}
 	defer src.Close()
 
-	contentType := fileHeader.Header.Get("Content-Type")
-	publicURL, err := s.storageProvider.UploadFile(ctx, src, storagePath, contentType)
+	publicURL, err := s.storageProvider.UploadFile(ctx, src, storagePath, detectedMimeType)
 	if err != nil {
 		return nil, http_error.UPLOAD_FAILED
 	}
@@ -113,7 +114,7 @@ func (s *uploadService) processSingleFile(ctx context.Context, fileHeader *multi
 		Id:           uuid.New(),
 		OriginalName: fileHeader.Filename,
 		StoredName:   storedFilename,
-		MimeType:     contentType,
+		MimeType:     detectedMimeType,
 		Size:         fileHeader.Size,
 		Path:         publicURL,
 		Context:      uploadContext,
@@ -128,22 +129,70 @@ func (s *uploadService) processSingleFile(ctx context.Context, fileHeader *multi
 	return fileEntity, nil
 }
 
-func (s *uploadService) validateFile(file *multipart.FileHeader, config config.UploadRule) error {
+func (s *uploadService) validateFile(file *multipart.FileHeader, config config.UploadRule) (string, error) {
 	if file.Size == 0 || file.Size > config.MaxBytes {
-		return http_error.FILE_TOO_LARGE
+		return "", http_error.FILE_TOO_LARGE
+	}
+
+	src, err := file.Open()
+	if err != nil {
+		return "", http_error.INTERNAL_SERVER_ERROR
+	}
+	defer src.Close()
+
+	buffer := make([]byte, 512)
+	_, err = src.Read(buffer)
+	if err != nil && err != io.EOF {
+		return "", http_error.INTERNAL_SERVER_ERROR
 	}
 
+	detectedMimeType := http.DetectContentType(buffer)
+
 	ext := strings.ToLower(strings.TrimSpace(filepath.Ext(file.Filename)))
 	if !config.AllowedExts[ext] {
-		return http_error.INVALID_FILE_TYPE
+		return "", http_error.INVALID_FILE_TYPE
+	}
+
+	if !isValidMimeForExt(ext, detectedMimeType) {
+		return "", http_error.INVALID_FILE_TYPE
 	}
 
 	blockedExts := map[string]bool{".exe": true, ".sh": true, ".bat": true, ".php": true}
 	if blockedExts[ext] {
-		return http_error.INVALID_FILE_TYPE
+		return "", http_error.INVALID_FILE_TYPE
 	}
 
-	return nil
+	return detectedMimeType, nil
+}
+
+func isValidMimeForExt(ext string, mimeType string) bool {
+	baseMime := strings.Split(mimeType, ";")[0]
+	baseMime = strings.TrimSpace(baseMime)
+
+	switch ext {
+	case ".jpg", ".jpeg":
+		return baseMime == "image/jpeg"
+	case ".png":
+		return baseMime == "image/png"
+	case ".gif":
+		return baseMime == "image/gif"
+	case ".pdf":
+		return baseMime == "application/pdf"
+	case ".txt":
+		return baseMime == "text/plain"
+	case ".c", ".cpp":
+		return baseMime == "submissions/x-c++src"
+	case ".py":
+		return baseMime == "submissions/x-python3src"
+	case ".java":
+		return baseMime == "submissions/x-java8src"
+	case ".cs":
+		return baseMime == "submissions/x-csharp8src"
+	case ".js":
+		return baseMime == "submissions/x-javascriptsrc"
+	default:
+		return false
+	}
 }
 
 func (s *uploadService) generateStoredFilename(originalName string, ext string) string {
@@ -212,4 +261,4 @@ func (s *uploadService) UploadRawFile(ctx context.Context, reader io.Reader, ori
 	}
 
 	return fileEntity, nil
-}
+}

utils/utils.go

@@ -35,3 +35,11 @@ func CalculateRemainingTime(startTime, dueTime time.Time) int {
 func Ptr[T any](v T) *T {
 	return &v
 }
+
+func TimePtrToString(t *time.Time) *string {
+	if t == nil {
+		return nil
+	}
+	s := t.Format(time.RFC3339)
+	return &s
+}