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"
	"net/http"
	"time"

	"github.com/gin-gonic/gin"
	"github.com/go-playground/validator/v10"
)

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)
	route.GET("/history", jwt, h.GetAllHistoryOrders)
	route.GET("/ticket-sold", jwt, h.CountSoldOfTicket)
	route.GET("/sum-amount", jwt, h.SumAmount)
	route.GET("/daily-sales", jwt, h.GetDailySalesTicket)
	route.GET("/payment-distribution", jwt, h.GetPaymentDistributionChart)
}

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,
			Name:     item.Product.Name,
		}
	}

	return response.CreateOrderResponse{
		ID:          order.ID,
		RefID:       order.RefID,
		PartnerID:   order.PartnerID,
		Status:      order.Status,
		Amount:      order.Amount,
		Total:       order.Total,
		Fee:         order.Fee,
		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,
			Name:     item.Product.Name,
		}
	}

	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,
		QRcode:       orderResponse.QRCode,
	}
}

func (h *Handler) toHistoryOrderResponse(resp *entity.HistoryOrder) response.HistoryOrder {
	return response.HistoryOrder{
		ID:          resp.ID,
		Employee:    resp.Employee,
		Site:        resp.Site,
		Timestamp:   resp.Timestamp.Format(time.RFC3339),
		BookingTime: resp.BookingTime.Format(time.RFC3339),
		Tickets:     resp.Tickets,
		PaymentType: resp.PaymentType,
		Status:      resp.Status,
		Amount:      resp.Amount,
		VisitDate:   resp.VisitDate.Format(time.RFC3339),
		TicketStatus: resp.TicketStatus,
		Source: resp.Source,
	}
}

func (h *Handler) SumAmount(c *gin.Context) {
	var req request.OrderParam
	if err := c.ShouldBindQuery(&req); err != nil {
		response.ErrorWrapper(c, errors.ErrorBadRequest)
		return
	}

	ctx := request.GetMyContext(c)
	order, err := h.service.SumAmount(ctx, req.ToOrderEntity(ctx))
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

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

func (h *Handler) GetAllHistoryOrders(c *gin.Context) {
	var req request.OrderParam
	if err := c.ShouldBindQuery(&req); err != nil {
		response.ErrorWrapper(c, errors.ErrorBadRequest)
		return
	}

	ctx := request.GetMyContext(c)
	orders, total, err := h.service.GetAllHistoryOrders(ctx, req.ToOrderEntity(ctx))
	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	c.JSON(http.StatusOK, response.BaseResponse{
		Success: true,
		Status:  http.StatusOK,
		Data:    h.toHistoryOrderList(orders, int64(total), req),
	})
}

func (h *Handler) CountSoldOfTicket(c *gin.Context) {
	var req request.OrderParam
	if err := c.ShouldBindQuery(&req); err != nil {
		response.ErrorWrapper(c, errors.ErrorBadRequest)
		return
	}

	ctx := request.GetMyContext(c)

	res, err := h.service.CountSoldOfTicket(ctx, req.ToOrderEntity(ctx))

	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	c.JSON(http.StatusOK, response.BaseResponse{
		Success: true,
		Status:  http.StatusOK,
		Data: response.TicketSold{
			Count: res.Count,
		},
	})
}

func (h *Handler) GetDailySalesTicket(c *gin.Context) {
	var req request.OrderParam
	if err := c.ShouldBindQuery(&req); err != nil {
		response.ErrorWrapper(c, errors.ErrorBadRequest)
		return
	}

	ctx := request.GetMyContext(c)

	resp, err := h.service.GetDailySales(ctx, req.ToOrderEntity(ctx))

	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	c.JSON(http.StatusOK, response.BaseResponse{
		Success: true,
		Status:  http.StatusOK,
		Data:    h.toDailySales(resp),
	})
}

func (h *Handler) GetPaymentDistributionChart(c *gin.Context) {
	var req request.OrderParam
	if err := c.ShouldBindQuery(&req); err != nil {
		response.ErrorWrapper(c, errors.ErrorBadRequest)
		return
	}

	ctx := request.GetMyContext(c)

	resp, err := h.service.GetPaymentDistribution(ctx, req.ToOrderEntity(ctx))

	if err != nil {
		response.ErrorWrapper(c, err)
		return
	}

	c.JSON(http.StatusOK, response.BaseResponse{
		Success: true,
		Status:  http.StatusOK,
		Data:    h.toPaymentDistributionChart(resp),
	})
}

func (h *Handler) toHistoryOrderList(resp []*entity.HistoryOrder, total int64, req request.OrderParam) response.HistoryOrderList {
	var orders []response.HistoryOrder
	for _, b := range resp {
		orders = append(orders, h.toHistoryOrderResponse(b))
	}

	return response.HistoryOrderList{
		Orders: orders,
		Total:  total,
		Limit:  req.Limit,
		Offset: req.Offset,
	}
}

func (h *Handler) toDailySales(resp []entity.ProductDailySales) []response.ProductDailySales {
	var dailySales []response.ProductDailySales
	for _, b := range resp {
		dailySales = append(dailySales, response.ProductDailySales{
			Day:         b.Day,
			SiteID:      b.SiteID,
			Total:       b.Total,
			SiteName:    b.SiteName,
			PaymentType: b.PaymentType,
		})
	}
	return dailySales
}

func (h *Handler) toPaymentDistributionChart(resp []entity.PaymentTypeDistribution) []response.PaymentDistribution {
	var dailySales []response.PaymentDistribution
	for _, b := range resp {
		dailySales = append(dailySales, response.PaymentDistribution{
			PaymentType: b.PaymentType,
			Count:       b.Count,
		})
	}
	return dailySales
}