feat(order): create claim and exchange (#7734)

This commit is contained in:
Carlos R. L. Rodrigues
2024-06-18 08:08:16 -03:00
committed by GitHub
parent e0b14519f1
commit cfa983001b
45 changed files with 2571 additions and 437 deletions
@@ -0,0 +1,365 @@
import {
Context,
CreateOrderChangeActionDTO,
OrderTypes,
} from "@medusajs/types"
import {
ClaimType,
ReturnStatus,
getShippingMethodsTotals,
isString,
promiseAll,
} from "@medusajs/utils"
import { ClaimItem, OrderClaim, Return, ReturnItem } from "@models"
import { OrderChangeType } from "@types"
import { ChangeActionType } from "../../utils"
function createClaimAndReturnEntities(em, data, order) {
const claimReference = em.create(OrderClaim, {
order_id: data.order_id,
order_version: order.version,
type: data.type as ClaimType,
no_notification: data.no_notification,
refund_amount: (data.refund_amount as unknown) ?? null,
})
const returnReference =
data.type === ClaimType.REPLACE
? em.create(Return, {
order_id: data.order_id,
order_version: order.version,
status: ReturnStatus.REQUESTED,
claim_id: claimReference.id,
refund_amount: (data.refund_amount as unknown) ?? null,
})
: undefined
claimReference.return_id = returnReference?.id
return { claimReference, returnReference }
}
function createReturnItem(em, item, claimReference, returnReference, actions) {
actions.push({
action: ChangeActionType.RETURN_ITEM,
reference: "return",
reference_id: returnReference.id,
details: {
reference_id: item.id,
return_id: returnReference.id,
claim_id: claimReference.id,
quantity: item.quantity,
metadata: item.metadata,
},
})
return em.create(ReturnItem, {
item_id: item.id,
return_id: returnReference.id,
quantity: item.quantity,
note: item.note,
metadata: item.metadata,
})
}
function createClaimAndReturnItems(
em,
data,
claimReference,
returnReference,
actions
) {
const returnItems: ReturnItem[] = []
const claimItems = data.claim_items?.map((item) => {
actions.push({
action: ChangeActionType.WRITE_OFF_ITEM,
reference: "claim",
reference_id: claimReference.id,
details: {
reference_id: item.id,
claim_id: claimReference.id,
quantity: item.quantity,
metadata: item.metadata,
},
})
returnItems.push(
returnReference
? createReturnItem(em, item, claimReference, returnReference, actions)
: undefined
)
return em.create(ClaimItem, {
item_id: item.id,
reason: item.reason,
quantity: item.quantity,
note: item.note,
metadata: item.metadata,
})
})
return [claimItems, returnItems]
}
async function processAdditionalItems(
em,
service,
data,
order,
claimReference,
actions,
sharedContext
) {
const itemsToAdd: any[] = []
const additionalNewItems: ClaimItem[] = []
const additionalItems: ClaimItem[] = []
data.additional_items?.forEach((item) => {
const hasItem = item.id
? order.items.find((o) => o.item.id === item.id)
: false
if (hasItem) {
actions.push({
action: ChangeActionType.ITEM_ADD,
claim_id: claimReference.id,
internal_note: item.internal_note,
reference: "claim",
reference_id: claimReference.id,
details: {
reference_id: item.id,
claim_id: claimReference.id,
quantity: item.quantity,
metadata: item.metadata,
},
})
additionalItems.push(
em.create(ClaimItem, {
item_id: item.id,
quantity: item.quantity,
note: item.note,
metadata: item.metadata,
is_additional_item: true,
})
)
} else {
itemsToAdd.push(item)
additionalNewItems.push(
em.create(ClaimItem, {
quantity: item.quantity,
note: item.note,
metadata: item.metadata,
is_additional_item: true,
})
)
}
})
const createItems = await service.lineItemService_.create(
itemsToAdd,
sharedContext
)
createItems.forEach((item, index) => {
const addedItem = itemsToAdd[index]
additionalNewItems[index].item_id = item.id
actions.push({
action: ChangeActionType.ITEM_ADD,
claim_id: claimReference.id,
internal_note: addedItem.internal_note,
reference: "claim",
reference_id: claimReference.id,
details: {
reference_id: item.id,
claim_id: claimReference.id,
quantity: addedItem.quantity,
metadata: addedItem.metadata,
},
})
})
return additionalNewItems.concat(additionalItems)
}
async function processShippingMethods(
service,
data,
claimReference,
actions,
sharedContext
) {
for (const shippingMethod of data.shipping_methods ?? []) {
let shippingMethodId
if (!isString(shippingMethod)) {
const methods = await service.createShippingMethods(
[
{
order_id: data.order_id,
claim_id: claimReference.id,
...shippingMethod,
},
],
sharedContext
)
shippingMethodId = methods[0].id
} else {
shippingMethodId = shippingMethod
}
const method = await service.retrieveShippingMethod(
shippingMethodId,
{ relations: ["tax_lines", "adjustments"] },
sharedContext
)
const calculatedAmount = getShippingMethodsTotals([method as any], {})[
method.id
]
actions.push({
action: ChangeActionType.SHIPPING_ADD,
reference: "order_shipping_method",
reference_id: shippingMethodId,
claim_id: claimReference.id,
amount: calculatedAmount.total,
})
}
}
async function processReturnShipping(
service,
data,
claimReference,
returnReference,
actions,
sharedContext
) {
if (!returnReference) {
return
}
if (data.return_shipping) {
let returnShippingMethodId
if (!isString(data.return_shipping)) {
const methods = await service.createShippingMethods(
[
{
order_id: data.order_id,
claim_id: claimReference.id,
return_id: returnReference.id,
...data.return_shipping,
},
],
sharedContext
)
returnShippingMethodId = methods[0].id
} else {
returnShippingMethodId = data.return_shipping
}
const method = await service.retrieveShippingMethod(
returnShippingMethodId,
{ relations: ["tax_lines", "adjustments"] },
sharedContext
)
const calculatedAmount = getShippingMethodsTotals([method as any], {})[
method.id
]
actions.push({
action: ChangeActionType.SHIPPING_ADD,
reference: "order_shipping_method",
reference_id: returnShippingMethodId,
return_id: returnReference.id,
claim_id: claimReference.id,
amount: calculatedAmount.total,
})
}
}
export async function createClaim(
this: any,
data: OrderTypes.CreateOrderClaimDTO,
sharedContext?: Context
) {
const order = await this.orderService_.retrieve(
data.order_id,
{ relations: ["items"] },
sharedContext
)
const actions: CreateOrderChangeActionDTO[] = []
const em = sharedContext!.transactionManager as any
const { claimReference, returnReference } = createClaimAndReturnEntities(
em,
data,
order
)
const [claimItems, returnItems] = createClaimAndReturnItems(
em,
data,
claimReference,
returnReference,
actions
)
claimReference.claim_items = claimItems
if (returnReference) {
returnReference.items = returnItems
}
claimReference.additional_items = await processAdditionalItems(
em,
this,
data,
order,
claimReference,
actions,
sharedContext
)
await processShippingMethods(
this,
data,
claimReference,
actions,
sharedContext
)
await processReturnShipping(
this,
data,
claimReference,
returnReference,
actions,
sharedContext
)
const change = await this.createOrderChange_(
{
order_id: data.order_id,
claim_id: claimReference.id,
return_id: returnReference.id,
change_type: OrderChangeType.CLAIM,
reference: "claim",
reference_id: claimReference.id,
description: data.description,
internal_note: data.internal_note,
created_by: data.created_by,
metadata: data.metadata,
actions,
},
sharedContext
)
await promiseAll([
this.createReturns([returnReference], sharedContext),
this.createOrderClaims([claimReference], sharedContext),
this.confirmOrderChange(change[0].id, sharedContext),
])
return claimReference
}
@@ -0,0 +1,316 @@
import {
Context,
CreateOrderChangeActionDTO,
OrderTypes,
} from "@medusajs/types"
import {
ReturnStatus,
getShippingMethodsTotals,
isString,
promiseAll,
} from "@medusajs/utils"
import { ExchangeItem, OrderExchange, Return, ReturnItem } from "@models"
import { OrderChangeType } from "@types"
import { ChangeActionType } from "../../utils"
function createExchangeAndReturnEntities(em, data, order) {
const exchangeReference = em.create(OrderExchange, {
order_id: data.order_id,
order_version: order.version,
no_notification: data.no_notification,
allow_backorder: data.allow_backorder,
difference_due: data.difference_due,
})
const returnReference = em.create(Return, {
order_id: data.order_id,
order_version: order.version,
status: ReturnStatus.REQUESTED,
exchange_id: exchangeReference.id,
refund_amount: (data.refund_amount as unknown) ?? null,
})
exchangeReference.return_id = returnReference.id
return { exchangeReference, returnReference }
}
function createReturnItems(
em,
data,
exchangeReference,
returnReference,
actions
) {
return data.return_items?.map((item) => {
actions.push({
action: ChangeActionType.RETURN_ITEM,
reference: "return",
reference_id: returnReference.id,
details: {
reference_id: item.id,
return_id: returnReference.id,
exchange_id: exchangeReference.id,
quantity: item.quantity,
metadata: item.metadata,
},
})
return em.create(ReturnItem, {
item_id: item.id,
return_id: returnReference.id,
reason: item.reason,
quantity: item.quantity,
note: item.note,
metadata: item.metadata,
})
})
}
async function processAdditionalItems(
em,
service,
data,
order,
exchangeReference,
actions,
sharedContext
) {
const itemsToAdd: any[] = []
const additionalNewItems: ExchangeItem[] = []
const additionalItems: ExchangeItem[] = []
data.additional_items?.forEach((item) => {
const hasItem = item.id
? order.items.find((o) => o.item.id === item.id)
: false
if (hasItem) {
actions.push({
action: ChangeActionType.ITEM_ADD,
exchange_id: exchangeReference.id,
internal_note: item.internal_note,
reference: "exchange",
reference_id: exchangeReference.id,
details: {
reference_id: item.id,
exchange_id: exchangeReference.id,
quantity: item.quantity,
metadata: item.metadata,
},
})
additionalItems.push(
em.create(ExchangeItem, {
item_id: item.id,
quantity: item.quantity,
note: item.note,
metadata: item.metadata,
is_additional_item: true,
})
)
} else {
itemsToAdd.push(item)
additionalNewItems.push(
em.create(ExchangeItem, {
quantity: item.quantity,
note: item.note,
metadata: item.metadata,
is_additional_item: true,
})
)
}
})
const createItems = await service.lineItemService_.create(
itemsToAdd,
sharedContext
)
createItems.forEach((item, index) => {
const addedItem = itemsToAdd[index]
additionalNewItems[index].item_id = item.id
actions.push({
action: ChangeActionType.ITEM_ADD,
exchange_id: exchangeReference.id,
internal_note: addedItem.internal_note,
reference: "exchange",
reference_id: exchangeReference.id,
details: {
reference_id: item.id,
exchange_id: exchangeReference.id,
quantity: addedItem.quantity,
metadata: addedItem.metadata,
},
})
})
return additionalNewItems.concat(additionalItems)
}
async function processShippingMethods(
service,
data,
exchangeReference,
actions,
sharedContext
) {
for (const shippingMethod of data.shipping_methods ?? []) {
let shippingMethodId
if (!isString(shippingMethod)) {
const methods = await service.createShippingMethods(
[
{
order_id: data.order_id,
exchange_id: exchangeReference.id,
...shippingMethod,
},
],
sharedContext
)
shippingMethodId = methods[0].id
} else {
shippingMethodId = shippingMethod
}
const method = await service.retrieveShippingMethod(
shippingMethodId,
{ relations: ["tax_lines", "adjustments"] },
sharedContext
)
const calculatedAmount = getShippingMethodsTotals([method as any], {})[
method.id
]
actions.push({
action: ChangeActionType.SHIPPING_ADD,
reference: "order_shipping_method",
reference_id: shippingMethodId,
exchange_id: exchangeReference.id,
amount: calculatedAmount.total,
})
}
}
async function processReturnShipping(
service,
data,
exchangeReference,
returnReference,
actions,
sharedContext
) {
let returnShippingMethodId
if (!isString(data.return_shipping)) {
const methods = await service.createShippingMethods(
[
{
order_id: data.order_id,
exchange_id: exchangeReference.id,
return_id: returnReference.id,
...data.return_shipping,
},
],
sharedContext
)
returnShippingMethodId = methods[0].id
} else {
returnShippingMethodId = data.return_shipping
}
const method = await service.retrieveShippingMethod(
returnShippingMethodId,
{ relations: ["tax_lines", "adjustments"] },
sharedContext
)
const calculatedAmount = getShippingMethodsTotals([method as any], {})[
method.id
]
actions.push({
action: ChangeActionType.SHIPPING_ADD,
reference: "order_shipping_method",
reference_id: returnShippingMethodId,
return_id: returnReference.id,
exchange_id: exchangeReference.id,
amount: calculatedAmount.total,
})
}
export async function createExchange(
this: any,
data: OrderTypes.CreateOrderExchangeDTO,
sharedContext?: Context
) {
const order = await this.orderService_.retrieve(
data.order_id,
{ relations: ["items"] },
sharedContext
)
const actions: CreateOrderChangeActionDTO[] = []
const em = sharedContext!.transactionManager as any
const { exchangeReference, returnReference } =
createExchangeAndReturnEntities(em, data, order)
returnReference.items = createReturnItems(
em,
data,
exchangeReference,
returnReference,
actions
)
exchangeReference.additional_items = await processAdditionalItems(
em,
this,
data,
order,
exchangeReference,
actions,
sharedContext
)
await processShippingMethods(
this,
data,
exchangeReference,
actions,
sharedContext
)
await processReturnShipping(
this,
data,
exchangeReference,
returnReference,
actions,
sharedContext
)
const change = await this.createOrderChange_(
{
order_id: data.order_id,
exchange_id: exchangeReference.id,
return_id: returnReference.id,
change_type: OrderChangeType.CLAIM,
reference: "exchange",
reference_id: exchangeReference.id,
description: data.description,
internal_note: data.internal_note,
created_by: data.created_by,
metadata: data.metadata,
actions,
},
sharedContext
)
await promiseAll([
this.createReturns([returnReference], sharedContext),
this.createOrderExchanges([exchangeReference], sharedContext),
this.confirmOrderChange(change[0].id, sharedContext),
])
return exchangeReference
}
@@ -7,67 +7,25 @@ import {
ReturnStatus,
getShippingMethodsTotals,
isString,
promiseAll,
} from "@medusajs/utils"
import { Return, ReturnItem } from "@models"
import { OrderChangeType } from "@types"
import { ChangeActionType } from "../../utils"
export async function createReturn(
this: any,
data: OrderTypes.CreateOrderReturnDTO,
sharedContext?: Context
) {
const order = await this.orderService_.retrieve(
data.order_id,
{
relations: ["items"],
},
sharedContext
)
function createReturnReference(em, data, order) {
return em.create(Return, {
order_id: data.order_id,
order_version: order.version,
status: ReturnStatus.REQUESTED,
no_notification: data.no_notification,
refund_amount: (data.refund_amount as unknown) ?? null,
})
}
const [returnRef] = await this.createReturns(
[
{
order_id: data.order_id,
order_version: order.version,
status: ReturnStatus.REQUESTED,
// TODO: add refund amount / calculate?
// refund_amount: data.refund_amount ?? null,
},
],
sharedContext
)
let shippingMethodId
if (!isString(data.shipping_method)) {
const methods = await this.createShippingMethods(
[
{
order_id: data.order_id,
...data.shipping_method,
},
],
sharedContext
)
shippingMethodId = methods[0].id
} else {
shippingMethodId = data.shipping_method
}
const method = await this.retrieveShippingMethod(
shippingMethodId,
{
relations: ["tax_lines", "adjustments"],
},
sharedContext
)
const calculatedAmount = getShippingMethodsTotals([method as any], {})[
method.id
]
const actions: CreateOrderChangeActionDTO[] = data.items.map((item) => {
return {
function createReturnItems(em, data, returnRef, actions) {
return data.items.map((item) => {
actions.push({
action: ChangeActionType.RETURN_ITEM,
return_id: returnRef.id,
internal_note: item.internal_note,
@@ -79,8 +37,53 @@ export async function createReturn(
quantity: item.quantity,
metadata: item.metadata,
},
}
})
return em.create(ReturnItem, {
reason_id: item.reason_id,
return_id: returnRef.id,
item_id: item.id,
quantity: item.quantity,
note: item.note,
metadata: item.metadata,
})
})
}
async function processShippingMethod(
service,
data,
returnRef,
actions,
sharedContext
) {
let shippingMethodId
if (!isString(data.shipping_method)) {
const methods = await service.createShippingMethods(
[
{
order_id: data.order_id,
return_id: returnRef.id,
...data.shipping_method,
},
],
sharedContext
)
shippingMethodId = methods[0].id
} else {
shippingMethodId = data.shipping_method
}
const method = await service.retrieveShippingMethod(
shippingMethodId,
{ relations: ["tax_lines", "adjustments"] },
sharedContext
)
const calculatedAmount = getShippingMethodsTotals([method as any], {})[
method.id
]
if (shippingMethodId) {
actions.push({
@@ -91,8 +94,16 @@ export async function createReturn(
amount: calculatedAmount.total,
})
}
}
const change = await this.createOrderChange_(
async function createOrderChange(
service,
data,
returnRef,
actions,
sharedContext
) {
return await service.createOrderChange_(
{
order_id: data.order_id,
return_id: returnRef.id,
@@ -107,8 +118,36 @@ export async function createReturn(
},
sharedContext
)
}
await this.confirmOrderChange(change[0].id, sharedContext)
export async function createReturn(
this: any,
data: OrderTypes.CreateOrderReturnDTO,
sharedContext?: Context
) {
const order = await this.orderService_.retrieve(
data.order_id,
{ relations: ["items"] },
sharedContext
)
const em = sharedContext!.transactionManager as any
const returnRef = createReturnReference(em, data, order)
const actions: CreateOrderChangeActionDTO[] = []
returnRef.items = createReturnItems(em, data, returnRef, actions)
await processShippingMethod(this, data, returnRef, actions, sharedContext)
const change = await createOrderChange(
this,
data,
returnRef,
actions,
sharedContext
)
await promiseAll([
this.createReturns([returnRef], sharedContext),
this.confirmOrderChange(change[0].id, sharedContext),
])
return returnRef
}
@@ -1,4 +1,6 @@
export * from "./cancel-fulfillment"
export * from "./create-claim"
export * from "./create-exchange"
export * from "./create-return"
export * from "./receive-return"
export * from "./register-fulfillment"
@@ -1,8 +1,78 @@
import { Context, OrderTypes } from "@medusajs/types"
import { MathBN, ReturnStatus } from "@medusajs/utils"
import { MathBN, ReturnStatus, promiseAll } from "@medusajs/utils"
import { OrderChangeType } from "@types"
import { ChangeActionType } from "../../utils"
function createReturnItems(data) {
return data.items.map((item) => ({
action: ChangeActionType.RECEIVE_RETURN_ITEM,
internal_note: item.internal_note,
reference: data.reference,
reference_id: data.reference_id,
details: {
reference_id: item.id,
quantity: item.quantity,
metadata: item.metadata,
},
}))
}
async function createOrderChange(
service,
data,
returnEntry,
items,
sharedContext
) {
return await service.createOrderChange_(
{
order_id: returnEntry.order_id,
return_id: returnEntry.id,
reference: "return",
reference_id: returnEntry.id,
change_type: OrderChangeType.RETURN,
description: data.description,
internal_note: data.internal_note,
created_by: data.created_by,
metadata: data.metadata,
actions: items,
},
sharedContext
)
}
function updateReturnItems(returnEntry, items) {
return returnEntry.items
.map((item) => {
const data = items.find((i) => i.details.reference_id === item.item_id)
if (!data) return
const receivedQuantity = MathBN.add(
item.received_quantity || 0,
data.details.quantity
)
item.received_quantity = receivedQuantity
return {
id: item.id,
received_quantity: receivedQuantity,
}
})
.filter(Boolean)
}
function checkAllItemsReceived(returnEntry) {
return returnEntry.items.every((item) =>
MathBN.eq(item.received_quantity, item.quantity)
)
}
function getReturnUpdateData(hasReceivedAllItems) {
return hasReceivedAllItems
? { status: ReturnStatus.RECEIVED, received_at: new Date() }
: { status: ReturnStatus.PARTIALLY_RECEIVED }
}
export async function receiveReturn(
this: any,
data: OrderTypes.ReceiveOrderReturnDTO,
@@ -17,59 +87,28 @@ export async function receiveReturn(
sharedContext
)
const items = data.items.map((item) => {
return {
action: ChangeActionType.RECEIVE_RETURN_ITEM,
internal_note: item.internal_note,
reference: data.reference,
reference_id: data.reference_id,
details: {
reference_id: item.id,
quantity: item.quantity,
metadata: item.metadata,
},
}
})
const change = await this.createOrderChange_(
{
order_id: returnEntry.order_id,
reference: "return",
reference_id: returnEntry.id,
change_type: OrderChangeType.RETURN,
description: data.description,
internal_note: data.internal_note,
created_by: data.created_by,
metadata: data.metadata,
actions: items,
},
const items = createReturnItems(data)
const change = await createOrderChange(
this,
data,
returnEntry,
items,
sharedContext
)
await this.confirmOrderChange(change[0].id, sharedContext)
const hasReceivedAllItems = returnEntry.items.every((item) => {
const retItem = items.find((dtItem) => {
return item.detail.item_id === dtItem.details.reference_id
})
const quantity = retItem ? retItem.details.quantity : 0
return MathBN.eq(
MathBN.sub(item.detail.return_requested_quantity, quantity),
0
)
})
const retItemsToUpdate = updateReturnItems(returnEntry, items)
const hasReceivedAllItems = checkAllItemsReceived(returnEntry)
const retData = getReturnUpdateData(hasReceivedAllItems)
const retData = hasReceivedAllItems
? { status: ReturnStatus.RECEIVED, received_at: new Date() }
: { status: ReturnStatus.PARTIALLY_RECEIVED }
const returnRef = await this.updateReturns(
{
selector: { id: returnEntry.id },
data: retData,
},
sharedContext
)
const [returnRef] = await promiseAll([
this.updateReturns(
{ selector: { id: returnEntry.id }, data: retData },
sharedContext
),
this.updateReturnItems(retItemsToUpdate, sharedContext),
])
return returnRef
}