Add multiple items to cart (#3117)

Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: cp-at-mit

ecommerce/api.py

@@ -253,7 +253,14 @@ def apply_user_discounts(request):
     if BasketDiscount.objects.filter(redeemed_basket=basket).count() > 0:
         return
 
-    product = BasketItem.objects.get(basket=basket).product
+    # For multiple items, check each item for flexible pricing discounts
+    basket_items = BasketItem.objects.filter(basket=basket)
+    if basket_items.count() == 0:
+        return
+
+    # Use the first item's product for flexible pricing determination
+    # This maintains backward compatibility while supporting multiple items
+    product = basket_items.first().product
     flexible_price_discount = determine_courseware_flexible_price_discount(
         product, user
     )

ecommerce/models.py

@@ -198,7 +198,7 @@ def get_products(self):
         Returns the products that have been added to the basket so far.
         """
 
-        return [item.product for item in self.basket_items.all()]
+        return [item.product for item in self.basket_items.select_related("product")]
 
 
 class BasketItem(TimestampedModel):

ecommerce/serializers.py

@@ -178,7 +178,7 @@ def get_basket_items(self, instance):
         """Get items in the basket"""
         return [
             BasketItemSerializer(instance=basket, context=self.context).data
-            for basket in instance.basket_items.all()
+            for basket in instance.basket_items.select_related("product")
         ]
 
     class Meta:
@@ -263,14 +263,15 @@ def get_basket_items(self, instance) -> list[dict[str, any]]:
         """
         return [
             BasketItemWithProductSerializer(instance=basket, context=self.context).data
-            for basket in instance.basket_items.all()
+            for basket in instance.basket_items.select_related("product")
         ]
 
     @extend_schema_field(Decimal)
     def get_total_price(self, instance) -> Decimal:
         """Get total price of all items in basket before discounts"""
         return sum(
-            basket_item.base_price for basket_item in instance.basket_items.all()
+            basket_item.base_price
+            for basket_item in instance.basket_items.select_related("product")
         )
 
     @extend_schema_field(Decimal)
@@ -280,7 +281,8 @@ def get_discounted_price(self, instance) -> Decimal:
         if discounts.count() == 0:
             return self.get_total_price(instance)
         return sum(
-            basket_item.discounted_price for basket_item in instance.basket_items.all()
+            basket_item.discounted_price
+            for basket_item in instance.basket_items.select_related("product")
         )
 
     @extend_schema_field(list[BasketDiscountSerializer])

ecommerce/tests/test_multiple_cart_items.py

@@ -0,0 +1,136 @@
+"""Tests for multiple cart items functionality"""
+
+import pytest
+from django.test import override_settings
+from django.urls import reverse
+from rest_framework import status
+
+from ecommerce.factories import BasketFactory, BasketItemFactory, ProductFactory
+
+
+@pytest.mark.django_db
+class TestMultipleCartItems:
+    """Test class for multiple cart items functionality"""
+
+    @override_settings(ENABLE_MULTIPLE_CART_ITEMS=False)
+    def test_add_to_cart_single_item_mode_default(self, user_drf_client, user):
+        """Test that with feature flag disabled, adding items replaces existing items"""
+        # Create a product and basket with existing item
+        existing_product = ProductFactory.create()
+        new_product = ProductFactory.create()
+
+        basket = BasketFactory.create(user=user)
+        BasketItemFactory.create(basket=basket, product=existing_product)
+
+        assert basket.basket_items.count() == 1
+
+        # Add new product to cart
+        response = user_drf_client.post(
+            reverse("checkout_api-add_to_cart"),
+            data={"product_id": new_product.id},
+        )
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data["message"] == "Product added to cart"
+
+        # Verify that only the new product is in the basket
+        basket.refresh_from_db()
+        assert basket.basket_items.count() == 1
+        assert basket.basket_items.first().product == new_product
+
+    @override_settings(ENABLE_MULTIPLE_CART_ITEMS=True)
+    def test_add_to_cart_multiple_items_mode_new_product(self, user_drf_client, user):
+        """Test that with feature flag enabled, adding new items keeps existing items"""
+        # Create products and basket with existing item
+        existing_product = ProductFactory.create()
+        new_product = ProductFactory.create()
+
+        basket = BasketFactory.create(user=user)
+        BasketItemFactory.create(basket=basket, product=existing_product)
+
+        assert basket.basket_items.count() == 1
+
+        # Add new product to cart
+        response = user_drf_client.post(
+            reverse("checkout_api-add_to_cart"),
+            data={"product_id": new_product.id},
+        )
+
+        assert response.status_code == status.HTTP_200_OK
+        assert response.data["message"] == "Product added to cart"
+
+        # Verify that both products are in the basket
+        basket.refresh_from_db()
+        assert basket.basket_items.count() == 2
+        products_in_basket = {item.product for item in basket.basket_items.all()}
+        assert products_in_basket == {existing_product, new_product}
+
+    @override_settings(ENABLE_MULTIPLE_CART_ITEMS=True)
+    def test_add_to_cart_nonexistent_product(self, user_drf_client):
+        """Test that adding a non-existent product returns 404"""
+        # Add non-existent product to cart
+        response = user_drf_client.post(
+            reverse("checkout_api-add_to_cart"),
+            data={"product_id": 99999},
+        )
+
+        assert response.status_code == status.HTTP_404_NOT_FOUND
+        assert response.data["message"] == "Product not found"
+
+    @override_settings(ENABLE_MULTIPLE_CART_ITEMS=True)
+    def test_cart_with_multiple_items_pricing(self, user_drf_client, user):
+        """Test that cart pricing works correctly with multiple items"""
+        # Create products with different prices
+        product1 = ProductFactory.create(price=50.00)
+        product2 = ProductFactory.create(price=30.00)
+
+        basket = BasketFactory.create(user=user)
+        BasketItemFactory.create(basket=basket, product=product1, quantity=2)
+        BasketItemFactory.create(basket=basket, product=product2, quantity=1)
+
+        # Get cart info
+        response = user_drf_client.get(reverse("checkout_api-cart"))
+
+        assert response.status_code == status.HTTP_200_OK
+        cart_data = response.data
+
+        # Verify total price calculation (2 * $50 + 1 * $30 = $130)
+        assert float(cart_data["total_price"]) == 130.00
+        assert len(cart_data["basket_items"]) == 2
+
+    def test_basket_items_count_endpoint(self, user_drf_client, user):
+        """Test that basket items count endpoint works with multiple items"""
+        # Create products and add to basket
+        product1 = ProductFactory.create()
+        product2 = ProductFactory.create()
+
+        basket = BasketFactory.create(user=user)
+        BasketItemFactory.create(basket=basket, product=product1, quantity=2)
+        BasketItemFactory.create(basket=basket, product=product2, quantity=1)
+
+        # Get basket items count
+        response = user_drf_client.get(reverse("checkout_api-basket_items_count"))
+
+        assert response.status_code == status.HTTP_200_OK
+        # Should return count of distinct items, not total quantity
+        assert response.data == 2
+
+    @override_settings(ENABLE_MULTIPLE_CART_ITEMS=False)
+    def test_existing_basket_item_viewset_still_works(self, user_drf_client, user):
+        """Test that the existing BasketItemViewSet still works regardless of feature flag"""
+        product1 = ProductFactory.create()
+        product2 = ProductFactory.create()
+
+        basket = BasketFactory.create(user=user)
+        BasketItemFactory.create(basket=basket, product=product1)
+
+        # Add item using the existing ViewSet endpoint
+        response = user_drf_client.post(
+            f"/api/baskets/{basket.id}/items/",
+            data={"product": product2.id},
+        )
+
+        assert response.status_code == status.HTTP_201_CREATED
+
+        # Verify both items are in basket
+        assert basket.basket_items.count() == 2

ecommerce/views/v0/__init__.py

@@ -647,17 +647,44 @@ def add_to_cart(self, request):
             basket, _ = Basket.objects.select_for_update().get_or_create(
                 user=self.request.user
             )
-            basket.basket_items.all().delete()
-            BasketDiscount.objects.filter(redeemed_basket=basket).delete()
 
-            all_product_ids = [request.data["product_id"]]
+            # Check if multiple cart items feature is enabled
+            allow_multiple_items = getattr(
+                settings, "ENABLE_MULTIPLE_CART_ITEMS", False
+            )
 
-            for product in Product.objects.filter(id__in=all_product_ids):
+            if not allow_multiple_items:
+                # Legacy behavior: clear existing items and discounts
+                basket.basket_items.all().delete()
+                BasketDiscount.objects.filter(redeemed_basket=basket).delete()
+            else:
+                # New behavior: only clear discounts, keep existing items
+                BasketDiscount.objects.filter(redeemed_basket=basket).delete()
+
+            product_id = request.data["product_id"]
+
+            try:
+                product = Product.objects.get(id=product_id)
+            except Product.DoesNotExist:
+                return Response(
+                    {"message": "Product not found"},
+                    status=status.HTTP_404_NOT_FOUND,
+                )
+            message = "Product already in cart"
+            if allow_multiple_items:
+                # Check if product already exists in basket
+                if not basket.basket_items.filter(product=product).exists():
+                    # Add new item to basket
+                    BasketItem.objects.create(basket=basket, product=product)
+                    message = "Product added to cart"
+            else:
+                # Legacy behavior: add single item
                 BasketItem.objects.create(basket=basket, product=product)
+                message = "Product added to cart"
 
         return Response(
             {
-                "message": "Product added to cart",
+                "message": message,
             }
         )
 

ecommerce/views_test.py

@@ -739,6 +739,46 @@ def test_checkout_product_with_program_id(user, user_client):
     assert [item.product for item in basket.basket_items.all()] == [product]
 
 
+@pytest.mark.parametrize("multiple_cart_enabled", [True, False])
+def test_add_to_cart_api_with_feature_flag(
+    user_drf_client, user, multiple_cart_enabled, settings
+):
+    """Test add_to_cart API behavior with and without multiple cart items feature"""
+    settings.ENABLE_MULTIPLE_CART_ITEMS = multiple_cart_enabled
+
+    # Create products
+    product1 = ProductFactory.create()
+    product2 = ProductFactory.create()
+
+    # Add first product
+    resp = user_drf_client.post(
+        reverse("checkout_api-add_to_cart"),
+        data={"product_id": product1.id},
+    )
+    assert resp.status_code == 200
+
+    basket = Basket.objects.get(user=user)
+    assert basket.basket_items.count() == 1
+
+    # Add second product
+    resp = user_drf_client.post(
+        reverse("checkout_api-add_to_cart"),
+        data={"product_id": product2.id},
+    )
+    assert resp.status_code == 200
+
+    basket.refresh_from_db()
+    if multiple_cart_enabled:
+        # Should have both products
+        assert basket.basket_items.count() == 2
+        products_in_basket = {item.product for item in basket.basket_items.all()}
+        assert products_in_basket == {product1, product2}
+    else:
+        # Should only have the second product (legacy behavior)
+        assert basket.basket_items.count() == 1
+        assert basket.basket_items.first().product == product2
+
+
 def test_discount_rest_api(admin_drf_client, user_drf_client):
     """
     Checks that the admin REST API is only accessible by an admin

frontend/public/src/flow/declarations.js

@@ -12,6 +12,7 @@ declare type Settings = {
   recaptchaKey: ?string,
   support_email: string,
   features: {
+    enable_multiple_cart_items?: boolean
   },
   site_name: string,
   zendesk_config: {

main/features.py

@@ -3,5 +3,6 @@
 IGNORE_EDX_FAILURES = "IGNORE_EDX_FAILURES"
 SYNC_ON_DASHBOARD_LOAD = "SYNC_ON_DASHBOARD_LOAD"
 ENABLE_AUTO_DAILY_FEATURED_ITEMS = "mitxonline-auto-daily-featured-items"
+ENABLE_MULTIPLE_CART_ITEMS = "ENABLE_MULTIPLE_CART_ITEMS"
 
 ENABLE_GOOGLE_ANALYTICS_DATA_PUSH = "mitxonline-4099-dedp-google-analytics"

main/settings.py

@@ -939,6 +939,14 @@
     dev_only=True,
     description="The default value for all feature flags",
 )
+
+# Multiple cart items feature flag
+ENABLE_MULTIPLE_CART_ITEMS = get_bool(
+    name="ENABLE_MULTIPLE_CART_ITEMS",
+    default=False,
+    description="Enable users to add multiple items to their cart/basket",
+)
+
 FEATURES = get_features()
 
 # Redis