dj-shop-cart

https://tobi-de.github.io/dj-shop-cart
Admin
A simple and flexible cart manager for your Django projects, allowing users to add, remove,...
Tokens:8,401
Snippets:57
Trust Score:8.3
Update:10 months ago
Show doc for...
Tokens:
Raw
### Install dj-shop-cart using pip

Source: https://tobi-de.github.io/dj-shop-cart/index

Installs the dj-shop-cart library using pip. Ensure you have pip or poetry installed for package management.

```bash
pip install dj-shop-cart
```

--------------------------------

### Install Development Dependencies with Poetry

Source: https://tobi-de.github.io/dj-shop-cart/index

Installs project dependencies and pre-commit hooks using Poetry, which is the recommended package manager for development.

```bash
poetry install
pre-commit install --install-hooks
```

--------------------------------

### Install Project with Development Requirements

Source: https://tobi-de.github.io/dj-shop-cart/contributing

Installs the dj-shop-cart project along with its development dependencies using Poetry. This command ensures that all necessary tools and libraries for development and testing are available in your environment.

```shell
poetry install
```

--------------------------------

### Managing Multiple Carts

Source: https://tobi-de.github.io/dj-shop-cart/usage

Explains how to manage multiple distinct carts simultaneously using the `prefix` argument and provides an example using `functools.partial` for convenience.

```APIDOC
## Managing Multiple Carts

### Description
Demonstrates how to manage multiple carts concurrently using the `prefix` argument when creating cart instances. Includes an example using `functools.partial` for easier instantiation.

### Usage

Use the `prefix` argument in `Cart.new()` to differentiate between multiple carts stored under the same backend.

### Request Example
```python
from django.http import HttpRequest
from dj_shop_cart.cart import Cart
from products.models import Product # Assuming Product model exists
from functools import partial

def manage_multiple_carts(request: HttpRequest):
    product_a = Product.objects.get(id=1)
    product_b = Product.objects.get(id=2)

    # Managing two carts explicitly
    cart_a = Cart.new(request, prefix="cart_a")
    cart_a.add(product_a, quantity=10)
    assert product_a in cart_a

    cart_b = Cart.new(request, prefix="cart_b")
    cart_b.add(product_b, quantity=10)
    assert product_b in cart_b

    assert product_a not in cart_b
    assert product_b not in cart_a

    # Using functools.partial for convenience
    get_cart_a = partial(Cart.new, prefix="cart_a")
    cart_a_partial = get_cart_a(request)
    cart_a_partial.add(product_a, quantity=5)
```

### Response Example
*Success Response (200)*

Operations related to multiple carts typically modify the storage and do not return specific data in the response body, confirming successful addition or checking of items across carts.
```

--------------------------------

### Django Views for Cart Operations (Add, Remove, Empty)

Source: https://tobi-de.github.io/dj-shop-cart/index

Provides example Django views for adding products to the cart, removing products, and emptying the cart. These views utilize the Cart class from dj_shop_cart.

```python
# views.py

from dj_shop_cart.cart import get_cart_class
from django.http import HttpRequest
from django.views.decorators.http import require_POST
from django.shortcuts import get_object_or_404

from .models import Product

Cart = get_cart_class()


@require_POST
def add_product(request: HttpRequest, product_id:int):
    product = get_object_or_404(Product.objects.all(), pk=product_id)
    quantity = int(request.POST.get("quantity"))
    cart = Cart.new(request)
    cart.add(product, quantity=quantity)
    ...


@require_POST
def remove_product(request: HttpRequest):
    item_id = request.POST.get("item_id")
    quantity = int(request.POST.get("quantity"))
    cart = Cart.new(request)
    cart.remove(item_id=item_id, quantity=quantity)
    ...


@require_POST
def empty_cart(request: HttpRequest):
    Cart.new(request).empty()
    ...

```

--------------------------------

### Install Git Hooks for Linting and Formatting

Source: https://tobi-de.github.io/dj-shop-cart/contributing

