157 lines
3.4 KiB
Go
157 lines
3.4 KiB
Go
package license
|
|
|
|
import (
|
|
"furtuna-be/internal/common/errors"
|
|
"furtuna-be/internal/handlers/request"
|
|
"furtuna-be/internal/handlers/response"
|
|
"furtuna-be/internal/services"
|
|
"github.com/gin-gonic/gin"
|
|
"github.com/go-playground/validator/v10"
|
|
"net/http"
|
|
)
|
|
|
|
type Handler struct {
|
|
service services.License
|
|
}
|
|
|
|
func (h *Handler) Route(group *gin.RouterGroup, jwt gin.HandlerFunc) {
|
|
route := group.Group("/license")
|
|
|
|
route.POST("/", jwt, h.Create)
|
|
route.GET("/", jwt, h.GetAll)
|
|
route.PUT("/:id", jwt, h.Update)
|
|
route.GET("/:id", jwt, h.GetByID)
|
|
}
|
|
|
|
func NewHandler(service services.License) *Handler {
|
|
return &Handler{
|
|
service: service,
|
|
}
|
|
}
|
|
|
|
// Create handles the creation of a new license.
|
|
func (h *Handler) Create(c *gin.Context) {
|
|
ctx := request.GetMyContext(c)
|
|
|
|
var req request.License
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
response.ErrorWrapper(c, errors.ErrorBadRequest)
|
|
return
|
|
}
|
|
|
|
validate := validator.New()
|
|
if err := validate.Struct(req); err != nil {
|
|
response.ErrorWrapper(c, err)
|
|
return
|
|
}
|
|
|
|
licenseEntity, err := req.ToEntity()
|
|
if err != nil {
|
|
response.ErrorWrapper(c, err)
|
|
return
|
|
}
|
|
|
|
res, err := h.service.Create(ctx, licenseEntity)
|
|
if err != nil {
|
|
response.ErrorWrapper(c, err)
|
|
return
|
|
}
|
|
|
|
var licenseResponse response.License
|
|
licenseResponse.FromEntity(res)
|
|
|
|
c.JSON(http.StatusOK, response.BaseResponse{
|
|
Success: true,
|
|
Status: http.StatusOK,
|
|
Data: licenseResponse,
|
|
})
|
|
}
|
|
|
|
// Update handles the update of an existing license.
|
|
func (h *Handler) Update(c *gin.Context) {
|
|
ctx := request.GetMyContext(c)
|
|
|
|
licenseID := c.Param("id")
|
|
|
|
var req request.License
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
response.ErrorWrapper(c, errors.ErrorBadRequest)
|
|
return
|
|
}
|
|
|
|
validate := validator.New()
|
|
if err := validate.Struct(req); err != nil {
|
|
response.ErrorWrapper(c, err)
|
|
return
|
|
}
|
|
|
|
licenseEntity, err := req.ToEntity()
|
|
if err != nil {
|
|
response.ErrorWrapper(c, err)
|
|
return
|
|
}
|
|
|
|
updatedLicense, err := h.service.Update(ctx, licenseID, licenseEntity)
|
|
if err != nil {
|
|
response.ErrorWrapper(c, err)
|
|
return
|
|
}
|
|
|
|
var licenseResponse response.License
|
|
licenseResponse.FromEntity(updatedLicense)
|
|
|
|
c.JSON(http.StatusOK, response.BaseResponse{
|
|
Success: true,
|
|
Status: http.StatusOK,
|
|
Data: licenseResponse,
|
|
})
|
|
}
|
|
|
|
// GetAll retrieves a list of licenses.
|
|
func (h *Handler) GetAll(c *gin.Context) {
|
|
var req request.LicenseParam
|
|
if err := c.ShouldBindQuery(&req); err != nil {
|
|
response.ErrorWrapper(c, errors.ErrorBadRequest)
|
|
return
|
|
}
|
|
|
|
licenses, total, err := h.service.GetAll(c.Request.Context(), req.Limit, req.Offset)
|
|
if err != nil {
|
|
response.ErrorWrapper(c, err)
|
|
return
|
|
}
|
|
|
|
licenseResponses := response.FromEntityList(licenses)
|
|
|
|
c.JSON(http.StatusOK, response.BaseResponse{
|
|
Success: true,
|
|
Status: http.StatusOK,
|
|
Data: response.LicenseList{Licenses: licenseResponses, Total: total, Limit: req.Limit, Offset: req.Offset},
|
|
})
|
|
}
|
|
|
|
// GetByID retrieves details of a specific license by ID.
|
|
func (h *Handler) GetByID(c *gin.Context) {
|
|
licenseID := c.Param("id")
|
|
|
|
res, err := h.service.GetByID(c.Request.Context(), licenseID)
|
|
if err != nil {
|
|
c.JSON(http.StatusInternalServerError, response.BaseResponse{
|
|
Success: false,
|
|
Status: http.StatusInternalServerError,
|
|
Message: err.Error(),
|
|
Data: nil,
|
|
})
|
|
return
|
|
}
|
|
|
|
var licenseResponse response.License
|
|
licenseResponse.FromEntity(res)
|
|
|
|
c.JSON(http.StatusOK, response.BaseResponse{
|
|
Success: true,
|
|
Status: http.StatusOK,
|
|
Data: licenseResponse,
|
|
})
|
|
}
|