update order

internal/entity/order.go

@@ -30,6 +30,10 @@ type Order struct {
 	InProgressOrderID int64
 }
 
+func (o *Order) IsMemberOrder() bool {
+	return o.CustomerID != nil && *o.CustomerID > 0
+}
+
 type OrderDB struct {
 	Order
 }

internal/handlers/http/order.go

@@ -160,35 +160,35 @@ func (h *Handler) GetOrderHistory(c *gin.Context) {
 	startDateStr := c.Query("start_date")
 	endDateStr := c.Query("end_date")
 
-	// Build search request
 	searchReq := entity.SearchRequest{}
 
-	// Set status if provided
 	if status != "" {
 		searchReq.Status = status
 	}
 
-	// Parse and set limit
-	limit := 10
+	limit := 20
 	if limitStr != "" {
 		parsedLimit, err := strconv.Atoi(limitStr)
 		if err == nil && parsedLimit > 0 {
 			limit = parsedLimit
 		}
 	}
-	if limit > 20 {
-		limit = 20
+
+	if limit > 100 {
+		limit = 100
 	}
+
 	searchReq.Limit = limit
 
-	// Parse and set offset
 	offset := 0
+
 	if offsetStr != "" {
 		parsedOffset, err := strconv.Atoi(offsetStr)
 		if err == nil && parsedOffset >= 0 {
 			offset = parsedOffset
 		}
 	}
+
 	searchReq.Offset = offset
 
 	if startDateStr != "" {
@@ -228,6 +228,8 @@ func (h *Handler) GetOrderHistory(c *gin.Context) {
 		responseData = append(responseData, response.OrderHistoryResponse{
 			ID:           order.ID,
 			CustomerName: order.CustomerName,
+			CustomerID:   order.CustomerID,
+			IsMember:     order.IsMemberOrder(),
 			Status:       order.Status,
 			Amount:       order.Amount,
 			Total:        order.Total,

internal/handlers/response/order.go

@@ -190,6 +190,8 @@ type OrderDetailItem struct {
 
 type OrderHistoryResponse struct {
 	ID             int64               `json:"id"`
+	IsMember       bool                `json:"is_member"`
+	CustomerID     *int64              `json:"customer_id"`
 	CustomerName   string              `json:"customer_name"`
 	Status         string              `json:"status"`
 	Amount         float64             `json:"amount"`

internal/handlers/response/order_inquiry.go

@@ -102,14 +102,9 @@ func MapToOrderResponse(result *entity.OrderResponse) OrderResponse {
 func MapToOrderItemResponses(items []entity.OrderItem) []OrderItemResponse {
 	result := make([]OrderItemResponse, 0, len(items))
 	for _, item := range items {
-		productName := ""
-		if item.Product != nil {
-			productName = item.Product.Name
-		}
-
 		result = append(result, OrderItemResponse{
 			ProductID:   item.ItemID,
-			ProductName: productName,
+			ProductName: item.ItemName,
 			Price:       item.Price,
 			Quantity:    item.Quantity,
 			Subtotal:    item.Price * float64(item.Quantity),

internal/repository/orde_repo.go

@@ -100,7 +100,6 @@ func (r *orderRepository) Create(ctx mycontext.Context, order *entity.Order) (*e
 		item.ID = itemDB.ID
 	}
 
-	// Commit the transaction
 	if err := tx.Commit().Error; err != nil {
 		return nil, errors.Wrap(err, "failed to commit transaction")
 	}
@@ -254,6 +253,20 @@ func (r *orderRepository) toOrderDBModel(order *entity.Order) models.OrderDB {
 }
 
 func (r *orderRepository) toDomainOrderModel(dbModel *models.OrderDB) *entity.Order {
+
+	orderItems := make([]entity.OrderItem, 0, len(dbModel.OrderItems))
+	for _, itemDB := range dbModel.OrderItems {
+		orderItems = append(orderItems, entity.OrderItem{
+			ItemID:    itemDB.ItemID,
+			ItemType:  itemDB.ItemType,
+			ItemName:  itemDB.ItemName,
+			Price:     itemDB.Price,
+			Quantity:  itemDB.Quantity,
+			CreatedBy: itemDB.CreatedBy,
+			CreatedAt: itemDB.CreatedAt,
+		})
+	}
+
 	return &entity.Order{
 		ID:              dbModel.ID,
 		PartnerID:       dbModel.PartnerID,
@@ -268,7 +281,7 @@ func (r *orderRepository) toDomainOrderModel(dbModel *models.OrderDB) *entity.Or
 		CreatedBy:       dbModel.CreatedBy,
 		CreatedAt:       dbModel.CreatedAt,
 		UpdatedAt:       dbModel.UpdatedAt,
-		OrderItems:      []entity.OrderItem{},
+		OrderItems:      orderItems,
 		CustomerName:    dbModel.CustomerName,
 		TableNumber:     dbModel.TableNumber,
 		OrderType:       dbModel.OrderType,