Sets up pre-commit as a Git hook to automatically run linting and code formatting checks before each commit. This ensures that all code contributions adhere to the project's style guidelines and maintain code quality.

```shell
pre-commit --install
```

--------------------------------

### Django Cart Operations Example

Source: https://tobi-de.github.io/dj-shop-cart/usage

Demonstrates common operations on a Cart instance, including adding items, finding items, checking counts, updating metadata, and using various utility methods.

```python
def my_view(request):
    cart = Cart.new(request)
    # by looping through the cart, we return all the CartItem objects.
    for item in cart:
        print(item.subtotal)

    # find items based on product_pk, cart item id, variant details, quantity, etc.
    item = cart.find_one(product_pk=1)[0]
    assert item in cart

    # the number of items in the cart
    print(cart.count)

    # the number of unique items
    print(cart.unique_count)

    # calling len on the cart returns the number of unique items in the cart, regardless of the quantity.
    print(len(cart))

    # attach some metadata to the cart
    cart.update_metadata({"discount": "10%"})

```

--------------------------------

### Managing Multiple Carts with Prefixes

Source: https://tobi-de.github.io/dj-shop-cart/usage

Shows how to manage separate carts for the same user using the 'prefix' argument when creating a Cart instance. It includes direct instantiation and using functools.partial for convenience.

```python
cart_a = Cart.new(request, prefix="cart_a")
cart_a.add(product_a, quantity=10)
assert product_a in cart_a

cart_b = Cart.new(request, prefix="cart_b")
cart_b.add(product_b, quantity=10)
assert product_b in cart_b

assert product_a not in cart_b
assert product_b not in cart_a

```

```python
from functools import partial

get_cart_a = partial(Cart.new, prefix="cart_a")
cart_a = get_cart_a(request)
cart_a.add(product_a, quantity=10)

```

--------------------------------

### Instantiate a new cart

Source: https://tobi-de.github.io/dj-shop-cart/usage

Creates a new cart instance and loads existing data from the specified storage backend.

```APIDOC
## POST /cart/new

### Description
Instantiates a new cart and loads existing data via the specified storage backend.

### Method
POST

### Endpoint
`/cart/new`

### Parameters
#### Query Parameters
None

#### Request Body
None

### Request Example
```python
from dj_shop_cart.cart import get_cart_class
from django.http import HttpRequest

Cart = get_cart_class()
def view(request: HttpRequest):
    cart = Cart.new(request)
    ...
```

### Response
#### Success Response (200)
- **cart** (object) - The newly created cart object.

#### Response Example
```json
{
  "cart_id": "some_unique_cart_id",
  "items": []
}
```
```

--------------------------------

### Django Settings and Model Configuration for dj-shop-cart

Source: https://tobi-de.github.io/dj-shop-cart/index

Configures Django settings to include the cart context processor and defines a Product model with a required get_price method for dj-shop-cart integration.

```python
# settings.py

TEMPLATES = [
    {
        "OPTIONS": {
            "context_processors": [
                ...,
                "dj_shop_cart.context_processors.cart", # If you want access to the cart instance in all templates
            ],
        },
    }
]

# models.py

from django.db import models
from dj_shop_cart.cart import CartItem
from dj_shop_cart.protocols import Numeric

class Product(models.Model):
    ...

    def get_price(self, item:CartItem) -> Numeric:
        """The only requirements of the dj_shop_cart package apart from the fact that the products you add
        to the cart must be instances of django based models. You can use a different name for this method
        but be sure to update the corresponding setting (see Configuration). Even if you change the name the
        function signature should match this one.
        """

```

--------------------------------

### Run Full Test Suite

Source: https://tobi-de.github.io/dj-shop-cart/contributing

Executes the complete test suite for the dj-shop-cart project using pytest. This command verifies the integrity and correctness of the codebase, ensuring that all unit tests pass and code coverage remains at 100%.

```shell
pytest
```

--------------------------------

### Add Product to Cart with Django

