add function to add item

internal/handlers/http/inprogress_order.go

@@ -25,6 +25,7 @@ func NewInProgressOrderHandler(service inprogress_order.InProgressOrderService)
 func (h *InProgressOrderHandler) Route(group *gin.RouterGroup, jwt gin.HandlerFunc) {
 	route := group.Group("/inprogress-order")
 	route.POST("/save", jwt, h.Save)
+	route.POST("/add", jwt, h.Add)
 	route.GET("/list", jwt, h.GetByPartnerID)
 }
 
@@ -41,6 +42,11 @@ type CreateInProgressOrderRequest struct {
 	InProgressOrderID   int64                        `json:"in_progress_order_id"`
 }
 
+type AddItemOrderRequest struct {
+	OrderItems        []InProgressOrderItemRequest `json:"order_items" validate:"required,min=1,dive"`
+	InProgressOrderID int64                        `json:"in_progress_order_id"`
+}
+
 type InProgressOrderItemRequest struct {
 	ProductID int64 `json:"product_id" validate:"required"`
 	Quantity  int   `json:"quantity" validate:"required,min=1"`
@@ -104,6 +110,41 @@ func (h *InProgressOrderHandler) Save(c *gin.Context) {
 	})
 }
 
+func (h *InProgressOrderHandler) Add(c *gin.Context) {
+	ctx := request.GetMyContext(c)
+
+	var req AddItemOrderRequest
+	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
+	}
+
+	orderItems := make([]entity.OrderItemRequest, len(req.OrderItems))
+	for i, item := range req.OrderItems {
+		orderItems[i] = entity.OrderItemRequest{
+			ProductID: item.ProductID,
+			Quantity:  item.Quantity,
+		}
+	}
+
+	_, err := h.service.AddItems(ctx, req.InProgressOrderID, orderItems)
+	if err != nil {
+		response.ErrorWrapper(c, err)
+		return
+	}
+
+	c.JSON(http.StatusCreated, response.BaseResponse{
+		Success: true,
+		Status:  http.StatusCreated,
+	})
+}
+
 func mapToInProgressOrderResponse(order *entity.Order) map[string]interface{} {
 	orderItems := make([]map[string]interface{}, len(order.OrderItems))
 	for i, item := range order.OrderItems {

internal/services/v2/inprogress_order/in_progress_order.go

@@ -14,9 +14,11 @@ type InProgressOrderService interface {
 	Save(ctx mycontext.Context, order *entity.OrderRequest) (*entity.Order, error)
 	GetOrdersByPartnerID(ctx mycontext.Context, partnerID int64, limit, offset int) ([]*entity.Order, error)
 	GetOrderByOrderAndPartnerID(ctx mycontext.Context, partnerID int64, orderID int64) (*entity.Order, error)
+	AddItems(ctx mycontext.Context, orderID int64, newItems []entity.OrderItemRequest) (*entity.Order, error)
 }
 
 type OrderRepository interface {
+	FindByID(ctx mycontext.Context, id int64) (*entity.Order, error)
 	CreateOrUpdate(ctx mycontext.Context, order *entity.Order) (*entity.Order, error)
 	GetListByPartnerID(ctx mycontext.Context, partnerID int64, limit, offset int, status string) ([]*entity.Order, error)
 	FindByIDAndPartnerID(ctx mycontext.Context, id int64, partnerID int64) (*entity.Order, error)
@@ -124,6 +126,50 @@ func (s *inProgressOrderSvc) GetOrdersByPartnerID(ctx mycontext.Context, partner
 	return orders, nil
 }
 
+func (s *inProgressOrderSvc) AddItems(ctx mycontext.Context, orderID int64, newItems []entity.OrderItemRequest) (*entity.Order, error) {
+	existingOrder, err := s.repo.FindByID(ctx, orderID)
+	if err != nil {
+		return nil, errors.Wrapf(err, "failed to fetch order %d", orderID)
+	}
+
+	itemMap := make(map[int64]entity.OrderItemRequest, len(existingOrder.OrderItems)+len(newItems))
+
+	for _, oi := range existingOrder.OrderItems {
+		itemMap[oi.ItemID] = entity.OrderItemRequest{
+			ProductID: oi.ItemID,
+			Quantity:  oi.Quantity,
+		}
+	}
+
+	for _, ni := range newItems {
+		if existing, found := itemMap[ni.ProductID]; found {
+			existing.Quantity += ni.Quantity
+			itemMap[ni.ProductID] = existing
+		} else {
+			itemMap[ni.ProductID] = ni
+		}
+	}
+
+	mergedItems := make([]entity.OrderItemRequest, 0, len(itemMap))
+	for _, item := range itemMap {
+		mergedItems = append(mergedItems, item)
+	}
+
+	req := &entity.OrderRequest{
+		ID:           existingOrder.ID,
+		PartnerID:    existingOrder.PartnerID,
+		CustomerID:   existingOrder.CustomerID,
+		CustomerName: existingOrder.CustomerName,
+		CreatedBy:    existingOrder.CreatedBy,
+		TableNumber:  existingOrder.TableNumber,
+		OrderType:    existingOrder.OrderType,
+		Source:       existingOrder.Source,
+		OrderItems:   mergedItems,
+	}
+
+	return s.Save(ctx, req)
+}
+
 func (s *inProgressOrderSvc) GetOrderByOrderAndPartnerID(ctx mycontext.Context, partnerID int64, orderID int64) (*entity.Order, error) {
 	orders, err := s.repo.FindByIDAndPartnerID(ctx, orderID, partnerID)
 	if err != nil {