apskel-pos-backend/internal/handlers/http/auth/auth.go

package auth

import (
	"enaklo-pos-be/internal/constants/role"
	"fmt"
	"net/http"
	"strings"

	"github.com/gin-gonic/gin"

	"enaklo-pos-be/internal/common/errors"
	auth2 "enaklo-pos-be/internal/handlers/request"
	"enaklo-pos-be/internal/handlers/response"
	"enaklo-pos-be/internal/services"
)

type AuthHandler struct {
	service services.Auth
}

func (a *AuthHandler) Route(group *gin.RouterGroup, jwt gin.HandlerFunc) {
	authRoute := group.Group("/auth")
	authRoute.POST("/login", a.AuthLogin)
	authRoute.POST("/forgot-password", a.ForgotPassword)
	authRoute.POST("/reset-password", jwt, a.ResetPassword)
}

func NewAuthHandler(service services.Auth) *AuthHandler {
	return &AuthHandler{
		service: service,
	}
}

// AuthLogin handles the authentication process for user login.
// @Summary User login
// @Description Authenticates a user based on the provided credentials and returns a JWT token.
// @Accept json
// @Produce json
// @Param bodyParam body auth2.LoginRequest true "User login credentials"
// @Success 200 {object} response.BaseResponse{data=response.LoginResponse} "Login successful"
// @Failure 400 {object} response.BaseResponse{data=errors.Error} "Bad request"
// @Failure 401 {object} response.BaseResponse{data=errors.Error} "Unauthorized"
// @Router /api/v1/auth/login [post]
// @Tags Auth Login API's
func (h *AuthHandler) AuthLogin(c *gin.Context) {
	var bodyParam auth2.LoginRequest
	if err := c.ShouldBindJSON(&bodyParam); err != nil {
		response.ErrorWrapper(c, errors.ErrorBadRequest)
		return
	}

	email := strings.ToLower(bodyParam.Email)
	authUser, err := h.service.AuthenticateUser(c, email, bodyParam.Password)
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	if authUser.UserType == "CUSTOMER" {
		response.ErrorWrapper(c, errors.ErrorUserIsNotFound)
		return
	}

	var partner *response.Partner
	var site *response.SiteName

	if authUser.RoleID != role.SuperAdmin {
		partner = &response.Partner{
			ID:     authUser.PartnerID,
			Name:   authUser.PartnerName,
			Status: authUser.PartnerStatus,
		}
	}

	if authUser.RoleID == role.Casheer || authUser.RoleID == role.SiteAdmin {
		site = &response.SiteName{
			ID:   authUser.SiteID,
			Name: authUser.SiteName,
		}
	}

	resp := response.LoginResponse{
		Token:   authUser.Token,
		Partner: partner,
		Name:    authUser.Name,
		Role: response.Role{
			ID:   int64(authUser.RoleID),
			Role: authUser.RoleName,
		},
		Site:          site,
		ResetPassword: authUser.ResetPassword,
		PartnerLicense: &response.PartnerLicense{
			DaysToExpire: authUser.PartnerLicense.DaysToExpire,
			Status:       authUser.PartnerLicense.LicenseStatus,
		},
	}

	c.JSON(http.StatusOK, response.BaseResponse{
		Success: true,
		Status:  http.StatusOK,
		Message: "Login Success",
		Data:    resp,
	})
}

// ForgotPassword handles the request for password reset.
// @Summary Request password reset
// @Description Sends a password reset link to the user's email.
// @Accept json
// @Produce json
// @Param bodyParam body auth2.ForgotPasswordRequest true "User email"
// @Success 200 {object} response.BaseResponse "Password reset link sent"
// @Failure 400 {object} response.BaseResponse{data=errors.Error} "Bad request"
// @Router /api/v1/auth/forgot-password [post]
// @Tags Auth Password API's
func (h *AuthHandler) ForgotPassword(c *gin.Context) {
	var bodyParam auth2.ResetPasswordRequest
	if err := c.ShouldBindJSON(&bodyParam); err != nil {
		response.ErrorWrapper(c, errors.ErrorBadRequest)
		return
	}

	err := h.service.SendPasswordResetLink(c, bodyParam.Email)
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	c.JSON(http.StatusOK, response.BaseResponse{
		Success: true,
		Status:  http.StatusOK,
		Message: "Password reset link sent",
	})
}

// ResetPassword handles the password reset process.
// @Summary Reset user password
// @Description Resets the user's password using the provided token.
// @Accept json
// @Produce json
// @Param bodyParam body auth2.ResetPasswordRequest true "Reset password details"
// @Success 200 {object} response.BaseResponse "Password reset successful"
// @Failure 400 {object} response.BaseResponse{data=errors.Error} "Bad request"
// @Router /api/v1/auth/reset-password [post]
// @Tags Auth Password API's
func (h *AuthHandler) ResetPassword(c *gin.Context) {
	ctx := auth2.GetMyContext(c)

	var req auth2.ResetPasswordChangeRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.ErrorWrapper(c, errors.ErrorBadRequest)
		return
	}

	if err := req.Validate(); err != nil {
		response.ErrorWrapper(c, errors.NewError(
			errors.ErrorBadRequest.ErrorType(),
			fmt.Sprintf("invalid request %v", err.Error())))
		return
	}

	err := h.service.ResetPassword(ctx, req.OldPassword, req.NewPassword)
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	c.JSON(http.StatusOK, response.BaseResponse{
		Success: true,
		Status:  http.StatusOK,
		Message: "Password reset successful",
	})
}