docs: publish restructure (#3496)

* docs: added features and guides overview page

* added image

* added version 2

* added version 3

* added version 4

* docs: implemented new color scheme

* docs: redesigned sidebar (#3193)

* docs: redesigned navbar for restructure (#3199)

* docs: redesigned footer (#3209)

* docs: redesigned cards (#3230)

* docs: redesigned admonitions (#3231)

* docs: redesign announcement bar (#3236)

* docs: redesigned large cards (#3239)

* docs: redesigned code blocks (#3253)

* docs: redesigned search modal and page (#3264)

* docs: redesigned doc footer (#3268)

* docs: added new sidebars + refactored css and assets (#3279)

* docs: redesigned api reference sidebar

* docs: refactored css

* docs: added code tabs transition

* docs: added new sidebars

* removed unused assets

* remove unusued assets

* Fix deploy errors

* fix incorrect link

* docs: fixed code responsivity + missing icons (#3283)

* docs: changed icons (#3296)

* docs: design fixes to the sidebar (#3297)

* redesign fixes

* docs: small design fixes

* docs: several design fixes after restructure (#3299)

* docs: bordered icon fixes

* docs: desgin fixes

* fixes to code blocks and sidebar scroll

* design adjustments

* docs: restructured homepage (#3305)

* docs: restructured homepage

* design fixes

* fixed core concepts icon

* docs: added core concepts page (#3318)

* docs: restructured homepage

* design fixes

* docs: added core concepts page

* changed text of different components

* docs: added architecture link

* added missing prop for user guide

* docs: added regions overview page (#3327)

* docs: added regions overview

* moved region pages to new structure

* docs: fixed description of regions architecture page

* small changes

* small fix

* docs: added customers overview page (#3331)

* docs: added regions overview

* moved region pages to new structure

* docs: fixed description of regions architecture page

* small changes

* small fix

* docs: added customers overview page

* fix link

* resolve link issues

* docs: updated regions architecture image

* docs: second-iteration fixes (#3347)

* docs: redesigned document

* design fixes

* docs: added products overview page (#3354)

* docs: added carts overview page (#3363)

* docs: added orders overview (#3364)

* docs: added orders overview

* added links in overview

* docs: added vercel redirects

* docs: added soon badge for cards (#3389)

* docs: resolved feedback changes + organized troubleshooting pages (#3409)

* docs: resolved feedback changes

* added extra line

* docs: changed icons for restructure (#3421)

* docs: added taxes overview page (#3422)

* docs: added taxes overview page

* docs: fix sidebar label

* added link to taxes overview page

* fixed link

* docs: fixed sidebar scroll (#3429)

* docs: added discounts overview (#3432)

* docs: added discounts overview

* fixed links

* docs: added gift cards overview (#3433)

* docs: added price lists overview page (#3440)

* docs: added price lists overview page

* fixed links

* docs: added sales channels overview page (#3441)

* docs: added sales overview page

* fixed links

* docs: added users overview (#3443)

* docs: fixed sidebar border height (#3444)

* docs: fixed sidebar border height

* fixed svg markup

* docs: added possible solutions to feedback component (#3449)

* docs: added several overview pages + restructured files (#3463)

* docs: added several overview pages

* fixed links

* docs: added feature flags + PAK overview pages (#3464)

* docs: added feature flags + PAK overview pages

* fixed links

* fix link

* fix link

* fixed links colors

* docs: added strategies overview page (#3468)

* docs: automated upgrade guide (#3470)

* docs: automated upgrade guide

* fixed vercel redirect

* docs: restructured files in docs codebase (#3475)

* docs: restructured files

* docs: fixed eslint exception

* docs: finished restructure loose-ends (#3493)

* fixed uses of backend

* docs: finished loose ends

* eslint fixes

* fixed links

* merged master

* added update instructions for v1.7.12
This commit is contained in:
Shahed Nasser
2023-03-16 17:03:10 +02:00
committed by GitHub
parent f312ce1e0f
commit 1decaa27c7
415 changed files with 12422 additions and 5098 deletions
@@ -0,0 +1,755 @@
---
description: 'Learn how to implement discount functionalities for admins in Medusa using the REST APIs. This includes creating, updating, and deleting discounts, and managing conditions of discounts.'
addHowToData: true
---
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';
# How to Manage Discounts using Admin APIs
In this document, youll learn how to use the Admins Discount APIs to manage discounts, discount conditions, and more.
:::tip
If you want to learn about the Discount architecture in-depth, check out the [Discount Architecture](../discounts.md) documentation instead.
:::
## Overview
Using Medusas Discount Admin APIs, you can manage discounts, their conditions, status, rules, and more. You can also manage [dynamic discounts and their discount codes](/api/admin/#tag/Discount/operation/PostDiscountsDiscountDynamicCodes).
### Scenario
You want to add or use general admin functionalities related to:
- Creating discounts of different types, configurations, and rules.
- Updating and deleting discounts.
- Managing conditions in that discount, including adding, retrieving, updating, and removing conditions.
:::tip
You can use Medusas Admin APIs to achieve more functionalities as well. Check out the [API reference](/api/admin/#tag/Discount) to learn more.
:::
---
# Prerequisites
### Medusa Components
It is assumed that you already have a Medusa backend installed and set up. If not, you can follow the [quickstart guide](../../../development/backend/install.mdx) to get started.
### JS Client
This guide includes code snippets to send requests to your Medusa backend using Medusas JS Client, JavaScripts Fetch API, or cURL.
If you follow the JS Client code blocks, its assumed you already have [Medusas JS Client](../../../js-client/overview.md) installed and have [created an instance of the client](../../../js-client/overview.md#configuration).
### Medusa React
This guide also includes code snippets to send requests to your Medusa backend using Medusa React, among other methods.
If you follow the Medusa React code blocks, it's assumed you already have [Medusa React installed](../../../medusa-react/overview.md) and have [used MedusaProvider higher in your component tree](../../../medusa-react/overview.md#usage).
### Authenticated Admin User
You must be an authenticated admin user before following along with the steps in the tutorial.
You can learn more about [authenticating as an admin user in the API reference](/api/admin/#section/Authentication).
---
## Create a Discount
You can create a discount by sending a request to the [Create Discount](/api/admin/#tag/Discount/operation/PostDiscounts) endpoint:
<Tabs groupId="request-type" wrapperClassName="code-tabs">
<TabItem value="client" label="Medusa JS Client" default>
```ts
import {
AllocationType,
DiscountRuleType,
} from "@medusajs/medusa"
// ...
medusa.admin.discounts.create({
code,
rule: {
type: DiscountRuleType.FIXED,
value: 10,
allocation: AllocationType.ITEM,
},
regions: [
regionId,
],
is_dynamic: false,
is_disabled: false,
})
.then(({ discount }) => {
console.log(discount.id)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import {
useAdminCreateDiscount,
} from "medusa-react"
import {
AllocationType,
DiscountRuleType,
} from "@medusajs/medusa"
const CreateDiscount = () => {
const createDiscount = useAdminCreateDiscount()
// ...
const handleCreate = () => {
// ...
createDiscount.mutate({
code,
rule: {
type: DiscountRuleType.FIXED,
value: 10,
allocation: AllocationType.ITEM,
},
regions: [
regionId,
],
is_dynamic: false,
is_disabled: false,
})
}
// ...
}
export default CreateDiscount
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(`<BACKEND_URL>/admin/discounts`, {
method: "POST",
credentials: "include",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
code,
rule: {
type: "fixed",
value: 10,
allocation: "item",
},
regions: [
regionId,
],
is_dynamic: false,
is_disabled: false,
}),
})
.then((response) => response.json())
.then(({ discount }) => {
console.log(discount.id)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X POST '<BACKEND_URL>/admin/discounts' \
-H 'Authorization: Bearer <API_TOKEN>' \
-H 'Content-Type: application/json' \
--data-raw '{
"code": "<CODE>",
"rule": {
"type": "fixed",
"value": 10,
"allocation": "item"
},
"regions": [
"<REGION_ID>"
],
"is_dynamic": false,
"is_disabled": false
}'
```
</TabItem>
</Tabs>
This request accepts [many request-body parameters](/api/admin/#tag/Discount/operation/PostDiscounts) including:
- `code`: This parameter is required. It is a unique code. The customer redeems the discount using this code.
- `rule`: This parameter is required. It is an object having at least the following fields:
- `type`: A string indicating the type of discount. It can be `fixed`, `percentage`, or `free_shipping`. When using the Medusa JS Client, you must use the enum type [DiscountRuleType](../../../references/js-client/enums/internal.discountruletype/) for the value.
- `value`: A number indicating the value of the discount. If the discount type is `fixed`, then it will be the fixed amount to discount from the carts totals or its items. If the discount type is `percentage`, then it will be the percentage to discount from the items in the cart. If the type is `free_shipping`, it has no effect and can be set to `0`.
- `allocation`: A string indicating how the discount should be applied. Can be `item` or `total`. If the type is not `fixed`, then this has no effect. When using the Medusa JS Client, you must use the enum type [AllocationType](../../../references/js-client/enums/internal.allocationtype/) for the value.
- `regions`: An array of region IDs this discount can be used in. If the type of discount is `fixed`, only one region can be passed.
This request returns the full `discount` object.
---
## Update Discount
You can update any of the discounts information, configurations, and conditions by sending a request to the [Update Discount](/api/admin/#tag/Discount/operation/PostDiscountsDiscount) endpoint.
For example, you can update the discounts description and status by sending the following request:
<Tabs groupId="request-type" wrapperClassName="code-tabs">
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.admin.discounts.update(discountId, {
is_disabled: true,
})
.then(({ discount }) => {
console.log(discount.id)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminUpdateDiscount } from "medusa-react"
const UpdateDiscount = () => {
const updateDiscount = useAdminUpdateDiscount(discount_id)
// ...
const handleUpdate = () => {
// ...
updateDiscount.mutate({
is_disabled: true,
})
}
// ...
}
export default UpdateDiscount
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(`<BACKEND_URL>/admin/discounts/${discountId}`, {
method: "POST",
credentials: "include",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
is_disabled: true,
}),
})
.then((response) => response.json())
.then(({ discount }) => {
console.log(discount.id)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X POST '<BACKEND_URL>/admin/discounts/<DISCOUNT_ID>' \
-H 'Authorization: Bearer <API_TOKEN>' \
-H 'Content-Type: application/json' \
--data-raw '{
"is_disabled": true
}'
```
</TabItem>
</Tabs>
This request accepts the discount ID as a path parameter. You can pass the parameters you want to update in the request body. In the example above, is_disabled` parameter to update it.
You can check the [API reference](/api/admin/#tag/Discount/operation/PostDiscountsDiscount) for all the accepted parameters to update the discount.
This updates the discounts information and returns the full updated `discount` object in the response.
---
## Manage Conditions
### Create a Condition
:::tip
You can learn more about conditions and conditions types in the [Discount Architecture](../discounts.md) documentation.
:::
You can send a request to the [Create Condition](/api/admin/#tag/Discount-Condition/operation/PostDiscountsDiscountConditions) endpoint to create a condition in a discount:
<Tabs groupId="request-type" wrapperClassName="code-tabs">
<TabItem value="client" label="Medusa JS Client" default>
```ts
import { DiscountConditionOperator } from "@medusajs/medusa"
// ...
medusa.admin.discounts.createCondition(discount_id, {
operator: DiscountConditionOperator.IN,
products: [
productId,
],
})
.then(({ discount }) => {
console.log(discount.id)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminDiscountCreateCondition } from "medusa-react"
import { DiscountConditionOperator } from "@medusajs/medusa"
const Discount = () => {
const createCondition = useAdminDiscountCreateCondition(
discount_id
)
// ...
const handleCreateCondition = (
operator: DiscountConditionOperator,
productId: string
) => {
// ...
createCondition.mutate({
operator,
products: [
productId,
],
})
}
// ...
}
export default Discount
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(`<BACKEND_URL>/admin/discounts/${discountId}/conditions`,
{
method: "POST",
credentials: "include",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
operator: "in",
products: [
productId,
],
}),
}
)
.then((response) => response.json())
.then(({ discount }) => {
console.log(discount.id)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X POST '<BACKEND_URL>/admin/discounts/<DISCOUNT_ID>/conditions' \
-H 'Authorization: Bearer <API_TOKEN>' \
-H 'Content-Type: application/json' \
--data-raw '{
"operator": "in",
"products": [
"<PRODUCT_ID>"
]
}'
```
</TabItem>
</Tabs>
This request accepts the discount ID as a path parameter.
It also requires the request-body parameter `operator` which can have one of the following values:
- `in` indicates that the discount should be applied to the specified resources in this condition. When using the Medusa JS Client, `DiscountConditionOperator.IN` must be used as the value.
- `not_in` indicates that the discount should be applied to all resources except those specified in this condition. When using the Medusa JS Client, `DiscountConditionOperator.NOT_IN` must be used as the value.
In addition, every condition has a condition type. Based on that condition type, a different additional parameter is required for the request.
For example, if the condition type is product, meaning that the condition specifies which products this discount apply/doesnt apply for, the parameter `products` is required.
The additional required parameter must be an array of IDs of the resources. For the previous example, `products` would be an array of product IDs.
You can check the [API reference](/api/admin/#tag/Discount-Condition/operation/PostDiscountsDiscountConditions) for a full list of accepted parameters based on the condition type.
This request returns the full `discount` object in the response which includes all conditions under `discount.rule.conditions`.
### Retrieve Condition
You can retrieve a condition and its resources by sending a request to the [Get Condition](/api/admin/#tag/Discount-Condition/operation/GetDiscountsDiscountConditionsCondition) endpoint:
<Tabs groupId="request-type" wrapperClassName="code-tabs">
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.admin.discounts.getCondition(
discountId,
conditionId,
{
expand: "products",
}
)
.then(({ discount_condition }) => {
console.log(
discount_condition.id,
discount_condition.products
)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminGetDiscountCondition } from "medusa-react"
import { Product } from "@medusajs/medusa"
const DiscountCondition = () => {
const {
discount_condition,
isLoading,
} = useAdminGetDiscountCondition(
discount_id,
conditionId
)
// ...
return (
<div>
{isLoading && <span>Loading</span>}
{discount_condition && (
<>
<span>{discount_condition.id}</span>
<ul>
{discount_condition.products.map(
(product: Product) => (
<li key={product.id}>{product.title}</li>
)
)}
</ul>
</>
)}
</div>
)
}
export default DiscountCondition
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(
`<BACKEND_URL>/admin/discounts/${discountId}` +
`/conditions/${conditionId}&expand=products`,
{
credentials: "include",
}
)
.then((response) => response.json())
.then(({ discount_condition }) => {
console.log(
discount_condition.id,
discount_condition.products
)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X GET '<BACKEND_URL>/admin/discounts/<DISCOUNT_ID>/conditions/<CONDITION_ID>&expand=products' \
-H 'Authorization: Bearer <API_TOKEN>'
```
</TabItem>
</Tabs>
This request accepts as path parameters the discount ID and the condition ID. You can optionally pass a query parameter `expand` which specifies which relations to include in the returned object.
By default, this request returns the discount condition object without any of its resources (In the previous example the resources are the products). To ensure the resources are included in the returned object, you must pass the name of the conditions type as a value to the `expand` query parameter.
In the previous example, you pass `expand=products` as a query parameter, which returns inside the `discount_condition` object a `products` attribute. The value of `products` is an array of products that belong to this condition.
### Update Condition
You can update a conditions resources using the [Update Condition](/api/admin/#tag/Discount/operation/PostDiscountsDiscountConditionsCondition) endpoint. You cant update a conditions operator.
For example, to update the products in a condition:
<Tabs groupId="request-type" wrapperClassName="code-tabs">
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.admin.discounts.updateCondition(
discountId,
conditionId, {
products: [
productId1,
productId2,
],
}
)
.then(({ discount }) => {
console.log(discount.id)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminDiscountUpdateCondition } from "medusa-react"
import { Product } from "@medusajs/medusa"
const DiscountCondition = () => {
const updateCondition = useAdminDiscountUpdateCondition(
discount_id,
conditionId
)
// ...
const handleUpdateCondition = (productIds: string[]) => {
updateCondition.mutate({
products: productIds,
})
}
// ...
}
export default DiscountCondition
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
<!-- eslint-disable max-len -->
```ts
fetch(
`<BACKEND_URL>/admin/discounts/${discountId}/conditions/${conditionId}`,
{
method: "POST",
credentials: "include",
headers: {
"Content-Type": "application/json",
},
body: JSON.stringify({
products: [
productId1,
productId2,
],
}),
}
)
.then((response) => response.json())
.then(({ discount }) => {
console.log(discount.id)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X POST '<BACKEND_URL>/admin/discounts/<DISCOUNT_ID>/conditions/<CONDITION_ID>' \
-H 'Authorization: Bearer <API_TOKEN>' \
-H 'Content-Type: application/json' \
--data-raw '{
"products": [
"<PRODUCT_ID_1>",
"<PRODUCT_ID_2>"
]
}'
```
</TabItem>
</Tabs>
This request accepts as a path parameter the discount ID and the condition ID. In its body, it accepts the resources of the same type that were used when the condition was created.
For example, if a condition was created for `products`, you cant pass in the update request `product_collections`. You must pass in the update request a `products` array as well.
This request returns the full `discount` object with the updated condition in the response.
### Delete Condition
You can delete a condition by sending a request to the [Delete Condition](/api/admin/#tag/Discount-Condition/operation/DeleteDiscountsDiscountConditionsCondition) endpoint:
<Tabs groupId="request-type" wrapperClassName="code-tabs">
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.admin.discounts.deleteCondition(
discountId,
conditionId
)
.then(({ discount }) => {
console.log(discount)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminDiscountRemoveCondition } from "medusa-react"
const Discount = () => {
const deleteCondition = useAdminDiscountRemoveCondition(
discount_id
)
// ...
const handleUpdateCondition = (conditionId: string) => {
deleteCondition.mutate(conditionId)
}
// ...
}
export default Discount
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
<!-- eslint-disable max-len -->
```ts
fetch(
`<BACKEND_URL>/admin/discounts/${discountId}/conditions/${conditionId}`,
{
method: "DELETE",
credentials: "include",
}
)
.then((response) => response.json())
.then(({ discount }) => {
console.log(discount.id)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X DELETE '<BACKEND_URL>/admin/discounts/<DISCOUNT_ID>/conditions/<CONDITION_ID>' \
-H 'Authorization: Bearer <API_TOKEN>'
```
</TabItem>
</Tabs>
This request accepts as a path parameter the discount ID and the condition ID.
It returns the `discount` object in the response.
---
## Delete Discount
You can delete a discount by sending a request to the [Delete Discount](/api/admin/#tag/Discount/operation/DeleteDiscountsDiscount) endpoint:
<Tabs groupId="request-type" wrapperClassName="code-tabs">
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.admin.discounts.delete(discount_id)
.then(({ id, object, deleted }) => {
console.log(id)
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useAdminDeleteDiscount } from "medusa-react"
const Discount = () => {
const deleteDiscount = useAdminDeleteDiscount(discount_id)
// ...
const handleDelete = () => {
deleteDiscount.mutate()
}
// ...
}
export default Discount
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(`<BACKEND_URL>/admin/discounts/${discountId}`, {
method: "DELETE",
credentials: "include",
})
.then((response) => response.json())
.then(({ id, object, deleted }) => {
console.log(id)
})
```
</TabItem>
<TabItem value="curl" label="cURL">
```bash
curl -L -X DELETE '<BACKEND_URL>/admin/discounts/<DISCOUNT_ID>' \
-H 'Authorization: Bearer <API_TOKEN>'
```
</TabItem>
</Tabs>
This request accepts the discount ID as a path parameter.
It returns in the response the following fields:
- `id`: The ID of the deleted discount.
- `object`: A string indicating the type of object deleted. By default, its value is `discount`.
- `deleted`: A boolean value indicating whether the discount was deleted or not.
---
## See Also
- [Use Discounts on the storefront](../storefront/use-discounts-in-checkout.mdx)
+108
View File
@@ -0,0 +1,108 @@
---
description: 'Learn about the discount architecture in the Medusa backend. Discounts are used to offer promotions to the user for marketing purposes.'
---
# Discounts Architecture
In this document, youll learn about Discounts architecture and how it works.
## What are Discounts
Discounts allow you to offer promotions to your users generally for marketing purposes. Customers can apply a discount code to their checkout flow to use the discount if its valid for them.
Discounts can be limited by a set of configurations and conditions. For example, you can indicate how many times a discount can be used or by which customer group. You can also specify which products this discount can be used with, among other conditions.
### Discount Types
There are three types of discounts:
1. Percentage discount: remove a percentage of the price every product in the cart that the discount can be applied to.
2. Fixed discount: remove a fixed amount either of the customers total checkout amount or of the price every product in the cart that the discount can be applied to.
3. Free shipping discount: remove any shipping amount from the customers order during checkout.
### Example Use Cases
Discounts can be used in many use cases including:
1. Applying discounted amounts for wholesale or B2B customers.
2. Creating a sale within a specific period of time (for example, a summer sale).
3. Give your customers free shipping for a limited time.
---
## Discount Entity Overview
A discount is represented by the [`Discount`](../../references/entities/classes/Discount.md) entity. Some of its important attributes are:
- `code` is a unique code that you specify when you create the discount. Customers use this code to apply the discount during checkout. The code can only include upper-case letters and numbers.
- `rule_id` is the ID of the rule of this discount. The `rule` attribute is the expanded object of the `DiscountRule` entity. You can use the `rule` attribute to get details regarding the discount type. You can learn more about this in the [`DiscountRule` entity overview](#discountrule-entity-overview) later.
- `is_disabled` is a boolean value that indicates whether this discount is published or not.
- `regions` are the regions this discount can be used in.
- `starts_at` and `ends_at` are timestamps that indicate when the discount starts and ends. If no expiry date is set for the discount, `ends_at` will be `null`.
- `usage_limit` is the number of times the discount can be used. If there is no limit the value will be `null`.
- `usage_count` is the number of times the discount has been used.
### Dynamic Discounts
Dynamic discounts are a set of discount conditions and configurations that you can reuse across many discounts.
After creating a dynamic discount, you can use it to create “child” discounts. Child discounts have the same conditions and configurations as the “parent” dynamic discount but with a different discount code.
The `is_dynamic` attribute in the `Discount` entity is a boolean value that determines whether the discount is dynamic or not. Child discounts are related to the parent discount using the `parent_discount_id` attribute which is a foreign key to the same `Discount` entity.
---
## DiscountRule Entity Overview
Every `Discount` entity belongs to a [`DiscountRule`](../../references/entities/classes/DiscountRule.md) entity. `DiscountRule` includes details such as the type of discount, the amount to be discounted, and more.
Some of the `DiscountRule` entitys important attributes are:
- `type` is an enum string indicating the type of the discount. It must be either `fixed`, `percentage`, or `free_shipping`.
- `value` is the value to be discounted. The value of this depends on the value of `type`:
- If `type` is `fixed`, `value` will be the amount to be removed either from the total or from each product this discount is applied to.
- If `type` is `percentage`, `value` will be the percentage to be removed from each product this discount is applied to.
- If `type` is `free_shipping`, `value` will be 0.
- `conditions` is an array of all discount conditions, if there are any.
---
## DiscountCondition Entity Overview
A discount can optionally have discount conditions. Discount conditions are used to further add limitations on when the discount can be applied.
A [`DiscountCondition`](../../references/entities/classes/DiscountCondition.md) belongs to a `DiscountRule` entity. The `discount_rule_id` attribute indicates the ID of the `DiscountRule` it belongs to.
Discount conditions have an attribute `type` that indicates the conditions type. Its value must be one of the following:
- `products` means the condition applies to products.
- `product_types` means the condition applies to product types.
- `product_collections` means the condition applies to product collections.
- `product_tags` means the condition applies to product tags.
- `customer_groups` means the condition applies to customer groups.
Each condition type can be used for one condition in a discount. For example, you can add only one `product` discount condition to a discount.
Discount conditions also have an attribute `operator` that indicates how the condition should be applied. It must have one of the following values:
- `in` means the discount can be applied only for the items specified in the condition. For example, if the `type` is `product` and the `operator` is `in`, it means this condition defines which products must be available in the customers cart for the discount to apply.
- `not_in` means the discount can be applied for all items except those specified in the condition. For example, if the `type` is `product` and the `operator` is `not_in`, it means that the discount can be applied to any item in the cart that's not specified in the condition.
### Condition Type Relations
Based on the value of `type`, one of the following relations can be used to retrieve the conditions items:
- `products` is an array of products that this condition applies to if the conditions `type` is `products`. Each item of the array would be a [`DiscountConditionProduct`](../../references/entities/classes/DiscountConditionProduct.md).
- `product_types` is an array of product types that this condition applies to if the conditions `type` is `product_types`. Each item of the array would be a [`DiscountConditionProductType`](../../references/entities/classes/DiscountConditionProductType.md).
- `product_collections` is an array of product types that this condition applies to if the conditions `type` is `product_collections`. Each item of the array would be a [`DiscountConditionProductCollection`](../../references/entities/classes/DiscountConditionProductCollection.md).
- `product_tags` is an array of product types that this condition applies to if the conditions `type` is `product_tags`. Each item of the array would be a [`DiscountConditionProductTag`](../../references/entities/classes/DiscountConditionProductTag.md).
- `customer_groups` is an array of product types that this condition applies to if the conditions `type` is `customer_groups`. Each item of the array would be a [`DiscountConditionCustomerGroup`](../../references/entities/classes/DiscountConditionCustomerGroup.md).
![Discounts Architecture](https://res.cloudinary.com/dza7lstvk/image/upload/v1678372360/Medusa%20Docs/Diagrams/discounts_ioivrl.png)
---
## See Also
- [Manage discounts using the admin APIs](./admin/manage-discounts.mdx)
- [Use discounts on the storefront](./storefront/use-discounts-in-checkout.mdx)
+113
View File
@@ -0,0 +1,113 @@
---
description: "Discounts are deductions in the checkout total that are generally used for marketing and promotional purposes. Learn about the available features and guides."
---
import DocCardList from '@theme/DocCardList';
import DocCard from '@theme/DocCard';
import Icons from '@theme/Icon';
# Discounts
Discounts are deductions in the checkout total that are generally used for marketing and promotional purposes. This overview introduces the available features related to discounts.
:::note
Not a developer? Check out the [Discounts user guide](../../user-guide/discounts/index.md).
:::
## Features
### Discounts Management
Admins can create discounts with various conditions and rules that can be used to deduct a fixed or percentage amount from the cart total, or that can be used for free shipping.
<DocCardList colSize={6} items={[
{
type: 'link',
href: '/modules/discounts/admin/manage-discounts',
label: 'Admin: Manage Discounts',
customProps: {
icon: Icons['academic-cap-solid'],
description: 'Learn how to manage discounts using Admin APIs.'
}
},
{
type: 'link',
href: '/user-guide/discounts/manage',
label: 'User Guide: Manage Discounts',
customProps: {
icon: Icons['users-solid'],
description: 'Learn how to manage discounts using Medusa Admin.'
}
},
]} />
### Applying Discounts during Checkout
Customers can benefit from discounts by using a discount code during checkout.
<DocCardList colSize={6} items={[
{
type: 'link',
href: '/modules/discounts/storefront/use-discounts-in-checkout',
label: 'Storefront: Use Discounts in Checkout',
customProps: {
icon: Icons['academic-cap-solid'],
description: 'Learn how to use discounts during checkout.'
}
},
{
type: 'link',
href: '/api/store#tag/Cart/operation/GetCartsCart',
label: 'Store APIs: Discounts',
customProps: {
icon: Icons['server-solid'],
description: 'Check available Store REST APIs for Discounts with carts.'
}
},
]} />
---
## Understand the Architecture
Learn how discount-related entities and concepts are built, their relation to other modules, and more.
<DocCard item={{
type: 'link',
href: '/modules/discounts',
label: 'Architecture: Discounts',
customProps: {
icon: Icons['circle-stack-solid'],
description: 'Learn about the Discount architecture.'
}
}}
/>
---
## Related Modules
Discover Discounts relation to other modules in Medusa
<DocCardList colSize={6} items={[
{
type: 'link',
href: '/modules/carts-and-checkout/overview',
label: 'Cart and Checkout',
customProps: {
icon: Icons['shopping-cart-solid'],
description: 'Customers can apply discounts during checkout.'
}
},
{
type: 'link',
href: '/modules/products/overview',
label: 'Product',
customProps: {
icon: Icons['tag-solid'],
description: 'Discounts can be associated with specific products.'
}
},
]} />
@@ -0,0 +1,287 @@
---
description: 'Learn how to implement discount functionalities in your storefront using the REST APIs. This includes adding a discount to the cart, showing the discount details, and removing the discount from the cart.'
addHowToData: true
---
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';
# Use Discounts in Checkout
In this document, learn how to use discounts during checkout on the storefront.
:::info
You can check out the [Discounts Architecture documentation](../discounts.md) to learn more about how discounts work.
:::
## Overview
Customers can use discounts during checkout to benefit from promotions that the merchant provides. Discounts are added to a cart using its unique code.
In this document, youll learn how to add a discount to a cart, how to display details related to the discount, and how to remove a discount from a cart.
### Scenario
You want to implement discount functionality in your store to allow customers to apply discount codes to their cart and remove them from the cart. You also want to display the discount details for the customer.
---
## Prerequisites
### Medusa Components
It's assumed that you already have a Medusa backend installed and set up. If not, you can follow the [quickstart guide](../../../development/backend/install.mdx) to get started.
It is also assumed you already have a storefront set up. It can be a custom storefront or one of Medusas storefronts. If you dont have a storefront set up, you can install either the [Next.js](../../../starters/nextjs-medusa-starter.mdx) or [Gatsby](../../../starters/gatsby-medusa-starter.mdx) storefronts.
### JS Client
This guide includes code snippets to send requests to your Medusa backend using Medusas JS Client, among other methods.
If you follow the JS Client code blocks, its assumed you already have [Medusas JS Client installed](../../../js-client/overview.md) and have [created an instance of the client](../../../js-client/overview.md#configuration).
### Medusa React
This guide also includes code snippets to send requests to your Medusa backend using Medusa React, among other methods.
If you follow the Medusa React code blocks, it's assumed you already have [Medusa React installed](../../../medusa-react/overview.md) and have [used MedusaProvider higher in your component tree](../../../medusa-react/overview.md#usage).
It's also assumed you already have [used CartProvider higher in your component tree](../../../medusa-react/overview.md#cartprovider).
### Previous Steps
This document assumes youve already taken care of the add-to-cart flow. So, you should have a [cart created](/api/store/#tag/Cart/operation/PostCart) for the customer with at least [one product in it](/api/store/#tag/Cart/operation/PostCartsCartLineItems).
You can learn how to implement the cart flow using [this documentation](../../../modules/carts-and-checkout/storefront/implement-cart.mdx).
---
## Add Discount to Cart
The customer can enter a discount code during the checkout flow to benefit from a promotion.
You can add a discount to a customers cart by sending the [Update Cart request](/api/store/#tag/Cart/operation/PostCartsCart):
<Tabs groupId="request-type" wrapperClassName="code-tabs">
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.carts.update(cartId, {
discounts: [
{
code,
},
],
})
.then(({ cart }) => {
console.log(cart.discounts)
})
.catch((e) => {
// display an error to the customer
alert("Discount is invalid")
})
```
</TabItem>
<TabItem value="medusa-react" label="Medusa React">
```tsx
import { useCart } from "medusa-react"
const Cart = () => {
// ...
const { updateCart } = useCart()
const addDiscount = (code: string) => {
updateCart.mutate({
discounts: [
{
code,
},
],
})
}
// ...
}
export default Cart
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(`<BACKEND_URL>/store/carts/${cartId}`, {
method: "POST",
credentials: "include",
body: JSON.stringify({
discounts: [
{
code,
},
],
}),
headers: {
"Content-Type": "application/json",
},
})
.then((response) => response.json())
.then(({ cart }) => {
console.log(cart.discounts)
})
.catch((e) => {
// display an error to the customer
alert("Discount is invalid")
})
```
</TabItem>
</Tabs>
This request requires the customers cart ID as a path parameter. In the body of the request, you can update many cart-related details, including adding discounts by passing the `discounts` field. It is an array of objects, with each object having a property `code` with its value being the discounts unique code.
:::info
Customers can add more than one discount to their cart.
:::
If the discount is applied successfully, the entire cart object will be returned. You can access the discounts applied on the cart in the `cart.discounts` array.
In case the customer enters an invalid discount or the discount cannot be applied to the cart because it doesnt meet its conditions, the request will return an error. You can handle the error in the `catch` method.
---
## Display Discount Details
After the customer enters a discount code and it is applied to the cart, you can display the discount details to the customer. This shows the customer how much they benefitted from the discount.
The previous request returns the full cart object with different fields that can be used to display the discount details depending on the discount type.
### Display Discount Information
In the returned `cart` object, all discounts applied can be found in the `discounts` array. The following properties can be used to display the discount information:
```json
{
"discounts": [
{
"code": "TEST",
"is_dynamic": false,
"starts_at": "2022-12-01T15:09:21.149Z",
"ends_at": null,
"usage_limit": null,
"usage_count": 0,
"rule": {
"description": "percentage discount",
"type": "percentage",
"value": 20,
"allocation": "total",
"conditions": [
//...
],
//...
},
//...
}
],
//...
}
```
- The `code` property is the code of the discount. This is the code that the customer enters to apply the discount.
- The `starts_at` and `ends_at` indicate the start and expiry dates of the discount. If theres no end date, the `ends_at` property will be null.
- The `usage_limit` property indicates if there is any usage limit set on the discount. The `usage_count` property indicates how many times this discount has been used.
- The `rule` property includes details related to the type of discount, its value, and its conditions if there are any.
### Display Item Discounts
In the returned `cart` object, the property `items` is an array of items in the cart. If a discount is applied to an item, the following properties inside the item can be used to get the item-specific discount details:
```json
{
"items": [
{
"adjustments": [
{
"description": "discount",
"discount_id": "disc_01GK73RBCRXXT8HWEYMQE4RCY6",
"amount": 730,
//...
}
],
"subtotal": 3650,
"discount_total": 730,
"total": 2920,
//...
}
]
}
```
- The `adjustments` property is an array of objects, each containing details about the adjustment made to the item. Discounts applied to the item will be represented by an adjustment in this array. It will have the `description` property with the value `discount`, the `discount_id` property, and the `amount` of the discount.
- The `subtotal` property is the price before the discounts are applied.
- The `discount_total` property is the sum of all discount amounts.
- The `total` property is the total of the item after applying the discounts.
### Display Cart Discounts
The returned `cart` object has the following properties that can be used to display carts general discount details:
```json
{
"subtotal": 11550,
"discount_total": 1910,
"shipping_total": 0,
"total": 9640,
//...
}
```
- The `subtotal` property is the total of the cart before applying any discount.
- The `discount_total` property is the total discount amounts applied to the cart.
- The `shipping_total` property is the total shipping amount. If a Free Shipping discount is applied to the cart, `shipping_total` and `discount_total` will be 0.
- The `total` property is the total amount of the cart after applying the discount.
---
## Remove Discount from Cart
The customer can choose to remove a discount from their cart.
You can remove a discount from a customers cart using the [Remove Discount request](/api/store/#tag/Cart/operation/DeleteCartsCartDiscountsDiscount):
<Tabs groupId="request-type" wrapperClassName="code-tabs">
<TabItem value="client" label="Medusa JS Client" default>
```ts
medusa.carts.deleteDiscount(cartId, code)
.then(({ cart }) => {
console.log(cart.discounts)
})
```
</TabItem>
<TabItem value="fetch" label="Fetch API">
```ts
fetch(`<BACKEND_URL>/store/carts/${cartId}/discounts/${code}`, {
method: "DELETE",
credentials: "include",
})
.then((response) => response.json())
.then(({ cart }) => {
console.log(cart.discounts)
})
```
</TabItem>
</Tabs>
This request accepts the cart ID and the code of the discount to remove. If the discount is removed successfully, the request returns the updated cart object, where you wont find the discount in the `discounts` array anymore.
The totals of the cart and its items will be updated as well.