Source: https://tobi-de.github.io/dj-shop-cart/usage

Demonstrates how to add a product to the shopping cart using the `cart.add` method. This method accepts the product instance, quantity, optional variant details for product variations, an override flag, and serializable metadata.

```python
cart.add(product, quantity=20)
```

--------------------------------

### Define a Custom Storage Backend Protocol for dj-shop-cart

Source: https://tobi-de.github.io/dj-shop-cart/usage

Outlines the protocol for creating a custom storage backend for dj-shop-cart. A custom backend must implement `load`, `save`, and `clear` methods, and have an `HttpRequest` attribute. This allows for flexible storage solutions, such as a Redis-based backend.

```python
from typing import Protocol

from django.http import HttpRequest

class Storage(Protocol):
    request: HttpRequest

    def load(self) -> list[dict]:
        ...

    def save(self, items: list[dict]) -> None:
        ...

    def clear(self) -> None:
        ...
```

--------------------------------

### Storage Backend Options

Source: https://tobi-de.github.io/dj-shop-cart/usage

Information on the available storage backends for persisting cart data, including SessionStorage and DBStorage.

```APIDOC
## Storage Backend

### Description
Explains the storage backends used to persist cart data. Two default backends are provided: `SessionStorage` and `DBStorage`.

### SessionStorage

*Details about SessionStorage would go here, explaining how it uses user sessions to store cart data.*

### DBStorage

*Details about DBStorage would go here, explaining how it uses the database to store cart data.*

### Request Example
```python
# Example demonstrating the default usage of SessionStorage (implicitly used)
from django.http import HttpRequest
from dj_shop_cart.cart import Cart

def use_session_storage(request: HttpRequest):
    # When Cart.new is called without a specific storage backend configured, 
    # it typically defaults to SessionStorage.
    cart = Cart.new(request)
    cart.add(product, quantity=1)
    # The cart data will be stored in the user's session.
```

### Response Example
*Success Response (200)*

Storage backend operations are typically internal and do not return specific API responses. Their success is indicated by the cart's persistence across requests or user sessions.
```

--------------------------------

### Add a product to the cart

Source: https://tobi-de.github.io/dj-shop-cart/usage

Adds a product to the shopping cart with specified quantity and optional variant details and metadata.

```APIDOC
## POST /cart/add

### Description
Adds a product to the cart. If the product already exists, its quantity can be updated or overridden.

### Method
POST

### Endpoint
`/cart/add`

### Parameters
#### Query Parameters
None

#### Request Body
- **product** (object) - Required - An instance of a database product.
- **quantity** (integer) - Optional - The quantity to add. Defaults to 1.
- **variant** (any) - Optional - Product variation details to uniquely identify items. Can be a dictionary, set, integer, or string.
- **override_quantity** (boolean) - Optional - If `True`, replaces the existing quantity instead of adding to it. Defaults to `False`.
- **metadata** (object) - Optional - JSON serializable metadata to attach to the cart item.

### Request Example
```python
# Assuming 'product_instance' is a product object and 'cart' is a cart instance
cart.add(product_instance, quantity=20, variant={'color': 'red'}, override_quantity=False, metadata={'user_note': 'Please deliver quickly'})
```

### Response
#### Success Response (200)
- **cart_item** (object) - The added or updated cart item.

#### Response Example
```json
{
  "item_id": "unique_item_identifier",
  "product_id": "product_identifier",
  "quantity": 20,
  "variant": {"color": "red"},
  "metadata": {"user_note": "Please deliver quickly"}
}
```
```

--------------------------------

### Instantiate New Cart with Django

Source: https://tobi-de.github.io/dj-shop-cart/usage

This snippet shows how to instantiate a new cart instance using the `get_cart_class` function and the `Cart.new` method. It requires a Django HttpRequest object and utilizes the configured storage backend to load existing cart data.

```python
from dj_shop_cart.cart import get_cart_class
from django.http import HttpRequest

Cart = get_cart_class()

def view(request: HttpRequest):
    cart = Cart.new(request)
    ...
```

