iloom/auth-service/internal/handler/auth.go

package handler

import (
	"net/http"

	"github.com/gin-gonic/gin"
	"github.com/muyuqingfeng/iloom/auth-service/internal/model"
	"github.com/muyuqingfeng/iloom/auth-service/internal/service"
	"github.com/muyuqingfeng/iloom/shared/pkg/response"
)

type AuthHandler struct {
	svc *service.AuthService
}

func NewAuthHandler(svc *service.AuthService) *AuthHandler {
	return &AuthHandler{svc: svc}
}

type RegisterRequest struct {
	Username    string `json:"username" binding:"required"`
	Password    string `json:"password" binding:"required,min=6"`
	CompanyName string `json:"company_name" binding:"required"`
	Role        string `json:"role" binding:"required,oneof=purchaser textile washing"`
}

type LoginRequest struct {
	Username string `json:"username" binding:"required"`
	Password string `json:"password" binding:"required"`
}

type LoginResponse struct {
	AccessToken  string         `json:"access_token"`
	RefreshToken string         `json:"refresh_token"`
	User         *model.Profile `json:"user"`
	Company      *model.Company `json:"company"`
}

type RefreshRequest struct {
	RefreshToken string `json:"refresh_token" binding:"required"`
}

func (h *AuthHandler) Register(c *gin.Context) {
	var req RegisterRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.BadRequest(c, err.Error())
		return
	}

	svcReq := service.RegisterRequest{
		Username:    req.Username,
		Password:    req.Password,
		CompanyName: req.CompanyName,
		Role:        req.Role,
	}

	result, err := h.svc.Register(c.Request.Context(), svcReq)
	if err != nil {
		response.Error(c, http.StatusConflict, response.ErrCodeBadRequest, err.Error())
		return
	}

	response.OK(c, result)
}

func (h *AuthHandler) Login(c *gin.Context) {
	var req LoginRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.BadRequest(c, err.Error())
		return
	}

	result, err := h.svc.Login(c.Request.Context(), req.Username, req.Password)
	if err != nil {
		response.Unauthorized(c, err.Error())
		return
	}

	response.OK(c, result)
}

func (h *AuthHandler) Logout(c *gin.Context) {
	response.OK(c, gin.H{"message": "logged out"})
}

func (h *AuthHandler) Refresh(c *gin.Context) {
	var req RefreshRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		response.BadRequest(c, err.Error())
		return
	}

	accessToken, err := h.svc.RefreshToken(c.Request.Context(), req.RefreshToken)
	if err != nil {
		response.Unauthorized(c, err.Error())
		return
	}

	response.OK(c, gin.H{"access_token": accessToken})
}

func (h *AuthHandler) Me(c *gin.Context) {
	userID := c.GetHeader("X-User-ID")
	if userID == "" {
		response.Unauthorized(c, "user id not found")
		return
	}

	result, err := h.svc.GetMe(c.Request.Context(), userID)
	if err != nil {
		response.NotFound(c, err.Error())
		return
	}

	response.OK(c, result)
}