feat: amount transaction and count of item

internal/entity/order.go

@@ -18,6 +18,22 @@ type Order struct {
 	OrderItems  []OrderItem `gorm:"foreignKey:OrderID;constraint:OnDelete:CASCADE;"`
 }
 
+type OrderDB struct {
+	Order
+}
+
+func (b *Order) ToOrderDB() *OrderDB {
+	return &OrderDB{
+		Order: *b,
+	}
+}
+
+func (e *OrderDB) ToSumAmount() *Order {
+	return &Order{
+		Amount: e.Amount,
+	}
+}
+
 type OrderResponse struct {
 	Order *Order
 	Token string
@@ -99,11 +115,12 @@ type HistoryOrderDB struct {
 	HistoryOrder
 }
 
-type HistoryOrderSearch struct {
+type OrderSearch struct {
-	PartnerID *int64
+	PartnerID   *int64
-	IsAdmin   bool
+	IsAdmin     bool
-	Limit     int
+	PaymentType string
-	Offset    int
+	Limit       int
+	Offset      int
 }
 
 type HistoryOrderList []*HistoryOrderDB
@@ -136,3 +153,23 @@ func (b *HistoryOrderList) ToHistoryOrderList() []*HistoryOrder {
 	}
 	return HistoryOrders
 }
+
+type TicketSold struct {
+	Count int64 `gorm:"type:int;column:count"`
+}
+
+type TicketSoldDB struct {
+	TicketSold
+}
+
+func (b *TicketSold) ToTicketSoldDB() *TicketSoldDB {
+	return &TicketSoldDB{
+		TicketSold: *b,
+	}
+}
+
+func (e *TicketSoldDB) ToTicketSold() *TicketSold {
+	return &TicketSold{
+		Count: e.Count,
+	}
+}

internal/handlers/http/order/order.go

@@ -23,6 +23,8 @@ func (h *Handler) Route(group *gin.RouterGroup, jwt gin.HandlerFunc) {
 	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)
 }
 
 func NewHandler(service services.Order) *Handler {
@@ -169,15 +171,38 @@ func (h *Handler) toHistoryOrderResponse(resp *entity.HistoryOrder) response.His
 	}
 }
 
-func (h *Handler) GetAllHistoryOrders(c *gin.Context) {
+func (h *Handler) SumAmount(c *gin.Context) {
-	var req request.HistoryOrderParam
+	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.ToEntity(ctx))
+	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
@@ -190,7 +215,32 @@ func (h *Handler) GetAllHistoryOrders(c *gin.Context) {
 	})
 }
 
-func (h *Handler) toHistoryOrderList(resp []*entity.HistoryOrder, total int64, req request.HistoryOrderParam) response.HistoryOrderList {
+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) 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))

internal/handlers/http/sites/sites.go