--------------------------------

### Configuration

Source: https://tobi-de.github.io/dj-shop-cart/usage

Configure the cart's behavior by setting various options in your Django settings. All settings are optional.

```APIDOC
## Configuration

Configure the cart behaviour in your Django settings. All settings are optional and must be strings if defined.

| Name                       | Description                                                                                                                               | Default                      |
|----------------------------|-------------------------------------------------------------------------------------------------------------------------------------------|------------------------------|
| `CART_SESSION_KEY`         | The key used to store the cart in session                                                                                                 | `CART-ID`                    |
| `CART_CLASS`               | The path to the `Cart` class to use. If you are using a custom class it must subclass `dj_shop_cart.cart.Cart`                                | `dj_shop_cart.cart.Cart`     |
| `CART_PRODUCT_GET_PRICE_METHOD` | The method name to use to dynamically get the price on the product instance                                                                  | `get_price`                  |
| `CART_STORAGE_BACKEND`     | The path to the storage backend to use. If you define a custom storage backend, it should follow the `Storage` protocol, see the **Backend Storage section** below | `dj_shop_cart.storages.SessionStorage` |
| `CART_CACHE_TIMEOUT`       | The cache timeout when using the **CartStorage** backend, default to 5 days.                                                              | `60 * 60 * 24 * 5`           |
```

--------------------------------

### Cart Instance Attributes and Methods

Source: https://tobi-de.github.io/dj-shop-cart/usage

This section details the attributes and methods available on a Cart instance, including how to access cart details, find items, and modify cart metadata.

```APIDOC
## Cart Instance Attributes and Methods

### Description
Provides details on the attributes and methods of a `Cart` instance, such as accessing total cost, item counts, and managing metadata.

### Attributes
- **total** : The total cost of the cart.
- **is_empty** : A boolean value indicating whether the cart is empty or not.
- **count** : The number of items in the cart, that's the sum of quantities.
- **unique_count** : The number of unique items in the cart, regardless of the quantity.
- **products** : A list of associated products.
- **metadata** : A dictionary containing the metadata of the cart.

### Methods
- **empty(clear_metadata=True)** : Empty the cart. Takes an optional argument `clear_metadata` that defaults to `True`, if set to `False` the metadata of the cart will not be cleared.
- **update_metadata(metadata:dict)** : Update the metadata of the cart.
- **clear_metadata(*keys:list[str])** : Clear the metadata of the cart. Takes an optional list of keys to clear, if no keys are specified, all metadata is cleared.
- **find(**criteria)** : Returns a list of cart items matching the given criteria.
- **find_one(**criteria)** : Returns the first cart item that matches the given criteria, if no match is found return None.
- **variants_group_by_product()** : Return a dictionary with the products ids as keys and a list of variant as values.

### Request Example
```python
# Example usage within a Django view
from django.http import HttpRequest
from dj_shop_cart.cart import Cart

def my_view(request: HttpRequest):
    cart = Cart.new(request)
    # by looping through the cart, we return all the CartItem objects.
    for item in cart:
        print(item.subtotal)

    # find items based on product_pk, cart item id, variant details, quantity, etc.
    item = cart.find_one(product_pk=1)
    if item:
        assert item in cart

    # the number of items in the cart
    print(cart.count)

    # the number of unique items
    print(cart.unique_count)

    # calling len on the cart returns the number of unique items in the cart, regardless of the quantity.
    print(len(cart))

    # attach some metadata to the cart
    cart.update_metadata({"discount": "10%"})
```

### Response Example
```json
{
  "total": 120.50,
  "is_empty": false,
  "count": 5,
  "unique_count": 3,
  "products": [
    {
      "id": 1,
      "name": "Sample Product",
      "price": 20.00,
      "quantity": 2
    }
  ],
  "metadata": {
    "discount": "10%"
  }
}
```
```

--------------------------------

### Classmethods of Cart

