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

package order

import (
	"furtuna-be/internal/common/errors"
	"furtuna-be/internal/entity"
	"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.Order
}

func (h *Handler) Route(group *gin.RouterGroup, jwt gin.HandlerFunc) {
	route := group.Group("/order")

	route.POST("/inquiry", jwt, h.Inquiry)
	route.POST("/execute", jwt, h.Execute)
}

func NewHandler(service services.Order) *Handler {
	return &Handler{
		service: service,
	}
}

func (h *Handler) Inquiry(c *gin.Context) {
	ctx := request.GetMyContext(c)

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

	if !ctx.IsCasheer() {
		response.ErrorWrapper(c, errors.ErrorBadRequest)
		return
	}

	// override the partner_id
	req.PartnerID = *ctx.GetPartnerID()

	validate := validator.New()
	if err := validate.Struct(req); err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	order, err := h.service.CreateOrder(ctx, req.ToEntity(ctx.RequestedBy()))
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	c.JSON(http.StatusOK, response.BaseResponse{
		Success: true,
		Status:  http.StatusOK,
		Data:    MapOrderToCreateOrderResponse(order),
	})
}

func (h *Handler) Execute(c *gin.Context) {
	ctx := request.GetMyContext(c)

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

	if !ctx.IsCasheer() {
		response.ErrorWrapper(c, errors.ErrorBadRequest)
		return
	}

	req.PartnerID = *ctx.GetPartnerID()

	validate := validator.New()
	if err := validate.Struct(req); err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	order, err := h.service.Execute(ctx, req.ToOrderExecuteRequest(ctx.RequestedBy()))
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	c.JSON(http.StatusOK, response.BaseResponse{
		Success: true,
		Status:  http.StatusOK,
		Data:    MapOrderToExecuteOrderResponse(order),
	})
}

func MapOrderToCreateOrderResponse(orderResponse *entity.OrderResponse) response.CreateOrderResponse {
	order := orderResponse.Order
	orderItems := make([]response.CreateOrderItemResponse, len(order.OrderItems))
	for i, item := range order.OrderItems {
		orderItems[i] = response.CreateOrderItemResponse{
			ID:       item.ID,
			ItemID:   item.ItemID,
			Quantity: item.Quantity,
			Price:    item.Price,
		}
	}

	return response.CreateOrderResponse{
		ID:          order.ID,
		RefID:       order.RefID,
		PartnerID:   order.PartnerID,
		Status:      order.Status,
		Amount:      order.Amount,
		PaymentType: order.PaymentType,
		CreatedAt:   order.CreatedAt,
		OrderItems:  orderItems,
		Token:       orderResponse.Token,
	}
}

func MapOrderToExecuteOrderResponse(orderResponse *entity.ExecuteOrderResponse) response.ExecuteOrderResponse {
	order := orderResponse.Order
	orderItems := make([]response.CreateOrderItemResponse, len(order.OrderItems))
	for i, item := range order.OrderItems {
		orderItems[i] = response.CreateOrderItemResponse{
			ID:       item.ID,
			ItemID:   item.ItemID,
			Quantity: item.Quantity,
			Price:    item.Price,
		}
	}

	return response.ExecuteOrderResponse{
		ID:           order.ID,
		RefID:        order.RefID,
		PartnerID:    order.PartnerID,
		Status:       order.Status,
		Amount:       order.Amount,
		PaymentType:  order.PaymentType,
		CreatedAt:    order.CreatedAt,
		OrderItems:   orderItems,
		PaymentToken: orderResponse.PaymentToken,
		RedirectURL:  orderResponse.RedirectURL,
	}
}