@@ -261,7 +261,7 @@ func (h *Handler) Count(c *gin.Context) {
 
 	c.JSON(http.StatusOK, response.BaseResponse{
 		Success: true,
-		Status: http.StatusOK,
+		Status:  http.StatusOK,
 		Data: response.SiteCount{
 			Count: res.Count,
 		},

internal/handlers/request/order.go

@@ -12,15 +12,17 @@ type Order struct {
 	OrderItems    []OrderItem               `json:"order_items" validate:"required"`
 }
 
-type HistoryOrderParam struct {
+type OrderParam struct {
-	Limit  int `form:"limit" json:"limit" example:"10"`
+	PaymentType string `form:"payment_type" json:"payment_type" example:"CASH"`
-	Offset int `form:"offset" json:"offset" example:"0"`
+	Limit       int    `form:"limit" json:"limit" example:"10"`
+	Offset      int    `form:"offset" json:"offset" example:"0"`
 }
 
-func (o *HistoryOrderParam) ToEntity(ctx mycontext.Context) entity.HistoryOrderSearch {
+func (o *OrderParam) ToOrderEntity(ctx mycontext.Context) entity.OrderSearch {
-	return entity.HistoryOrderSearch{
+	return entity.OrderSearch{
 		PartnerID: ctx.GetPartnerID(),
 		IsAdmin:   ctx.IsAdmin(),
+		PaymentType: o.PaymentType,
 		Limit:     o.Limit,
 		Offset:    o.Offset,
 	}

internal/handlers/response/order.go

@@ -21,6 +21,10 @@ type Order struct {
 	UpdatedAt     string                    `json:"updated_at"`
 }
 
+type OrderAmount struct {
+	Amount float64 `json:"amount"`
+}
+
 type HistoryOrder struct {
 	ID          int64    `json:"id"`
 	Employee    string   `json:"employee"`
@@ -58,6 +62,10 @@ type HistoryOrderList struct {
 	Offset int            `json:"offset"`
 }
 
+type TicketSold struct {
+	Count int64 `json:"count"`
+}
+
 type OrderMonthlyRevenue struct {
 	TotalRevenue     float64 `json:"total_revenue"`
 	TotalTransaction int64   `json:"total_transaction"`

internal/repository/orders/order.go

@@ -3,8 +3,10 @@ package orders
 import (
 	"context"
 	"furtuna-be/internal/common/logger"
+	"furtuna-be/internal/common/mycontext"
 	"furtuna-be/internal/entity"
 	"strings"
+	"time"
 
 	"go.uber.org/zap"
 	"gorm.io/gorm"
@@ -83,7 +85,7 @@ func (r *OrderRepository) Update(ctx context.Context, order *entity.Order) (*ent
 	return order, nil
 }
 
-func (b *OrderRepository) GetAllHystoryOrders(ctx context.Context, req entity.HistoryOrderSearch) (entity.HistoryOrderList, int, error) {
+func (b *OrderRepository) GetAllHystoryOrders(ctx context.Context, req entity.OrderSearch) (entity.HistoryOrderList, int, error) {
 	var orders []*entity.HistoryOrderDB
 	var total int64
 
@@ -128,3 +130,47 @@ func (b *OrderRepository) GetAllHystoryOrders(ctx context.Context, req entity.Hi
 
 	return orders, int(total), nil
 }
+
+func (r *OrderRepository) CountSoldOfTicket(ctx mycontext.Context, req entity.OrderSearch) (*entity.TicketSoldDB, error) {
+	today := time.Now().Format("2006-01-02")
+	ticketCount := new(entity.TicketSoldDB)
+
+	query := r.db.Table("orders").
+		Select("sum(items.qty) as count").
+		Joins("left join order_items items on orders.id = items.order_id").
+		Where("orders.status = ?", "PAID").
+		Where("orders.created_at = ?", today)
+
+	if !req.IsAdmin {
+		query = query.Where("orders.partner_id = ?", req.PartnerID)
+	}
+
+	if err := query.Scan(&ticketCount).Error; err != nil {
+		logger.ContextLogger(ctx).Error("error when get count ticket", zap.Error(err))
+		return nil, err
+	}
+
+	return ticketCount, nil
+}
+
+func (r *OrderRepository) SumAmount(ctx mycontext.Context, req entity.OrderSearch) (*entity.OrderDB, error) {
+	amount := new(entity.OrderDB)
+	today := time.Now().Format("2006-01-02")
+
+	query := r.db.Table("orders").
+		Select("sum(amount) as amount").
+		Where("payment_type = ?", req.PaymentType).
+		Where("date(created_at) = ?", today).
+		Where("status = ?", "PAID")
+
+	if !req.IsAdmin {
+		query = query.Where("orders.partner_id = ?", req.PartnerID)
+	}
+
+	if err := query.Scan(&amount).Error; err != nil {
+		logger.ContextLogger(ctx).Error("error when get cash amount", zap.Error(err))
+		return nil, err
+	}
+
+	return amount, nil
+}

internal/repository/repository.go

@@ -132,7 +132,9 @@ type Order interface {
 	FindByID(ctx context.Context, id int64) (*entity.Order, error)
 	Update(ctx context.Context, order *entity.Order) (*entity.Order, error)
 	SetOrderStatus(ctx context.Context, db *gorm.DB, orderID int64, status string) error
-	GetAllHystoryOrders(ctx context.Context, req entity.HistoryOrderSearch) (entity.HistoryOrderList, int, error)
+	GetAllHystoryOrders(ctx context.Context, req entity.OrderSearch) (entity.HistoryOrderList, int, error)
+	SumAmount(ctx mycontext.Context, req entity.OrderSearch) (*entity.OrderDB, error)
+	CountSoldOfTicket(ctx mycontext.Context, req entity.OrderSearch) (*entity.TicketSoldDB, error)
 }
 
 type OSSRepository interface {

internal/services/order/order.go

@@ -298,7 +298,7 @@ func (s *OrderService) updateWalletBalance(ctx context.Context, tx *gorm.DB, par
 	return err
 }
 
-func (s *OrderService) GetAllHistoryOrders(ctx mycontext.Context, req entity.HistoryOrderSearch) ([]*entity.HistoryOrder, int, error) {
+func (s *OrderService) GetAllHistoryOrders(ctx mycontext.Context, req entity.OrderSearch) ([]*entity.HistoryOrder, int, error) {
 	historyOrders, total, err := s.repo.GetAllHystoryOrders(ctx, req)
 	if err != nil {
 		logger.ContextLogger(ctx).Error("error when get all history orders", zap.Error(err))
@@ -309,3 +309,29 @@ func (s *OrderService) GetAllHistoryOrders(ctx mycontext.Context, req entity.His
 
 	return data, total, nil
 }
+
+func (s OrderService) CountSoldOfTicket(ctx mycontext.Context, req entity.OrderSearch) (*entity.TicketSold, error) {
+	ticket, err := s.repo.CountSoldOfTicket(ctx, req)
+
+	if err != nil {
+		logger.ContextLogger(ctx).Error("error when get all history orders", zap.Error(err))
+		return nil, err
+	}
+
+	data := ticket.ToTicketSold()
+
+	return data, nil
+}
+
+func (s OrderService) SumAmount(ctx mycontext.Context, req entity.OrderSearch) (*entity.Order, error) {
+	amount, err := s.repo.SumAmount(ctx, req)
+
+	if err != nil {
+		logger.ContextLogger(ctx).Error("error when get amount cash orders", zap.Error(err))
+		return nil, err
+	}
+
+	data := amount.ToSumAmount()
+
+	return data, nil
+}

internal/services/service.go

@@ -101,7 +101,9 @@ type Order interface {
 	CreateOrder(ctx context.Context, req *entity.OrderRequest) (*entity.OrderResponse, error)
 	Execute(ctx context.Context, req *entity.OrderExecuteRequest) (*entity.ExecuteOrderResponse, error)
 	ProcessCallback(ctx context.Context, req *entity.CallbackRequest) error
-	GetAllHistoryOrders(ctx mycontext.Context, req entity.HistoryOrderSearch) ([]*entity.HistoryOrder, int, error)
+	GetAllHistoryOrders(ctx mycontext.Context, req entity.OrderSearch) ([]*entity.HistoryOrder, int, error)
+	CountSoldOfTicket(ctx mycontext.Context, req entity.OrderSearch) (*entity.TicketSold, error)
+	SumAmount(ctx mycontext.Context, req entity.OrderSearch) (*entity.Order, error)
 }
 
 type OSSService interface {