Source: https://tobi-de.github.io/dj-shop-cart/usage

Details the class methods for creating and managing cart instances, including creating new carts and emptying all carts for a user.

```APIDOC
## Classmethods of Cart

### Description
Details the class methods for creating and managing cart instances, including creating new carts and emptying all carts for a user.

### Methods
- **new(request: HttpRequest, prefix="default")** : Create a new cart instance and load existing data from the storage backend.
- **empty_all(request: HttpRequest)** : Empty all carts for the current user.

### Request Example
```python
from django.http import HttpRequest
from dj_shop_cart.cart import Cart

def create_cart(request: HttpRequest):
    # Create a new cart with the default prefix
    cart = Cart.new(request)
    
    # Create a new cart with a specific prefix
    custom_cart = Cart.new(request, prefix="special_offer")

def clear_all_user_carts(request: HttpRequest):
    # Empty all carts associated with the current user
    Cart.empty_all(request)
```

### Response Example
*Success Response (200)*

This method typically does not return a response body but modifies the cart storage.

*Emptying all carts might not return a specific value but confirms the operation completion through absence of carts.*
```

--------------------------------

### Custom Cart Class Implementation

Source: https://tobi-de.github.io/dj-shop-cart/usage

Illustrates how to create a custom Cart class by extending the base DjCart class. This allows overriding methods like `before_add`, `after_add`, `before_remove`, and `after_remove` to customize cart behavior.

```python
# settings.py
CART_CLASS = "your_project.somewhere_in_your_project.Cart"

# somewhere_in_your_project.py
from dj_shop_cart.cart import CartItem, Cart as DjCart


class Cart(DjCart):

    def before_add(self, item: CartItem, quantity: int) -> None:
        pass

    def after_add(self, item: CartItem) -> None:
        pass

    def before_remove(self, item: CartItem | None = None, quantity: int | None = None) -> None:
        pass

    def after_remove(self, item: CartItem | None = None) -> None:
        pass

```

--------------------------------

### Custom Cart Class

Source: https://tobi-de.github.io/dj-shop-cart/usage

Explains how to define and use a custom Cart class by overriding specific methods for fine-grained control over the add/remove processes.

```APIDOC
## Custom Cart Class

### Description
Details how to implement a custom Cart class by overriding `before_add`, `after_add`, `before_remove`, and `after_remove` methods to customize cart behavior during item additions and removals.

### Configuration

Set the `CART_CLASS` setting in your Django `settings.py` to the path of your custom cart class.

```python
# settings.py
CART_CLASS = "your_project.somewhere_in_your_project.Cart"
```

### Customization Methods

- **before_add(self, item: CartItem, quantity: int) -> None** : Hook called before an item is added to the cart.
- **after_add(self, item: CartItem) -> None** : Hook called after an item has been added to the cart.
- **before_remove(self, item: CartItem | None = None, quantity: int | None = None) -> None** : Hook called before an item is removed from the cart.
- **after_remove(self, item: CartItem | None = None) -> None** : Hook called after an item has been removed from the cart.

### Request Example
```python
# somewhere_in_your_project.py
from dj_shop_cart.cart import CartItem, Cart as DjCart

class CustomCart(DjCart):

    def before_add(self, item: CartItem, quantity: int) -> None:
        print(f"About to add {quantity} of {item.product.name} to the cart.")
        # Custom logic before adding, e.g., check stock
        if item.product.stock < quantity:
            raise ValueError("Not enough stock available.")

    def after_add(self, item: CartItem) -> None:
        print(f"{item.product.name} added to the cart.")
        # Custom logic after adding, e.g., trigger an event
        # track_event('item_added_to_cart', item.product.id)

    def before_remove(self, item: CartItem | None = None, quantity: int | None = None) -> None:
        print(f"About to remove {quantity} of {item.product.name} from the cart.")
        # Custom logic before removing

    def after_remove(self, item: CartItem | None = None) -> None:
        print(f"{item.product.name} removed from the cart.")
        # Custom logic after removing
