B2B Provisioning: Add user/contract FKs, user provisioning on purchase (#2645)

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

Author: jkachel

b2b/admin.py

@@ -0,0 +1,8 @@
+"""B2B model admin. Only for convenience; you should use the Wagtail interface instead."""
+
+from django.contrib import admin
+
+from b2b.models import ContractPage, OrganizationPage
+
+admin.site.register(OrganizationPage)
+admin.site.register(ContractPage)

b2b/api.py

@@ -12,6 +12,7 @@
 from b2b.models import ContractPage, OrganizationIndexPage, OrganizationPage
 from cms.api import get_home_page
 from courses.models import Course, CourseRun
+from ecommerce.api import establish_basket
 from ecommerce.models import Product
 from main.utils import date_to_datetime
 
@@ -133,3 +134,79 @@ def create_contract_run(
         )
 
     return course_run, course_run_product
+
+
+def validate_basket_for_b2b_purchase(request) -> bool:
+    """
+    Validate the basket for a B2B purchase.
+
+    This function checks if the basket is valid for a B2B purchase. It ensures
+    that the basket contains only products that are part of a contract and that
+    the contract is active.
+
+    When SSO integrations are implemented, this will need to be revised since
+    it'll fail those baskets (unless we create orders for those completely
+    differently).
+
+    Args:
+        request: The HTTP request object containing the basket data.
+
+    Returns: bool
+    """
+
+    basket = establish_basket(request)
+    if not basket:
+        return False
+
+    basket_contracts = []
+    course_run_content_type = ContentType.objects.get_for_model(CourseRun)
+
+    # This system only supports one item per basket, but this is done so it can
+    # be lifted out and into UE later (which supports >1 item).
+
+    for item in (
+        basket.basket_items.filter(product__content_type=course_run_content_type)
+        .prefetch_related(
+            "product",
+            "product__purchasable_object",
+            "product__purchasable_object__b2b_contract",
+        )
+        .all()
+    ):
+        contract = item.product.purchasable_object.b2b_contract
+
+        if contract and contract.is_active:
+            basket_contracts.append(contract)
+
+    if len(basket_contracts) == 0:
+        # No contracts in the basket, so we don't need to check further.
+        # The other validity checks that run before will make sure the discount
+        # applies to the basket products.
+        return True
+
+    discounts_with_contracts = (
+        basket.discounts.filter(
+            redeemed_discount__products__product__content_type=course_run_content_type
+        )
+        .prefetch_related(
+            "redeemed_discount",
+            "redeemed_discount__products",
+            "redeemed_discount__products__product__purchasable_object",
+            "redeemed_discount__products__product__purchasable_object__b2b_contract",
+        )
+        .distinct()
+        .all()
+    )
+
+    if len(discounts_with_contracts) != len(basket_contracts):
+        # We should have a code for each contract in the basket.
+        return False
+
+    for discount_item in discounts_with_contracts:
+        for discount_product in discount_item.redeemed_discount.products.all():
+            contract = discount_product.product.purchasable_object.b2b_contract
+
+            if contract and contract.is_active and contract in basket_contracts:
+                return True
+
+    return False

b2b/api_test.py

@@ -7,9 +7,13 @@
 from mitol.common.utils import now_in_utc
 
 from b2b import factories
-from b2b.api import create_contract_run
+from b2b.api import create_contract_run, validate_basket_for_b2b_purchase
 from b2b.constants import B2B_RUN_TAG_FORMAT
+from b2b.factories import ContractPageFactory
 from courses.factories import CourseFactory
+from ecommerce.api_test import create_basket
+from ecommerce.factories import ProductFactory, UnlimitedUseDiscountFactory
+from ecommerce.models import BasketDiscount, DiscountProduct
 from main.utils import date_to_datetime
 
 FAKE = faker.Factory.create()
@@ -73,3 +77,71 @@ def test_create_single_course_run(mocker, has_start, has_end):
         assert run.enrollment_end is None
 
     assert product.purchasable_object == run
+
+
+@pytest.mark.parametrize(
+    (
+        "run_contract",
+        "apply_code",
+    ),
+    [
+        (False, False),
+        (False, True),
+        (True, False),
+        (True, True),
+    ],
+)
+def test_b2b_basket_validation(user, run_contract, apply_code):
+    """
+    Test that a basket is validated correctly for B2B contracts.
+
+    Basically, if the user is adding a product that links to a course run that
+    is also linked to a contract, we need to have also applied the discount code
+    that matches the product, or we shouldn't be allowed to buy it.
+
+    The truth table for this should be:
+
+    | run_contract | apply_code | result |
+    |--------------|------------|--------|
+    | False        | False      | True   |
+    | False        | True       | True   |
+    | True         | False      | False  |
+    | True         | True       | True  |
+    """
+
+    product = ProductFactory.create()
+    discount = UnlimitedUseDiscountFactory.create()
+    discount_product = DiscountProduct.objects.create(
+        discount=discount, product=product
+    )
+    discount_product.save()
+    discount.products.add(discount_product)
+
+    if run_contract:
+        contract = ContractPageFactory.create()
+
+        product.purchasable_object.b2b_contract = contract
+        product.purchasable_object.save()
+        product.refresh_from_db()
+
+    basket = create_basket(user, [product])
+
+    if apply_code:
+        redemption = BasketDiscount(
+            redemption_date=now_in_utc(),
+            redeemed_by=user,
+            redeemed_discount=discount,
+            redeemed_basket=basket,
+        )
+
+        redemption.save()
+        basket.refresh_from_db()
+
+    check_result = validate_basket_for_b2b_purchase(basket)
+
+    if run_contract and not apply_code:
+        # User is trying to buy something that's linked to a contract but hasn't
+        # applied the code, so this should be false.
+        assert check_result is False
+    else:
+        assert check_result is True

b2b/serializers/v0/__init__.py

@@ -5,55 +5,61 @@
 from b2b.models import ContractPage, OrganizationPage
 
 
-class OrganizationPageSerializer(serializers.ModelSerializer):
+class ContractPageSerializer(serializers.ModelSerializer):
     """
-    Serializer for the OrganizationPage model.
+    Serializer for the ContractPage model.
     """
 
     class Meta:
-        model = OrganizationPage
+        model = ContractPage
         fields = [
             "id",
             "name",
             "description",
-            "logo",
+            "integration_type",
+            "organization",
+            "contract_start",
+            "contract_end",
+            "active",
             "slug",
+            "organization",
         ]
         read_only_fields = [
             "id",
             "name",
             "description",
-            "logo",
+            "integration_type",
+            "organization",
+            "contract_start",
+            "contract_end",
+            "active",
             "slug",
+            "organization",
         ]
 
 
-class ContractPageSerializer(serializers.ModelSerializer):
+class OrganizationPageSerializer(serializers.ModelSerializer):
     """
-    Serializer for the ContractPage model.
+    Serializer for the OrganizationPage model.
     """
 
+    contracts = ContractPageSerializer(many=True, read_only=True)
+
     class Meta:
-        model = ContractPage
+        model = OrganizationPage
         fields = [
             "id",
             "name",
             "description",
-            "integration_type",
-            "organization",
-            "contract_start",
-            "contract_end",
-            "active",
+            "logo",
             "slug",
+            "contracts",
         ]
         read_only_fields = [
             "id",
             "name",
             "description",
-            "integration_type",
-            "organization",
-            "contract_start",
-            "contract_end",
-            "active",
+            "logo",
             "slug",
+            "contracts",
         ]

courses/api.py

@@ -196,6 +196,12 @@ def _enroll_learner_into_associated_programs():
 
             _enroll_learner_into_associated_programs()
 
+            # If the run is associated with a B2B contract, add the contract
+            # to the user's contract list
+            if run.b2b_contract:
+                user.b2b_contracts.add(run.b2b_contract)
+                user.save()
+
             if not created:
                 enrollment_mode_changed = mode != enrollment.enrollment_mode
                 enrollment.edx_enrolled = edx_request_success

courses/management/commands/create_courseware.py

@@ -77,13 +77,13 @@ def _create_departments(self, departments: List[str]) -> models.QuerySet:  # noq
             models.QuerySet: Query set containing all of the departments specified
                 in the list of department names.
         """
-        add_depts = Department.objects.filter(name__in=departments.split()).all()
-        for dept in departments.split():
+        add_depts = Department.objects.filter(name__in=departments).all()
+        for dept in departments:
             found = len([db_dept for db_dept in add_depts if db_dept.name == dept]) > 0
             if not found:
                 Department.objects.create(name=dept)
 
-        return Department.objects.filter(name__in=departments.split()).all()
+        return Department.objects.filter(name__in=departments).all()
 
     def _department_must_be_defined_error(self):
         """

ecommerce/api.py

@@ -3,7 +3,9 @@
 import logging
 import uuid
 from decimal import Decimal
+from urllib.parse import urljoin
 
+from django.conf import settings
 from django.core.exceptions import ObjectDoesNotExist, PermissionDenied, ValidationError
 from django.db import transaction
 from django.db.models import Q
@@ -57,7 +59,11 @@
 log = logging.getLogger(__name__)
 
 
-def generate_checkout_payload(request):
+def generate_checkout_payload(request):  # noqa: PLR0911
+    """Generate the checkout payload for the current basket."""
+
+    from b2b.api import validate_basket_for_b2b_purchase
+
     basket = establish_basket(request)
 
     if basket.has_user_blocked_products(request.user):
@@ -99,6 +105,15 @@ def generate_checkout_payload(request):
             ),
         }
 
+    if not validate_basket_for_b2b_purchase(request):
+        return {
+            "invalid_discounts": True,
+            "response": redirect_with_user_message(
+                reverse("cart"),
+                {"type": USER_MSG_TYPE_DISCOUNT_INVALID},
+            ),
+        }
+
     order = PendingOrder.create_from_basket(basket)
     total_price = 0
 
@@ -141,7 +156,7 @@ def generate_checkout_payload(request):
                 ),
             }
 
-    callback_uri = request.build_absolute_uri(reverse("checkout-result-callback"))
+    callback_uri = urljoin(settings.SITE_BASE_URL, reverse("checkout-result-callback"))
     payload = PaymentGateway.start_payment(
         ECOMMERCE_DEFAULT_PAYMENT_GATEWAY,
         gateway_order,