cardverse-be/internal/modules/auth/handler.go

package auth

import (
	"errors"
	"net/http"

	"cardverse/internal/pkg/response"
	"cardverse/internal/pkg/validator"

	"github.com/gin-gonic/gin"
)

type Handler struct {
	service Service
}

func NewHandler(service Service) *Handler {
	return &Handler{service: service}
}

func (h *Handler) Register(c *gin.Context) {
	var req RegisterRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Error(c, http.StatusBadRequest, "input tidak valid", validator.TranslateError(err))
		return
	}

	u, token, err := h.service.Register(req)
	if err != nil {
		if errors.Is(err, ErrPasswordMismatch) {
			response.Error(c, http.StatusBadRequest, err.Error(), nil)
			return
		}
		if errors.Is(err, ErrEmailAlreadyExists) {
			response.Error(c, http.StatusConflict, err.Error(), nil)
			return
		}
		response.Error(c, http.StatusInternalServerError, "gagal mendaftar akun", err.Error())
		return
	}

	response.Success(c, http.StatusCreated, "registrasi berhasil, silakan verifikasi email anda", gin.H{
		"user_id":            u.ID,
		"email":              u.Email,
		"verification_token": token,
	})
}

func (h *Handler) Login(c *gin.Context) {
	var req LoginRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Error(c, http.StatusBadRequest, "input tidak valid", validator.TranslateError(err))
		return
	}

	result, err := h.service.Login(req)
	if err != nil {
		if errors.Is(err, ErrInvalidCredentials) {
			response.Error(c, http.StatusUnauthorized, err.Error(), nil)
			return
		}
		if errors.Is(err, ErrAccountSuspended) {
			response.Error(c, http.StatusForbidden, err.Error(), nil)
			return
		}
		response.Error(c, http.StatusInternalServerError, "gagal login", err.Error())
		return
	}

	response.Success(c, http.StatusOK, "login berhasil", result)
}

func (h *Handler) GoogleLogin(c *gin.Context) {
	var req GoogleLoginRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Error(c, http.StatusBadRequest, "input tidak valid", validator.TranslateError(err))
		return
	}

	result, err := h.service.GoogleLogin(req)
	if err != nil {
		if errors.Is(err, ErrGoogleVerificationFailed) {
			response.Error(c, http.StatusUnauthorized, err.Error(), nil)
			return
		}
		if errors.Is(err, ErrAccountSuspended) {
			response.Error(c, http.StatusForbidden, err.Error(), nil)
			return
		}
		response.Error(c, http.StatusInternalServerError, "gagal login via google", err.Error())
		return
	}

	response.Success(c, http.StatusOK, "login via google berhasil", result)
}

func (h *Handler) RefreshToken(c *gin.Context) {
	var req RefreshTokenRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Error(c, http.StatusBadRequest, "input tidak valid", validator.TranslateError(err))
		return
	}

	result, err := h.service.RefreshToken(req)
	if err != nil {
		if errors.Is(err, ErrAccountSuspended) {
			response.Error(c, http.StatusForbidden, err.Error(), nil)
			return
		}
		response.Error(c, http.StatusUnauthorized, err.Error(), nil)
		return
	}

	response.Success(c, http.StatusOK, "token berhasil diperbarui", result)
}

func (h *Handler) Logout(c *gin.Context) {
	var req LogoutRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Error(c, http.StatusBadRequest, "input tidak valid", validator.TranslateError(err))
		return
	}

	if err := h.service.Logout(req.RefreshToken); err != nil {
		response.Error(c, http.StatusInternalServerError, "gagal logout", err.Error())
		return
	}

	response.Success(c, http.StatusOK, "logout berhasil", nil)
}

func (h *Handler) VerifyEmail(c *gin.Context) {
	var req VerifyEmailRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Error(c, http.StatusBadRequest, "input tidak valid", validator.TranslateError(err))
		return
	}

	if err := h.service.VerifyEmail(req.Token); err != nil {
		response.Error(c, http.StatusBadRequest, err.Error(), nil)
		return
	}

	response.Success(c, http.StatusOK, "email berhasil diverifikasi", nil)
}

func (h *Handler) ForgotPassword(c *gin.Context) {
	var req ForgotPasswordRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Error(c, http.StatusBadRequest, "input tidak valid", validator.TranslateError(err))
		return
	}

	resetToken, err := h.service.ForgotPassword(req.Email)
	if err != nil {
		response.Error(c, http.StatusNotFound, err.Error(), nil)
		return
	}

	response.Success(c, http.StatusOK, "instruksi reset password telah dikirim", gin.H{
		"reset_token": resetToken,
	})
}

func (h *Handler) ResetPassword(c *gin.Context) {
	var req ResetPasswordRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.Error(c, http.StatusBadRequest, "input tidak valid", validator.TranslateError(err))
		return
	}

	if err := h.service.ResetPassword(req); err != nil {
		if errors.Is(err, ErrPasswordMismatch) {
			response.Error(c, http.StatusBadRequest, err.Error(), nil)
			return
		}
		response.Error(c, http.StatusBadRequest, err.Error(), nil)
		return
	}

	response.Success(c, http.StatusOK, "password berhasil diperbarui", nil)
}