```

### Response Example
*Success Response (200)*

Customization methods are hooks and do not return specific data. Their effects are observed in the cart's state changes or through any side effects they trigger (e.g., logging, event dispatching).
```

--------------------------------

### Configure SessionStorage for dj-shop-cart

Source: https://tobi-de.github.io/dj-shop-cart/usage

Sets the cart storage backend to SessionStorage, which uses Django's session app. Carts are stored temporarily within the user's session and are lost when the session ends. This is the default backend if none is specified.

```python
# settings.py

CART_STORAGE_BACKEND = "dj_shop_cart.storages.SessionStorage"
```

--------------------------------

### Configure CacheStorage for dj-shop-cart

Source: https://tobi-de.github.io/dj-shop-cart/usage

Configures dj-shop-cart to use CacheStorage, recommended for storing carts beyond user sessions, especially for authenticated users. It leverages Django's cache framework for potentially faster storage than database-dependent methods. Cart data for unauthenticated users is retained temporarily, and a timeout can be configured using CART_CACHE_TIMEOUT.

```python
# settings.py

CART_STORAGE_BACKEND = "dj_shop_cart.storages.CacheStorage"
```

--------------------------------

### Configure DBStorage for dj-shop-cart

Source: https://tobi-de.github.io/dj-shop-cart/usage

Enables DBStorage for dj-shop-cart, persisting carts in the database exclusively for authenticated users. It uses SessionStorage for unauthenticated users and transitions to database storage upon authentication. Only one cart object is associated with a user at a time, and cart data is not auto-deleted from the database.

```python
# settings.py

INSTALLED_APPS = [
    ...,
    "dj_shop_cart",
    ...,
]

CART_STORAGE_BACKEND = "dj_shop_cart.storages.DBStorage"
```

--------------------------------

### CartItem Properties

Source: https://tobi-de.github.io/dj-shop-cart/usage

Describes the properties available on a `CartItem` object, including its unique ID, price, subtotal, associated product, variant, and metadata.

```APIDOC
## Properties of CartItem

### Description
Details the properties of a `CartItem` object, providing information about individual items within the cart.

### Properties
- **id** : A unique id for the item.
- **price** : The item price calculated via the `get_price` method.
- **subtotal** : Item price x quantity.
- **product** : The associated product.
- **variant** : Variant info specified when the product was added to the cart, default to `None`, is used to compare items in the cart.
- **metadata** : A dictionary containing the metadata specified when the product was added to the cart, not used when comparing two cart items.

### Request Example
```python
from django.http import HttpRequest
from dj_shop_cart.cart import Cart

def get_cart_item_details(request: HttpRequest):
    cart = Cart.new(request)
    # Assuming cart has items, get the first one for demonstration
    if cart:
        first_item = next(iter(cart))
        
        item_id = first_item.id
        item_price = first_item.price
        item_subtotal = first_item.subtotal
        associated_product = first_item.product
        variant_info = first_item.variant
        item_metadata = first_item.metadata
        
        print(f"Item ID: {item_id}")
        print(f"Price: {item_price}")
        print(f"Subtotal: {item_subtotal}")
        print(f"Product Name: {associated_product.name}") # Assuming product has a name attribute
        print(f"Variant: {variant_info}")
        print(f"Metadata: {item_metadata}")
```

### Response Example
```json
{
  "id": "a1b2c3d4",
  "price": 25.50,
  "subtotal": 76.50,
  "product": {
    "id": 1,
    "name": "Example Product",
    "sku": "EXMPL-001"
  },
  "variant": {
    "color": "red",
    "size": "M"
  },
  "metadata": {
    "gift_wrap": true
  }
}
```
```

--------------------------------

### Increase Item Quantity in Cart with Django

Source: https://tobi-de.github.io/dj-shop-cart/usage

Illustrates how to increase the quantity of an existing item in the cart using the `cart.increase` method. This method takes the item ID and the quantity to add, triggering the same hooks as `cart.add` and effectively acting as a shortcut for updating quantities.

