fix: fixing hf bug

controllers/auth_controller.go

@@ -22,6 +22,10 @@ type AuthController interface {
 	GetAllUsers(ctx *gin.Context)
 	GetAllWorkers(ctx *gin.Context)
 	AssignWorkerRole(ctx *gin.Context)
+	CreateWorker(ctx *gin.Context)
+	GetWorkerByID(ctx *gin.Context)
+	UpdateWorker(ctx *gin.Context)
+	DeleteWorker(ctx *gin.Context)
 }
 
 type authController struct {
@@ -267,3 +271,114 @@ func (c *authController) AssignWorkerRole(ctx *gin.Context) {
 
 	utils.SendSuccessResponse(ctx, "Worker role assigned successfully", nil)
 }
+
+// @Summary Create Worker
+// @Description Create a new worker account (Admin only)
+// @Tags Admin
+// @Accept json
+// @Produce json
+// @Security BearerAuth
+// @Param request body dto.CreateWorkerRequest true "Create Worker Request"
+// @Success 200 {object} dto.WorkerResponse
+// @Failure 400 {object} map[string]string
+// @Router /api/admin/worker [post]
+func (c *authController) CreateWorker(ctx *gin.Context) {
+	var req dto.CreateWorkerRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		utils.SendErrorResponse(ctx, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	worker, err := c.authService.CreateWorker(req)
+	if err != nil {
+		utils.SendErrorResponse(ctx, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	utils.SendSuccessResponse(ctx, "Worker created successfully", worker)
+}
+
+// @Summary Get Worker By ID
+// @Description Get worker details by ID (Admin only)
+// @Tags Admin
+// @Produce json
+// @Security BearerAuth
+// @Param id path string true "Worker ID"
+// @Success 200 {object} dto.WorkerResponse
+// @Failure 400 {object} map[string]string
+// @Router /api/admin/worker/{id} [get]
+func (c *authController) GetWorkerByID(ctx *gin.Context) {
+	workerIDStr := ctx.Param("id")
+	workerID, err := uuid.Parse(workerIDStr)
+	if err != nil {
+		utils.SendErrorResponse(ctx, http.StatusBadRequest, "Invalid worker ID")
+		return
+	}
+
+	worker, err := c.authService.GetWorkerByID(workerID)
+	if err != nil {
+		utils.SendErrorResponse(ctx, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	utils.SendSuccessResponse(ctx, "Worker retrieved successfully", worker)
+}
+
+// @Summary Update Worker
+// @Description Update worker details (Admin only)
+// @Tags Admin
+// @Accept json
+// @Produce json
+// @Security BearerAuth
+// @Param id path string true "Worker ID"
+// @Param request body dto.UpdateWorkerRequest true "Update Worker Request"
+// @Success 200 {object} dto.WorkerResponse
+// @Failure 400 {object} map[string]string
+// @Router /api/admin/worker/{id} [put]
+func (c *authController) UpdateWorker(ctx *gin.Context) {
+	workerIDStr := ctx.Param("id")
+	workerID, err := uuid.Parse(workerIDStr)
+	if err != nil {
+		utils.SendErrorResponse(ctx, http.StatusBadRequest, "Invalid worker ID")
+		return
+	}
+
+	var req dto.UpdateWorkerRequest
+	if err := ctx.ShouldBindJSON(&req); err != nil {
+		utils.SendErrorResponse(ctx, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	worker, err := c.authService.UpdateWorker(workerID, req)
+	if err != nil {
+		utils.SendErrorResponse(ctx, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	utils.SendSuccessResponse(ctx, "Worker updated successfully", worker)
+}
+
+// @Summary Delete Worker
+// @Description Delete a worker (Admin only)
+// @Tags Admin
+// @Produce json
+// @Security BearerAuth
+// @Param id path string true "Worker ID"
+// @Success 200 {object} map[string]string
+// @Failure 400 {object} map[string]string
+// @Router /api/admin/worker/{id} [delete]
+func (c *authController) DeleteWorker(ctx *gin.Context) {
+	workerIDStr := ctx.Param("id")
+	workerID, err := uuid.Parse(workerIDStr)
+	if err != nil {
+		utils.SendErrorResponse(ctx, http.StatusBadRequest, "Invalid worker ID")
+		return
+	}
+
+	if err := c.authService.DeleteWorker(workerID); err != nil {
+		utils.SendErrorResponse(ctx, http.StatusBadRequest, err.Error())
+		return
+	}
+
+	utils.SendSuccessResponse(ctx, "Worker deleted successfully", nil)
+}

models/dto/auth_dto.go

@@ -35,3 +35,26 @@ type UserResponse struct {
 type AssignWorkerRoleRequest struct {
 	WorkerID uuid.UUID `json:"worker_id" binding:"required"`
 }
+
+type CreateWorkerRequest struct {
+	Fullname string `json:"fullname" binding:"required"`
+	Username string `json:"username" binding:"required"`
+	Email    string `json:"email" binding:"required,email"`
+	Password string `json:"password" binding:"required,min=6"`
+}
+
+type UpdateWorkerRequest struct {
+	Fullname string `json:"fullname"`
+	Username string `json:"username"`
+	Email    string `json:"email"`
+	Password string `json:"password"`
+}
+
+type WorkerResponse struct {
+	ID        uuid.UUID `json:"id"`
+	Username  string    `json:"username"`
+	Fullname  string    `json:"fullname"`
+	Email     string    `json:"email"`
+	Verified  bool      `json:"verified"`
+	CreatedAt string    `json:"created_at"`
+}

repositories/user_repository.go

@@ -18,6 +18,7 @@ type UserRepository interface {
 	GetTopUsersByXP(limit int) ([]entity.User, error)
 	GetAllUsers() ([]entity.User, error)
 	GetUsersByRole(role string) ([]entity.User, error)
+	DeleteUser(id uuid.UUID) error
 }
 
 type userRepository struct {
@@ -81,3 +82,7 @@ func (r *userRepository) GetTopUsersByXP(limit int) ([]entity.User, error) {
 	err := r.db.Order("total_xp DESC").Limit(limit).Find(&users).Error
 	return users, err
 }
+
+func (r *userRepository) DeleteUser(id uuid.UUID) error {
+	return r.db.Delete(&entity.User{}, "id = ?", id).Error
+}

router/auth_router.go

@@ -55,4 +55,14 @@ func (r *authRouter) Setup(router *gin.RouterGroup) {
 	userProtected.Use(middleware.AuthMiddleware())
 	userProtected.Use(middleware.RoleMiddleware("user", "admin"))
 	userProtected.GET("/me", r.authController.GetProfile)
+
+	// Worker CRUD routes (Admin only)
+	workerCRUD := router.Group("/admin/worker")
+	workerCRUD.Use(middleware.AuthMiddleware())
+	workerCRUD.Use(middleware.RoleMiddleware("admin"))
+	workerCRUD.POST("", r.authController.CreateWorker)
+	workerCRUD.GET("", r.authController.GetAllWorkers)
+	workerCRUD.GET("/:id", r.authController.GetWorkerByID)
+	workerCRUD.PUT("/:id", r.authController.UpdateWorker)
+	workerCRUD.DELETE("/:id", r.authController.DeleteWorker)
 }

router/router.go

@@ -6,7 +6,6 @@ import (
 
 	brotli "github.com/anargu/gin-brotli"
 	"github.com/gin-contrib/cors"
-	"github.com/gin-contrib/gzip"
 	swaggerFiles "github.com/swaggo/files"
 	ginSwagger "github.com/swaggo/gin-swagger"
 )
@@ -23,7 +22,6 @@ func RunRouter(appProvider provider.AppProvider) {
 		AllowCredentials: true,
 	}))
 	router.Use(brotli.Brotli(brotli.DefaultCompression))
-	router.Use(gzip.Gzip(gzip.DefaultCompression))
 
 	authRouter := NewAuthRouter(controller.ProvideAuthController())
 	authRouter.Setup(router.Group("/api"))

services/auth_service.go

@@ -23,6 +23,10 @@ type AuthService interface {
 	GetAllUsers() ([]dto.UserResponse, error)
 	GetAllWorkers() ([]dto.UserResponse, error)
 	AssignWorkerRole(userID uuid.UUID) error
+	CreateWorker(req dto.CreateWorkerRequest) (*dto.WorkerResponse, error)
+	GetWorkerByID(workerID uuid.UUID) (*dto.WorkerResponse, error)
+	UpdateWorker(workerID uuid.UUID, req dto.UpdateWorkerRequest) (*dto.WorkerResponse, error)
+	DeleteWorker(workerID uuid.UUID) error
 }
 
 type authService struct {
@@ -276,3 +280,120 @@ func (s *authService) AssignWorkerRole(userID uuid.UUID) error {
 	user.Role = entity.ROLE_WORKER
 	return s.userRepo.UpdateUser(user)
 }
+
+func (s *authService) CreateWorker(req dto.CreateWorkerRequest) (*dto.WorkerResponse, error) {
+	existingUser, err := s.userRepo.FindUserByEmail(req.Email)
+	if err != nil {
+		return nil, err
+	}
+	if existingUser != nil {
+		return nil, errors.New("email already registered")
+	}
+
+	hashedPassword, err := utils.HashPassword(req.Password)
+	if err != nil {
+		return nil, err
+	}
+
+	worker := &entity.User{
+		Username: req.Username,
+		Fullname: req.Fullname,
+		Email:    req.Email,
+		Role:     entity.ROLE_WORKER,
+		Password: hashedPassword,
+		Verified: true,
+	}
+
+	if err := s.userRepo.CreateUser(worker); err != nil {
+		return nil, err
+	}
+
+	return &dto.WorkerResponse{
+		ID:        worker.ID,
+		Username:  worker.Username,
+		Fullname:  worker.Fullname,
+		Email:     worker.Email,
+		Verified:  worker.Verified,
+		CreatedAt: worker.CreatedAt.Format("2006-01-02 15:04:05"),
+	}, nil
+}
+
+func (s *authService) GetWorkerByID(workerID uuid.UUID) (*dto.WorkerResponse, error) {
+	worker, err := s.userRepo.FindUserByID(workerID)
+	if err != nil {
+		return nil, err
+	}
+	if worker == nil {
+		return nil, errors.New("worker not found")
+	}
+	if worker.Role != entity.ROLE_WORKER {
+		return nil, errors.New("user is not a worker")
+	}
+
+	return &dto.WorkerResponse{
+		ID:        worker.ID,
+		Username:  worker.Username,
+		Fullname:  worker.Fullname,
+		Email:     worker.Email,
+		Verified:  worker.Verified,
+		CreatedAt: worker.CreatedAt.Format("2006-01-02 15:04:05"),
+	}, nil
+}
+
+func (s *authService) UpdateWorker(workerID uuid.UUID, req dto.UpdateWorkerRequest) (*dto.WorkerResponse, error) {
+	worker, err := s.userRepo.FindUserByID(workerID)
+	if err != nil {
+		return nil, err
+	}
+	if worker == nil {
+		return nil, errors.New("worker not found")
+	}
+	if worker.Role != entity.ROLE_WORKER {
+		return nil, errors.New("user is not a worker")
+	}
+
+	if req.Fullname != "" {
+		worker.Fullname = req.Fullname
+	}
+	if req.Username != "" {
+		worker.Username = req.Username
+	}
+	if req.Email != "" {
+		worker.Email = req.Email
+	}
+	if req.Password != "" {
+		hashedPassword, err := utils.HashPassword(req.Password)
+		if err != nil {
+			return nil, err
+		}
+		worker.Password = hashedPassword
+	}
+
+	if err := s.userRepo.UpdateUser(worker); err != nil {
+		return nil, err
+	}
+
+	return &dto.WorkerResponse{
+		ID:        worker.ID,
+		Username:  worker.Username,
+		Fullname:  worker.Fullname,
+		Email:     worker.Email,
+		Verified:  worker.Verified,
+		CreatedAt: worker.CreatedAt.Format("2006-01-02 15:04:05"),
+	}, nil
+}
+
+func (s *authService) DeleteWorker(workerID uuid.UUID) error {
+	worker, err := s.userRepo.FindUserByID(workerID)
+	if err != nil {
+		return err
+	}
+	if worker == nil {
+		return errors.New("worker not found")
+	}
+	if worker.Role != entity.ROLE_WORKER {
+		return errors.New("user is not a worker")
+	}
+
+	return s.userRepo.DeleteUser(workerID)
+}