Deploy files from GitHub repository

Quzuu_API_Collection.postman_collection.json

@@ -5227,6 +5227,40 @@
             }
           ]
         },
+        {
+          "name": "Repair",
+          "item": [
+            {
+              "name": "Repair Question Storage Path",
+              "request": {
+                "method": "POST",
+                "header": [
+                  {
+                    "key": "Authorization",
+                    "value": "Bearer {{access_token}}",
+                    "type": "text"
+                  }
+                ],
+                "url": {
+                  "raw": "{{base_url}}/api/v1/super-admin/repair/question/storage_path",
+                  "host": [
+                    "{{base_url}}"
+                  ],
+                  "path": [
+                    "api",
+                    "v1",
+                    "super-admin",
+                    "repair",
+                    "question",
+                    "storage_path"
+                  ]
+                },
+                "description": "Repair question storage path placeholders (super admin)"
+              },
+              "response": []
+            }
+          ]
+        },
         {
           "name": "Authentication Management",
           "item": [

controllers/repair_controller.go

@@ -0,0 +1,36 @@
+package controllers
+
+import (
+	"abdanhafidz.com/go-boilerplate/models/dto"
+	"abdanhafidz.com/go-boilerplate/services"
+	"github.com/gin-gonic/gin"
+)
+
+type RepairController interface {
+	RepairQuestionStoragePath(ctx *gin.Context)
+}
+
+type repairController struct {
+	repairService services.RepairService
+}
+
+func NewRepairController(repairService services.RepairService) RepairController {
+	return &repairController{repairService: repairService}
+}
+
+// RepairQuestionStoragePath godoc
+// @Summary      Super Admin: Repair Question Storage Path
+// @Description  Replace @@PLUGINFILE@@ placeholders in questions with the storage URL and problem set ID
+// @Tags         Super Admin Repair
+// @Accept       json
+// @Produce      json
+// @Security     BearerAuth
+// @Success      200  {object}  dto.SuccessResponse[dto.RepairQuestionStoragePathResponse]
+// @Failure      401  {object}  dto.ErrorResponse
+// @Failure      403  {object}  dto.ErrorResponse
+// @Failure      500  {object}  dto.ErrorResponse
+// @Router       /api/v1/super-admin/repair/question/storage_path [post]
+func (c *repairController) RepairQuestionStoragePath(ctx *gin.Context) {
+	updatedRows, err := c.repairService.RepairQuestionStoragePath(ctx.Request.Context())
+	ResponseJSON(ctx, gin.H{}, dto.RepairQuestionStoragePathResponse{UpdatedRows: updatedRows}, err)
+}

models/dto/repair_dto.go

@@ -0,0 +1,5 @@
+package dto
+
+type RepairQuestionStoragePathResponse struct {
+	UpdatedRows int64 `json:"updated_rows"`
+}

provider/controller_provider.go

@@ -22,6 +22,7 @@ type ControllerProvider interface {
 	ProvideUploadController() controllers.UploadController
 	ProvideUserController() controllers.UserController
 	ProvideSuperAdminInjectController() controllers.SuperAdminInjectController
+	ProvideRepairController() controllers.RepairController
 }
 
 type controllerProvider struct {
@@ -44,6 +45,7 @@ type controllerProvider struct {
 	uploadController              controllers.UploadController
 	userController                controllers.UserController
 	superAdminInjectController    controllers.SuperAdminInjectController
+	repairController              controllers.RepairController
 }
 
 func NewControllerProvider(servicesProvider ServicesProvider) ControllerProvider {
@@ -71,6 +73,7 @@ func NewControllerProvider(servicesProvider ServicesProvider) ControllerProvider
 	uploadController := controllers.NewUploadController(servicesProvider.ProvideUploadService())
 	userController := controllers.NewUserController(servicesProvider.ProvideAccountService())
 	superAdminInjectController := controllers.NewSuperAdminInjectController(servicesProvider.ProvideProblemSetService())
+	repairController := controllers.NewRepairController(servicesProvider.ProvideRepairService())
 	return &controllerProvider{
 		adminAcademyController:        adminAcademyController,
 		adminEventController:          adminEventController,
@@ -91,6 +94,7 @@ func NewControllerProvider(servicesProvider ServicesProvider) ControllerProvider
 		uploadController:              uploadController,
 		userController:                userController,
 		superAdminInjectController:    superAdminInjectController,
+		repairController:              repairController,
 	}
 }
 
@@ -171,3 +175,7 @@ func (c *controllerProvider) ProvideUserController() controllers.UserController
 func (c *controllerProvider) ProvideSuperAdminInjectController() controllers.SuperAdminInjectController {
 	return c.superAdminInjectController
 }
+
+func (c *controllerProvider) ProvideRepairController() controllers.RepairController {
+	return c.repairController
+}

provider/repositories_provider.go

@@ -33,6 +33,7 @@ type RepositoriesProvider interface {
 	ProvideProblemSetInjectRepository() repositories.ProblemSetInjectRepository
 	ProvideProblemSetRepository() repositories.ProblemSetRepository
 	ProvideQuestionsRepository() repositories.QuestionsRepository
+	ProvideRepairRepository() repositories.RepairRepository
 	ProvideRegionRepository() repositories.RegionRepository
 	ProvideResultRepository() repositories.ResultRepository
 }
@@ -68,6 +69,7 @@ type repositoriesProvider struct {
 	problemSetInjectRepository     repositories.ProblemSetInjectRepository
 	problemSetRepository           repositories.ProblemSetRepository
 	questionsRepository            repositories.QuestionsRepository
+	repairRepository               repositories.RepairRepository
 	regionRepository               repositories.RegionRepository
 	resultRepository               repositories.ResultRepository
 }
@@ -106,6 +108,7 @@ func NewRepositoriesProvider(cfg ConfigProvider) RepositoriesProvider {
 	problemSetInjectRepository := repositories.NewProblemSetInjectRepository(db)
 	problemSetRepository := repositories.NewProblemSetRepository(db)
 	questionsRepository := repositories.NewQuestionsRepository(db)
+	repairRepository := repositories.NewRepairRepository(db)
 	regionRepository := repositories.NewRegionRepository(db)
 	resultRepository := repositories.NewResultRepository(db)
 
@@ -140,6 +143,7 @@ func NewRepositoriesProvider(cfg ConfigProvider) RepositoriesProvider {
 		problemSetInjectRepository:     problemSetInjectRepository,
 		problemSetRepository:           problemSetRepository,
 		questionsRepository:            questionsRepository,
+		repairRepository:               repairRepository,
 		regionRepository:               regionRepository,
 		resultRepository:               resultRepository,
 	}
@@ -265,6 +269,10 @@ func (r *repositoriesProvider) ProvideQuestionsRepository() repositories.Questio
 	return r.questionsRepository
 }
 
+func (r *repositoriesProvider) ProvideRepairRepository() repositories.RepairRepository {
+	return r.repairRepository
+}
+
 func (r *repositoriesProvider) ProvideRegionRepository() repositories.RegionRepository {
 	return r.regionRepository
 }

provider/services_provider.go

@@ -18,6 +18,7 @@ type ServicesProvider interface {
 	ProvidePaymentService() services.PaymentService
 	ProvideUploadService() services.UploadService
 	ProvideProblemSetService() services.ProblemSetService
+	ProvideRepairService() services.RepairService
 	ProvideOptionService() services.OptionService
 	ProvideAccountService() services.AccountService
 	ProvideForgotPasswordService() services.ForgotPasswordService
@@ -40,6 +41,7 @@ type servicesProvider struct {
 	paymentService             services.PaymentService
 	uploadService              services.UploadService
 	problemSetService          services.ProblemSetService
+	repairService              services.RepairService
 	optionService              services.OptionService
 	accountService             services.AccountService
 	forgotPasswordService      services.ForgotPasswordService
@@ -68,6 +70,7 @@ func NewServicesProvider(repoProvider RepositoriesProvider, configProvider Confi
 		repoProvider.ProvideProblemSetExamAssignRepository(),
 		repoProvider.ProvideProblemSetInjectRepository(),
 	)
+	repairService := services.NewRepairService(repoProvider.ProvideRepairRepository())
 	optionService := services.NewOptionService(repoProvider.ProvideOptionRepository())
 	accountService := services.NewAccountService(jWTService, repoProvider.ProvideAccountRepository(), repoProvider.ProvideAccountDetailRepository(), configProvider.ProvideSuperAdminConfig())
 	forgotPasswordService := services.NewForgotPasswordService(jWTService, repoProvider.ProvideAccountRepository(), repoProvider.ProvideForgotPasswordRepository())
@@ -108,6 +111,7 @@ func NewServicesProvider(repoProvider RepositoriesProvider, configProvider Confi
 		paymentService:             paymentService,
 		uploadService:              uploadService,
 		problemSetService:          problemSetService,
+		repairService:              repairService,
 		optionService:              optionService,
 		accountService:             accountService,
 		forgotPasswordService:      forgotPasswordService,
@@ -160,6 +164,10 @@ func (s *servicesProvider) ProvideProblemSetService() services.ProblemSetService
 	return s.problemSetService
 }
 
+func (s *servicesProvider) ProvideRepairService() services.RepairService {
+	return s.repairService
+}
+
 func (s *servicesProvider) ProvideOptionService() services.OptionService {
 	return s.optionService
 }

repositories/repair_repository.go

@@ -0,0 +1,34 @@
+package repositories
+
+import (
+	"context"
+
+	"gorm.io/gorm"
+)
+
+type RepairRepository interface {
+	RepairQuestionStoragePath(ctx context.Context) (int64, error)
+}
+
+type repairRepository struct {
+	db *gorm.DB
+}
+
+func NewRepairRepository(db *gorm.DB) RepairRepository {
+	return &repairRepository{db: db}
+}
+
+func (r *repairRepository) RepairQuestionStoragePath(ctx context.Context) (int64, error) {
+	sql := `
+		UPDATE questions
+		SET question = REPLACE(
+			question,
+			'@@PLUGINFILE@@',
+			CONCAT('https://storage.quzuu.id', '/', problem_set_id)
+		)
+		WHERE question LIKE '%@@PLUGINFILE@@%';
+	`
+
+	records := r.db.WithContext(ctx).Exec(sql)
+	return records.RowsAffected, records.Error
+}

router/super_admin_router.go

@@ -11,6 +11,7 @@ func SuperAdminRouter(router *gin.Engine, middleware provider.MiddlewareProvider
 
 	userController := controller.ProvideUserController()
 	injectController := controller.ProvideSuperAdminInjectController()
+	repairController := controller.ProvideRepairController()
 
 	// Super Admin Users Routes
 	userSuperAdminGroup := router.Group("/api/v1/super-admin/users", authenticationMiddleware.VerifyAccount, authorizationMiddleware.VerifySuperAdmin)
@@ -26,4 +27,9 @@ func SuperAdminRouter(router *gin.Engine, middleware provider.MiddlewareProvider
 	{
 		injectSuperAdminGroup.POST("/probset", injectController.InjectProblemSet)
 	}
+
+	repairSuperAdminGroup := router.Group("/api/v1/super-admin/repair", authenticationMiddleware.VerifyAccount, authorizationMiddleware.VerifySuperAdmin)
+	{
+		repairSuperAdminGroup.POST("/question/storage_path", repairController.RepairQuestionStoragePath)
+	}
 }

services/repair_service.go

@@ -0,0 +1,23 @@
+package services
+
+import (
+	"context"
+
+	"abdanhafidz.com/go-boilerplate/repositories"
+)
+
+type RepairService interface {
+	RepairQuestionStoragePath(ctx context.Context) (int64, error)
+}
+
+type repairService struct {
+	repairRepository repositories.RepairRepository
+}
+
+func NewRepairService(repairRepository repositories.RepairRepository) RepairService {
+	return &repairService{repairRepository: repairRepository}
+}
+
+func (s *repairService) RepairQuestionStoragePath(ctx context.Context) (int64, error) {
+	return s.repairRepository.RepairQuestionStoragePath(ctx)
+}