```python
cart.increase(item_id, quantity=20)
```

--------------------------------

### Empty Cart with Django

Source: https://tobi-de.github.io/dj-shop-cart/usage

Provides the code to empty the entire shopping cart using the `cart.empty` method. This method requires no arguments and clears all items from the cart.

```python
cart.empty()
```

--------------------------------

### Empty the cart

Source: https://tobi-de.github.io/dj-shop-cart/usage

Removes all items from the shopping cart.

```APIDOC
## POST /cart/empty

### Description
Removes all items from the shopping cart.

### Method
POST

### Endpoint
`/cart/empty`

### Parameters
#### Query Parameters
None

#### Request Body
None

### Request Example
```python
cart.empty()
```

### Response
#### Success Response (200)
Indicates the cart has been successfully emptied. Often returns an empty cart representation or a success status.

#### Response Example
```json
{
  "status": "success",
  "message": "Cart emptied successfully."
}
```
```

--------------------------------

### Increase an item quantity

Source: https://tobi-de.github.io/dj-shop-cart/usage

Increases the quantity of an existing item in the cart.

```APIDOC
## POST /cart/increase

### Description
Increases the quantity of an existing item in the cart. This is a shortcut for `cart.add` when the item is already present.

### Method
POST

### Endpoint
`/cart/increase`

### Parameters
#### Query Parameters
None

#### Request Body
- **item_id** (string) - Required - The unique identifier of the cart item.
- **quantity** (integer) - Required - The quantity to add to the current item quantity.

### Request Example
```python
# Assuming 'cart' is a cart instance and 'item_id_to_increase' is the ID of the item
cart.increase(item_id_to_increase, quantity=5)
```

### Response
#### Success Response (200)
- **cart_item** (object) - The updated cart item object.
- **None** - If no item with the specified `item_id` is found.

#### Response Example
```json
{
  "item_id": "unique_item_identifier",
  "product_id": "product_identifier",
  "quantity": 25 
}
```
```

--------------------------------

### Remove / Decrement a product from the cart

Source: https://tobi-de.github.io/dj-shop-cart/usage

Removes a specified quantity of a product from the cart or removes the item entirely if no quantity is specified or the quantity becomes zero.

```APIDOC
## POST /cart/remove

### Description
Removes a specified quantity of a product from the cart or removes the entire item. Items are also automatically removed if the associated product is deleted from the database.

### Method
POST

### Endpoint
`/cart/remove`

### Parameters
#### Query Parameters
None

#### Request Body
- **item_id** (string) - Required - The unique identifier of the cart item.
- **quantity** (integer) - Optional - The quantity of the product to remove. If this results in zero quantity, the item is completely removed. Defaults to removing the entire item.
- **variant** (any) - Optional - Variant details of the product, used to identify the specific item if multiple variants exist for the same product.

### Request Example
```python
# Remove 10 from the quantity of an item
cart.remove(item_id_to_remove, quantity=10)

# Remove the whole item
cart.remove(item_id_to_remove)
```

### Response
#### Success Response (200)
- **cart_item** (object) - The updated cart item object if partially removed, or null if the item was completely removed.
- **None** - If no item with the specified `item_id` is found.

#### Response Example
```json
{
  "item_id": "unique_item_identifier",
  "product_id": "product_identifier",
  "quantity": 15 
}
```
*or*
```json
null
```
```

--------------------------------

### Remove or Decrement Product from Cart with Django

Source: https://tobi-de.github.io/dj-shop-cart/usage

Shows how to remove a specific quantity of an item or the entire item from the cart using the `cart.remove` method. This method accepts the item ID and an optional quantity. If the quantity reduces to zero, the item is completely removed. Items are also automatically removed if the associated product is deleted.

```python
# Remove 10 from the quantity
cart.remove(item_id, quantity=10)
# Remove the whole item
cart.remove(item_id)
```
Tokens:
Raw