asyavee/medusa-store
1
0
Fork 0
Code Issues Pull Requests Actions 2 Packages Projects Releases Wiki Activity

fix: make packages/medusa/src/api/routes/admin/orders pass eslint (#649)

Browse Source
This commit is contained in:
Woramat Ngamkham
2021-10-28 00:49:59 +07:00
committed by GitHub
parent ce4d3616d7
commit dc8821095c
30 changed files with 601 additions and 754 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.eslintignore
View File

@@ -27,7 +27,6 @@
/packages/medusa/src/api/routes/admin/auth
/packages/medusa/src/api/routes/admin/collections
/packages/medusa/src/api/routes/admin/notes
/packages/medusa/src/api/routes/admin/orders
/packages/medusa/src/api/routes/admin/store
/packages/medusa/src/api/routes/store/carts
/packages/medusa/src/api/routes/store/return-reasons

33
packages/medusa/src/api/routes/admin/orders/add-shipping-method.js
View File

@@ -1,4 +1,3 @@
import _ from "lodash"
import { Validator, MedusaError } from "medusa-core-utils"
import { defaultFields, defaultRelations } from "./"
@@ -28,15 +27,9 @@ export default async (req, res) => {
const { id } = req.params
const schema = Validator.object().keys({
price: Validator.number()
.integer()
.integer()
.allow(0)
.required(),
price: Validator.number().integer().integer().allow(0).required(),
option_id: Validator.string().required(),
data: Validator.object()
.optional()
.default({}),
data: Validator.object().optional().default({}),
})
const { value, error } = schema.validate(req.body)
@@ -44,20 +37,16 @@ export default async (req, res) => {
throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
}
try {
const orderService = req.scope.resolve("orderService")
const orderService = req.scope.resolve("orderService")
await orderService.addShippingMethod(id, value.option_id, value.data, {
price: value.price,
})
await orderService.addShippingMethod(id, value.option_id, value.data, {
price: value.price,
})
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.status(200).json({ order })
} catch (err) {
throw err
}
res.status(200).json({ order })
}

16
packages/medusa/src/api/routes/admin/orders/archive-order.js
View File

@@ -1,17 +1,13 @@
export default async (req, res) => {
const { id } = req.params
try {
const orderService = req.scope.resolve("orderService")
const orderService = req.scope.resolve("orderService")
await orderService.archive(id)
await orderService.archive(id)
const order = await orderService.retrieve(id, {
relations: ["region", "customer", "swaps"],
})
const order = await orderService.retrieve(id, {
relations: ["region", "customer", "swaps"],
})
res.json({ order })
} catch (error) {
throw error
}
res.json({ order })
}

38
packages/medusa/src/api/routes/admin/orders/cancel-claim.js
View File

@@ -24,28 +24,24 @@ import { defaultRelations, defaultFields } from "."
export default async (req, res) => {
const { id, claim_id } = req.params
try {
const claimService = req.scope.resolve("claimService")
const orderService = req.scope.resolve("orderService")
const claimService = req.scope.resolve("claimService")
const orderService = req.scope.resolve("orderService")
const claim = await claimService.retrieve(claim_id)
const claim = await claimService.retrieve(claim_id)
if (claim.order_id !== id) {
throw new MedusaError(
MedusaError.Types.NOT_FOUND,
`no claim was found with the id: ${claim_id} related to order: ${id}`
)
}
await claimService.cancel(claim_id)
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.json({ order })
} catch (error) {
throw error
if (claim.order_id !== id) {
throw new MedusaError(
MedusaError.Types.NOT_FOUND,
`no claim was found with the id: ${claim_id} related to order: ${id}`
)
}
await claimService.cancel(claim_id)
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.json({ order })
}

56
packages/medusa/src/api/routes/admin/orders/cancel-fulfillment-claim.js
View File

@@ -25,37 +25,33 @@ import { defaultRelations, defaultFields } from "."
export default async (req, res) => {
const { id, claim_id, fulfillment_id } = req.params
try {
const fulfillmentService = req.scope.resolve("fulfillmentService")
const claimService = req.scope.resolve("claimService")
const orderService = req.scope.resolve("orderService")
const fulfillmentService = req.scope.resolve("fulfillmentService")
const claimService = req.scope.resolve("claimService")
const orderService = req.scope.resolve("orderService")
const fulfillment = await fulfillmentService.retrieve(fulfillment_id)
const fulfillment = await fulfillmentService.retrieve(fulfillment_id)
if (fulfillment.claim_order_id !== claim_id) {
throw new MedusaError(
MedusaError.Types.NOT_FOUND,
`no fulfillment was found with the id: ${fulfillment_id} related to claim: ${claim_id}`
)
}
const claim = await claimService.retrieve(claim_id)
if (claim.order_id !== id) {
throw new MedusaError(
MedusaError.Types.NOT_FOUND,
`no claim was found with the id: ${claim_id} related to order: ${id}`
)
}
await claimService.cancelFulfillment(fulfillment_id)
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.json({ order })
} catch (error) {
throw error
if (fulfillment.claim_order_id !== claim_id) {
throw new MedusaError(
MedusaError.Types.NOT_FOUND,
`no fulfillment was found with the id: ${fulfillment_id} related to claim: ${claim_id}`
)
}
const claim = await claimService.retrieve(claim_id)
if (claim.order_id !== id) {
throw new MedusaError(
MedusaError.Types.NOT_FOUND,
`no claim was found with the id: ${claim_id} related to order: ${id}`
)
}
await claimService.cancelFulfillment(fulfillment_id)
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.json({ order })
}

58
packages/medusa/src/api/routes/admin/orders/cancel-fulfillment-swap.js
View File

@@ -25,38 +25,34 @@ import { defaultRelations, defaultFields } from "."
export default async (req, res) => {
const { id, swap_id, fulfillment_id } = req.params
try {
const fulfillmentService = req.scope.resolve("fulfillmentService")
const swapService = req.scope.resolve("swapService")
const orderService = req.scope.resolve("orderService")
const fulfillmentService = req.scope.resolve("fulfillmentService")
const swapService = req.scope.resolve("swapService")
const orderService = req.scope.resolve("orderService")
const fulfillment = await fulfillmentService.retrieve(fulfillment_id)
const fulfillment = await fulfillmentService.retrieve(fulfillment_id)
if (fulfillment.swap_id !== swap_id) {
throw new MedusaError(
MedusaError.Types.NOT_FOUND,
`no fulfillment was found with the id: ${fulfillment_id} related to swap: ${id}`
)
}
const swap = await swapService.retrieve(swap_id)
if (swap.order_id !== id) {
throw new MedusaError(
MedusaError.Types.NOT_FOUND,
`no swap was found with the id: ${swap_id} related to order: ${id}`
)
}
await swapService.cancelFulfillment(fulfillment_id)
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.json({ order })
} catch (error) {
throw error
if (fulfillment.swap_id !== swap_id) {
throw new MedusaError(
MedusaError.Types.NOT_FOUND,
`no fulfillment was found with the id: ${fulfillment_id} related to swap: ${id}`
)
}
const swap = await swapService.retrieve(swap_id)
if (swap.order_id !== id) {
throw new MedusaError(
MedusaError.Types.NOT_FOUND,
`no swap was found with the id: ${swap_id} related to order: ${id}`
)
}
await swapService.cancelFulfillment(fulfillment_id)
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.json({ order })
}

38
packages/medusa/src/api/routes/admin/orders/cancel-fulfillment.js
View File

@@ -24,28 +24,24 @@ import { defaultRelations, defaultFields } from "."
export default async (req, res) => {
const { id, fulfillment_id } = req.params
try {
const fulfillmentService = req.scope.resolve("fulfillmentService")
const orderService = req.scope.resolve("orderService")
const fulfillmentService = req.scope.resolve("fulfillmentService")
const orderService = req.scope.resolve("orderService")
const fulfillment = await fulfillmentService.retrieve(fulfillment_id)
const fulfillment = await fulfillmentService.retrieve(fulfillment_id)
if (fulfillment.order_id !== id) {
throw new MedusaError(
MedusaError.Types.NOT_FOUND,
`no fulfillment was found with the id: ${fulfillment_id} related to order: ${id}`
)
}
await orderService.cancelFulfillment(fulfillment_id)
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.json({ order })
} catch (error) {
throw error
if (fulfillment.order_id !== id) {
throw new MedusaError(
MedusaError.Types.NOT_FOUND,
`no fulfillment was found with the id: ${fulfillment_id} related to order: ${id}`
)
}
await orderService.cancelFulfillment(fulfillment_id)
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.json({ order })
}

18
packages/medusa/src/api/routes/admin/orders/cancel-order.js
View File

@@ -22,17 +22,13 @@ import { defaultFields, defaultRelations } from "."
export default async (req, res) => {
const { id } = req.params
try {
const orderService = req.scope.resolve("orderService")
await orderService.cancel(id)
const orderService = req.scope.resolve("orderService")
await orderService.cancel(id)
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.json({ order })
} catch (error) {
throw error
}
res.json({ order })
}

38
packages/medusa/src/api/routes/admin/orders/cancel-swap.js
View File

@@ -24,28 +24,24 @@ import { defaultRelations, defaultFields } from "."
export default async (req, res) => {
const { id, swap_id } = req.params
try {
const swapService = req.scope.resolve("swapService")
const orderService = req.scope.resolve("orderService")
const swapService = req.scope.resolve("swapService")
const orderService = req.scope.resolve("orderService")
const swap = await swapService.retrieve(swap_id)
const swap = await swapService.retrieve(swap_id)
if (swap.order_id !== id) {
throw new MedusaError(
MedusaError.Types.NOT_FOUND,
`no swap was found with the id: ${swap_id} related to order: ${id}`
)
}
await swapService.cancel(swap_id)
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.json({ order })
} catch (error) {
throw error
if (swap.order_id !== id) {
throw new MedusaError(
MedusaError.Types.NOT_FOUND,
`no swap was found with the id: ${swap_id} related to order: ${id}`
)
}
await swapService.cancel(swap_id)
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.json({ order })
}

18
packages/medusa/src/api/routes/admin/orders/capture-payment.js
View File

@@ -22,18 +22,14 @@ import { defaultRelations, defaultFields } from "./"
export default async (req, res) => {
const { id } = req.params
try {
const orderService = req.scope.resolve("orderService")
const orderService = req.scope.resolve("orderService")
await orderService.capturePayment(id)
await orderService.capturePayment(id)
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.json({ order })
} catch (error) {
throw error
}
res.json({ order })
}

16
packages/medusa/src/api/routes/admin/orders/complete-order.js
View File

@@ -1,17 +1,13 @@
export default async (req, res) => {
const { id } = req.params
try {
const orderService = req.scope.resolve("orderService")
const orderService = req.scope.resolve("orderService")
await orderService.completeOrder(id)
await orderService.completeOrder(id)
const order = await orderService.retrieve(id, {
relations: ["region", "customer", "swaps"],
})
const order = await orderService.retrieve(id, {
relations: ["region", "customer", "swaps"],
})
res.json({ order })
} catch (error) {
throw error
}
res.json({ order })
}

32
packages/medusa/src/api/routes/admin/orders/create-claim-shipment.js
View File

@@ -39,9 +39,7 @@ export default async (req, res) => {
const schema = Validator.object().keys({
fulfillment_id: Validator.string().required(),
tracking_numbers: Validator.array()
.items(Validator.string())
.optional(),
tracking_numbers: Validator.array().items(Validator.string()).optional(),
})
const { value, error } = schema.validate(req.body)
@@ -49,23 +47,19 @@ export default async (req, res) => {
throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
}
try {
const orderService = req.scope.resolve("orderService")
const claimService = req.scope.resolve("claimService")
const orderService = req.scope.resolve("orderService")
const claimService = req.scope.resolve("claimService")
await claimService.createShipment(
claim_id,
value.fulfillment_id,
value.tracking_numbers.map(n => ({ tracking_number: n }))
)
await claimService.createShipment(
claim_id,
value.fulfillment_id,
value.tracking_numbers.map((n) => ({ tracking_number: n }))
)
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.json({ order })
} catch (error) {
throw error
}
res.json({ order })
}

330
packages/medusa/src/api/routes/admin/orders/create-claim.js
View File

@@ -112,9 +112,7 @@ import { defaultRelations, defaultFields } from "./"
export default async (req, res) => {
const { id } = req.params
const schema = Validator.object().keys({
type: Validator.string()
.valid("replace", "refund")
.required(),
type: Validator.string().valid("replace", "refund").required(),
claim_items: Validator.array()
.items({
item_id: Validator.string().required(),
@@ -133,9 +131,7 @@ export default async (req, res) => {
return_shipping: Validator.object()
.keys({
option_id: Validator.string().optional(),
price: Validator.number()
.integer()
.optional(),
price: Validator.number().integer().optional(),
})
.optional(),
additional_items: Validator.array()
@@ -148,14 +144,10 @@ export default async (req, res) => {
.items({
id: Validator.string().optional(),
option_id: Validator.string().optional(),
price: Validator.number()
.integer()
.optional(),
price: Validator.number().integer().optional(),
})
.optional(),
refund_amount: Validator.number()
.integer()
.optional(),
refund_amount: Validator.number().integer().optional(),
shipping_address: Validator.object().optional(),
no_notification: Validator.boolean().optional(),
metadata: Validator.object().optional(),
@@ -185,176 +177,172 @@ export default async (req, res) => {
res.setHeader("Access-Control-Expose-Headers", "Idempotency-Key")
res.setHeader("Idempotency-Key", idempotencyKey.idempotency_key)
try {
const orderService = req.scope.resolve("orderService")
const claimService = req.scope.resolve("claimService")
const returnService = req.scope.resolve("returnService")
const orderService = req.scope.resolve("orderService")
const claimService = req.scope.resolve("claimService")
const returnService = req.scope.resolve("returnService")
let inProgress = true
let err = false
let inProgress = true
let err = false
while (inProgress) {
switch (idempotencyKey.recovery_point) {
case "started": {
const { key, error } = await idempotencyKeyService.workStage(
idempotencyKey.idempotency_key,
async manager => {
const order = await orderService
.withTransaction(manager)
.retrieve(id, {
relations: [
"items",
"cart",
"cart.discounts",
"cart.discounts.rule",
],
})
await claimService.withTransaction(manager).create({
idempotency_key: idempotencyKey.idempotency_key,
order,
type: value.type,
shipping_address: value.shipping_address,
claim_items: value.claim_items,
return_shipping: value.return_shipping,
additional_items: value.additional_items,
shipping_methods: value.shipping_methods,
no_notification: value.no_notification,
metadata: value.metadata,
while (inProgress) {
switch (idempotencyKey.recovery_point) {
case "started": {
const { key, error } = await idempotencyKeyService.workStage(
idempotencyKey.idempotency_key,
async (manager) => {
const order = await orderService
.withTransaction(manager)
.retrieve(id, {
relations: [
"items",
"cart",
"cart.discounts",
"cart.discounts.rule",
],
})
return {
recovery_point: "claim_created",
}
await claimService.withTransaction(manager).create({
idempotency_key: idempotencyKey.idempotency_key,
order,
type: value.type,
shipping_address: value.shipping_address,
claim_items: value.claim_items,
return_shipping: value.return_shipping,
additional_items: value.additional_items,
shipping_methods: value.shipping_methods,
no_notification: value.no_notification,
metadata: value.metadata,
})
return {
recovery_point: "claim_created",
}
)
if (error) {
inProgress = false
err = error
} else {
idempotencyKey = key
}
break
}
)
case "claim_created": {
const { key, error } = await idempotencyKeyService.workStage(
idempotencyKey.idempotency_key,
async manager => {
let claim = await claimService.withTransaction(manager).list({
idempotency_key: idempotencyKey.idempotency_key,
})
if (!claim.length) {
throw new MedusaError(
MedusaError.Types.INVALID_DATA,
`Claim not found`
)
}
claim = claim[0]
if (claim.type === "refund") {
await claimService
.withTransaction(manager)
.processRefund(claim.id)
}
return {
recovery_point: "refund_handled",
}
}
)
if (error) {
inProgress = false
err = error
} else {
idempotencyKey = key
}
break
}
case "refund_handled": {
const { key, error } = await idempotencyKeyService.workStage(
idempotencyKey.idempotency_key,
async manager => {
let order = await orderService
.withTransaction(manager)
.retrieve(id, {
relations: ["items", "discounts"],
})
let claim = await claimService.withTransaction(manager).list(
{
idempotency_key: idempotencyKey.idempotency_key,
},
{
relations: ["return_order"],
}
)
if (!claim.length) {
throw new MedusaError(
MedusaError.Types.INVALID_DATA,
`Claim not found`
)
}
claim = claim[0]
if (claim.return_order) {
await returnService
.withTransaction(manager)
.fulfill(claim.return_order.id)
}
order = await orderService.withTransaction(manager).retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
return {
response_code: 200,
response_body: { order },
}
}
)
if (error) {
inProgress = false
err = error
} else {
idempotencyKey = key
}
break
}
case "finished": {
if (error) {
inProgress = false
break
err = error
} else {
idempotencyKey = key
}
default:
idempotencyKey = await idempotencyKeyService.update(
idempotencyKey.idempotency_key,
{
recovery_point: "finished",
response_code: 500,
response_body: { message: "Unknown recovery point" },
}
)
break
break
}
}
if (err) {
throw err
}
case "claim_created": {
const { key, error } = await idempotencyKeyService.workStage(
idempotencyKey.idempotency_key,
async (manager) => {
let claim = await claimService.withTransaction(manager).list({
idempotency_key: idempotencyKey.idempotency_key,
})
res.status(idempotencyKey.response_code).json(idempotencyKey.response_body)
} catch (error) {
throw error
if (!claim.length) {
throw new MedusaError(
MedusaError.Types.INVALID_DATA,
`Claim not found`
)
}
claim = claim[0]
if (claim.type === "refund") {
await claimService
.withTransaction(manager)
.processRefund(claim.id)
}
return {
recovery_point: "refund_handled",
}
}
)
if (error) {
inProgress = false
err = error
} else {
idempotencyKey = key
}
break
}
case "refund_handled": {
const { key, error } = await idempotencyKeyService.workStage(
idempotencyKey.idempotency_key,
async (manager) => {
let order = await orderService
.withTransaction(manager)
.retrieve(id, {
relations: ["items", "discounts"],
})
let claim = await claimService.withTransaction(manager).list(
{
idempotency_key: idempotencyKey.idempotency_key,
},
{
relations: ["return_order"],
}
)
if (!claim.length) {
throw new MedusaError(
MedusaError.Types.INVALID_DATA,
`Claim not found`
)
}
claim = claim[0]
if (claim.return_order) {
await returnService
.withTransaction(manager)
.fulfill(claim.return_order.id)
}
order = await orderService.withTransaction(manager).retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
return {
response_code: 200,
response_body: { order },
}
}
)
if (error) {
inProgress = false
err = error
} else {
idempotencyKey = key
}
break
}
case "finished": {
inProgress = false
break
}
default:
idempotencyKey = await idempotencyKeyService.update(
idempotencyKey.idempotency_key,
{
recovery_point: "finished",
response_code: 500,
response_body: { message: "Unknown recovery point" },
}
)
break
}
}
if (err) {
throw err
}
res.status(idempotencyKey.response_code).json(idempotencyKey.response_body)
}

24
packages/medusa/src/api/routes/admin/orders/create-fulfillment.js
View File

@@ -61,21 +61,17 @@ export default async (req, res) => {
throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
}
try {
const orderService = req.scope.resolve("orderService")
const orderService = req.scope.resolve("orderService")
await orderService.createFulfillment(id, value.items, {
metadata: value.metadata,
no_notification: value.no_notification,
})
await orderService.createFulfillment(id, value.items, {
metadata: value.metadata,
no_notification: value.no_notification,
})
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.json({ order })
} catch (error) {
throw error
}
res.json({ order })
}

16
packages/medusa/src/api/routes/admin/orders/create-order.js
View File

@@ -3,9 +3,7 @@ import { MedusaError, Validator } from "medusa-core-utils"
export default async (req, res) => {
const schema = Validator.object().keys({
status: Validator.string().optional(),
email: Validator.string()
.email()
.required(),
email: Validator.string().email().required(),
billing_address: Validator.address().required(),
shipping_address: Validator.address().required(),
items: Validator.array().required(),
@@ -36,13 +34,9 @@ export default async (req, res) => {
throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
}
try {
const orderService = req.scope.resolve("orderService")
let order = await orderService.create(value)
order = await orderService.decorate(order, [], ["region"])
const orderService = req.scope.resolve("orderService")
let order = await orderService.create(value)
order = await orderService.decorate(order, [], ["region"])
res.status(200).json({ order })
} catch (err) {
throw err
}
res.status(200).json({ order })
}

32
packages/medusa/src/api/routes/admin/orders/create-shipment.js
View File

@@ -41,9 +41,7 @@ export default async (req, res) => {
const schema = Validator.object().keys({
fulfillment_id: Validator.string().required(),
tracking_numbers: Validator.array()
.items(Validator.string())
.optional(),
tracking_numbers: Validator.array().items(Validator.string()).optional(),
no_notification: Validator.boolean().optional(),
})
@@ -52,23 +50,19 @@ export default async (req, res) => {
throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
}
try {
const orderService = req.scope.resolve("orderService")
const orderService = req.scope.resolve("orderService")
await orderService.createShipment(
id,
value.fulfillment_id,
value.tracking_numbers.map(n => ({ tracking_number: n })),
{ no_notification: value.no_notification }
)
await orderService.createShipment(
id,
value.fulfillment_id,
value.tracking_numbers.map((n) => ({ tracking_number: n })),
{ no_notification: value.no_notification }
)
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.json({ order })
} catch (error) {
throw error
}
res.json({ order })
}

34
packages/medusa/src/api/routes/admin/orders/create-swap-shipment.js
View File

@@ -42,9 +42,7 @@ export default async (req, res) => {
const schema = Validator.object().keys({
fulfillment_id: Validator.string().required(),
tracking_numbers: Validator.array()
.items(Validator.string())
.optional(),
tracking_numbers: Validator.array().items(Validator.string()).optional(),
no_notification: Validator.boolean().optional(),
})
@@ -53,24 +51,20 @@ export default async (req, res) => {
throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
}
try {
const orderService = req.scope.resolve("orderService")
const swapService = req.scope.resolve("swapService")
const orderService = req.scope.resolve("orderService")
const swapService = req.scope.resolve("swapService")
await swapService.createShipment(
swap_id,
value.fulfillment_id,
value.tracking_numbers.map(n => ({ tracking_number: n })),
{ no_notification: value.no_notification }
)
await swapService.createShipment(
swap_id,
value.fulfillment_id,
value.tracking_numbers.map((n) => ({ tracking_number: n })),
{ no_notification: value.no_notification }
)
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.json({ order })
} catch (error) {
throw error
}
res.json({ order })
}

214
packages/medusa/src/api/routes/admin/orders/create-swap.js
View File

@@ -87,9 +87,7 @@ export default async (req, res) => {
return_shipping: Validator.object()
.keys({
option_id: Validator.string().optional(),
price: Validator.number()
.integer()
.optional(),
price: Validator.number().integer().optional(),
})
.optional(),
additional_items: Validator.array().items({
@@ -131,127 +129,121 @@ export default async (req, res) => {
res.setHeader("Access-Control-Expose-Headers", "Idempotency-Key")
res.setHeader("Idempotency-Key", idempotencyKey.idempotency_key)
try {
const orderService = req.scope.resolve("orderService")
const swapService = req.scope.resolve("swapService")
const returnService = req.scope.resolve("returnService")
const orderService = req.scope.resolve("orderService")
const swapService = req.scope.resolve("swapService")
const returnService = req.scope.resolve("returnService")
let inProgress = true
let err = false
let inProgress = true
let err = false
while (inProgress) {
switch (idempotencyKey.recovery_point) {
case "started": {
const { key, error } = await idempotencyKeyService.workStage(
idempotencyKey.idempotency_key,
async manager => {
const order = await orderService
.withTransaction(manager)
.retrieve(id, {
select: ["refunded_total", "total"],
relations: ["items", "swaps", "swaps.additional_items"],
})
const swap = await swapService
.withTransaction(manager)
.create(
order,
value.return_items,
value.additional_items,
value.return_shipping,
{
idempotency_key: idempotencyKey.idempotency_key,
no_notification: value.no_notification,
allow_backorder: value.allow_backorder,
}
)
await swapService
.withTransaction(manager)
.createCart(swap.id, value.custom_shipping_options)
const returnOrder = await returnService
.withTransaction(manager)
.retrieveBySwap(swap.id)
await returnService
.withTransaction(manager)
.fulfill(returnOrder.id)
return {
recovery_point: "swap_created",
}
}
)
if (error) {
inProgress = false
err = error
} else {
idempotencyKey = key
}
break
}
case "swap_created": {
const { key, error } = await idempotencyKeyService.workStage(
idempotencyKey.idempotency_key,
async manager => {
const swaps = await swapService.list({
idempotency_key: idempotencyKey.idempotency_key,
while (inProgress) {
switch (idempotencyKey.recovery_point) {
case "started": {
const { key, error } = await idempotencyKeyService.workStage(
idempotencyKey.idempotency_key,
async (manager) => {
const order = await orderService
.withTransaction(manager)
.retrieve(id, {
select: ["refunded_total", "total"],
relations: ["items", "swaps", "swaps.additional_items"],
})
if (!swaps.length) {
throw new MedusaError(
MedusaError.Types.INVALID_DATA,
"Swap not found"
)
}
const swap = await swapService
.withTransaction(manager)
.create(
order,
value.return_items,
value.additional_items,
value.return_shipping,
{
idempotency_key: idempotencyKey.idempotency_key,
no_notification: value.no_notification,
allow_backorder: value.allow_backorder,
}
)
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
await swapService
.withTransaction(manager)
.createCart(swap.id, value.custom_shipping_options)
const returnOrder = await returnService
.withTransaction(manager)
.retrieveBySwap(swap.id)
return {
response_code: 200,
response_body: { order },
}
await returnService.withTransaction(manager).fulfill(returnOrder.id)
return {
recovery_point: "swap_created",
}
)
if (error) {
inProgress = false
err = error
} else {
idempotencyKey = key
}
break
}
)
case "finished": {
if (error) {
inProgress = false
break
err = error
} else {
idempotencyKey = key
}
default:
idempotencyKey = await idempotencyKeyService.update(
idempotencyKey.idempotency_key,
{
recovery_point: "finished",
response_code: 500,
response_body: { message: "Unknown recovery point" },
}
)
break
break
}
}
if (err) {
throw err
}
case "swap_created": {
const { key, error } = await idempotencyKeyService.workStage(
idempotencyKey.idempotency_key,
async (manager) => {
const swaps = await swapService.list({
idempotency_key: idempotencyKey.idempotency_key,
})
res.status(idempotencyKey.response_code).json(idempotencyKey.response_body)
} catch (error) {
throw error
if (!swaps.length) {
throw new MedusaError(
MedusaError.Types.INVALID_DATA,
"Swap not found"
)
}
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
return {
response_code: 200,
response_body: { order },
}
}
)
if (error) {
inProgress = false
err = error
} else {
idempotencyKey = key
}
break
}
case "finished": {
inProgress = false
break
}
default:
idempotencyKey = await idempotencyKeyService.update(
idempotencyKey.idempotency_key,
{
recovery_point: "finished",
response_code: 500,
response_body: { message: "Unknown recovery point" },
}
)
break
}
}
if (err) {
throw err
}
res.status(idempotencyKey.response_code).json(idempotencyKey.response_body)
}

16
packages/medusa/src/api/routes/admin/orders/delete-metadata.js
View File

@@ -21,17 +21,13 @@
export default async (req, res) => {
const { id, key } = req.params
try {
const orderService = req.scope.resolve("orderService")
const orderService = req.scope.resolve("orderService")
await orderService.deleteMetadata(id, key)
await orderService.deleteMetadata(id, key)
const order = await orderService.retrieve(id, {
relations: ["region", "customer", "swaps"],
})
const order = await orderService.retrieve(id, {
relations: ["region", "customer", "swaps"],
})
res.status(200).json({ order })
} catch (err) {
throw err
}
res.status(200).json({ order })
}

30
packages/medusa/src/api/routes/admin/orders/fulfill-claim.js
View File

@@ -45,25 +45,21 @@ export default async (req, res) => {
throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
}
try {
const orderService = req.scope.resolve("orderService")
const claimService = req.scope.resolve("claimService")
const entityManager = req.scope.resolve("manager")
const orderService = req.scope.resolve("orderService")
const claimService = req.scope.resolve("claimService")
const entityManager = req.scope.resolve("manager")
await entityManager.transaction(async manager => {
await claimService.withTransaction(manager).createFulfillment(claim_id, {
metadata: value.metadata,
no_notification: value.no_notification,
})
await entityManager.transaction(async (manager) => {
await claimService.withTransaction(manager).createFulfillment(claim_id, {
metadata: value.metadata,
no_notification: value.no_notification,
})
})
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.status(200).json({ order })
} catch (err) {
throw err
}
res.status(200).json({ order })
}

34
packages/medusa/src/api/routes/admin/orders/fulfill-swap.js
View File

@@ -45,25 +45,21 @@ export default async (req, res) => {
throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
}
try {
const orderService = req.scope.resolve("orderService")
const swapService = req.scope.resolve("swapService")
const entityManager = req.scope.resolve("manager")
const orderService = req.scope.resolve("orderService")
const swapService = req.scope.resolve("swapService")
const entityManager = req.scope.resolve("manager")
await entityManager.transaction(async manager => {
await swapService.withTransaction(manager).createFulfillment(swap_id, {
metadata: value.metadata,
no_notification: value.no_notification,
})
const order = await orderService.withTransaction(manager).retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.status(200).json({ order })
await entityManager.transaction(async (manager) => {
await swapService.withTransaction(manager).createFulfillment(swap_id, {
metadata: value.metadata,
no_notification: value.no_notification,
})
} catch (err) {
throw err
}
const order = await orderService.withTransaction(manager).retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.status(200).json({ order })
})
}

16
packages/medusa/src/api/routes/admin/orders/get-order.js
View File

@@ -22,16 +22,12 @@ import { defaultRelations, defaultFields } from "./"
export default async (req, res) => {
const { id } = req.params
try {
const orderService = req.scope.resolve("orderService")
const orderService = req.scope.resolve("orderService")
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.json({ order })
} catch (error) {
throw error
}
res.json({ order })
}

2
packages/medusa/src/api/routes/admin/orders/index.js
View File

@@ -3,7 +3,7 @@ import middlewares from "../../../middlewares"
const route = Router()
export default app => {
export default (app) => {
app.use("/orders", route)
/**

93
packages/medusa/src/api/routes/admin/orders/list-orders.js
View File

@@ -30,58 +30,51 @@ export default async (req, res) => {
throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
}
try {
const orderService = req.scope.resolve("orderService")
const orderService = req.scope.resolve("orderService")
const limit = parseInt(req.query.limit) || 50
const offset = parseInt(req.query.offset) || 0
const limit = parseInt(req.query.limit) || 50
const offset = parseInt(req.query.offset) || 0
let selector = {}
const selector = {}
if ("q" in req.query) {
selector.q = req.query.q
}
let includeFields = []
if ("fields" in req.query) {
includeFields = req.query.fields.split(",")
// Ensure created_at is included, since we are sorting on this
includeFields.push("created_at")
}
let expandFields = []
if ("expand" in req.query) {
expandFields = req.query.expand.split(",")
}
for (const k of filterableFields) {
if (k in value) {
selector[k] = value[k]
}
}
const listConfig = {
select: includeFields.length ? includeFields : defaultFields,
relations: expandFields.length ? expandFields : defaultRelations,
skip: offset,
take: limit,
order: { created_at: "DESC" },
}
const [orders, count] = await orderService.listAndCount(
selector,
listConfig
)
let data = orders
const fields = [...includeFields, ...expandFields]
if (fields.length) {
data = orders.map(o => _.pick(o, fields))
}
res.json({ orders: data, count, offset, limit })
} catch (error) {
throw error
if ("q" in req.query) {
selector.q = req.query.q
}
let includeFields = []
if ("fields" in req.query) {
includeFields = req.query.fields.split(",")
// Ensure created_at is included, since we are sorting on this
includeFields.push("created_at")
}
let expandFields = []
if ("expand" in req.query) {
expandFields = req.query.expand.split(",")
}
for (const k of filterableFields) {
if (k in value) {
selector[k] = value[k]
}
}
const listConfig = {
select: includeFields.length ? includeFields : defaultFields,
relations: expandFields.length ? expandFields : defaultRelations,
skip: offset,
take: limit,
order: { created_at: "DESC" },
}
const [orders, count] = await orderService.listAndCount(selector, listConfig)
let data = orders
const fields = [...includeFields, ...expandFields]
if (fields.length) {
data = orders.map((o) => _.pick(o, fields))
}
res.json({ orders: data, count, offset, limit })
}

26
packages/medusa/src/api/routes/admin/orders/process-swap-payment.js
View File

@@ -23,22 +23,18 @@ import { defaultFields, defaultRelations } from "./"
export default async (req, res) => {
const { id, swap_id } = req.params
try {
const orderService = req.scope.resolve("orderService")
const swapService = req.scope.resolve("swapService")
const entityManager = req.scope.resolve("manager")
const orderService = req.scope.resolve("orderService")
const swapService = req.scope.resolve("swapService")
const entityManager = req.scope.resolve("manager")
await entityManager.transaction(async manager => {
await swapService.withTransaction(manager).processDifference(swap_id)
await entityManager.transaction(async (manager) => {
await swapService.withTransaction(manager).processDifference(swap_id)
const order = await orderService.withTransaction(manager).retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.json({ order })
const order = await orderService.withTransaction(manager).retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
} catch (error) {
throw error
}
res.json({ order })
})
}

36
packages/medusa/src/api/routes/admin/orders/receive-swap.js
View File

@@ -54,28 +54,24 @@ export default async (req, res) => {
throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
}
try {
const orderService = req.scope.resolve("orderService")
const swapService = req.scope.resolve("swapService")
const entityManager = req.scope.resolve("manager")
const orderService = req.scope.resolve("orderService")
const swapService = req.scope.resolve("swapService")
const entityManager = req.scope.resolve("manager")
await entityManager.transaction(async manager => {
await swapService
.withTransaction(manager)
.receiveReturn(swap_id, value.items)
await entityManager.transaction(async (manager) => {
await swapService
.withTransaction(manager)
.receiveReturn(swap_id, value.items)
await orderService
.withTransaction(manager)
.registerSwapReceived(id, swap_id)
})
await orderService
.withTransaction(manager)
.registerSwapReceived(id, swap_id)
})
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.status(200).json({ order })
} catch (err) {
throw err
}
res.status(200).json({ order })
}

34
packages/medusa/src/api/routes/admin/orders/refund-payment.js
View File

@@ -43,13 +43,9 @@ import { defaultRelations, defaultFields } from "./"
export default async (req, res) => {
const { id } = req.params
const schema = Validator.object().keys({
amount: Validator.number()
.integer()
.required(),
amount: Validator.number().integer().required(),
reason: Validator.string().required(),
note: Validator.string()
.allow("")
.optional(),
note: Validator.string().allow("").optional(),
no_notification: Validator.boolean().optional(),
})
@@ -59,24 +55,16 @@ export default async (req, res) => {
throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
}
try {
const orderService = req.scope.resolve("orderService")
const orderService = req.scope.resolve("orderService")
await orderService.createRefund(
id,
value.amount,
value.reason,
value.note,
{ no_notification: value.no_notification }
)
await orderService.createRefund(id, value.amount, value.reason, value.note, {
no_notification: value.no_notification,
})
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.status(200).json({ order })
} catch (err) {
throw err
}
res.status(200).json({ order })
}

14
packages/medusa/src/api/routes/admin/orders/request-return.js
View File

@@ -76,16 +76,12 @@ export default async (req, res) => {
return_shipping: Validator.object()
.keys({
option_id: Validator.string().optional(),
price: Validator.number()
.integer()
.optional(),
price: Validator.number().integer().optional(),
})
.optional(),
receive_now: Validator.boolean().default(false),
no_notification: Validator.boolean().optional(),
refund: Validator.number()
.integer()
.optional(),
refund: Validator.number().integer().optional(),
})
const { value, error } = schema.validate(req.body)
@@ -126,7 +122,7 @@ export default async (req, res) => {
case "started": {
const { key, error } = await idempotencyKeyService.workStage(
idempotencyKey.idempotency_key,
async manager => {
async (manager) => {
const returnObj = {
order_id: id,
idempotency_key: idempotencyKey.idempotency_key,
@@ -145,7 +141,7 @@ export default async (req, res) => {
}
}
let order = await orderService
const order = await orderService
.withTransaction(manager)
.retrieve(id)
@@ -191,7 +187,7 @@ export default async (req, res) => {
case "return_requested": {
const { key, error } = await idempotencyKeyService.workStage(
idempotencyKey.idempotency_key,
async manager => {
async (manager) => {
let order = await orderService
.withTransaction(manager)
.retrieve(id, { relations: ["returns"] })

24
packages/medusa/src/api/routes/admin/orders/update-claim.js
View File

@@ -104,9 +104,7 @@ export default async (req, res) => {
.items({
id: Validator.string().optional(),
option_id: Validator.string().optional(),
price: Validator.number()
.integer()
.optional(),
price: Validator.number().integer().optional(),
})
.optional(),
no_notification: Validator.boolean().optional(),
@@ -118,19 +116,15 @@ export default async (req, res) => {
throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
}
try {
const orderService = req.scope.resolve("orderService")
const claimService = req.scope.resolve("claimService")
const orderService = req.scope.resolve("orderService")
const claimService = req.scope.resolve("claimService")
await claimService.update(claim_id, value)
await claimService.update(claim_id, value)
const data = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
const data = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.json({ order: data })
} catch (error) {
throw error
}
res.json({ order: data })
}

18
packages/medusa/src/api/routes/admin/orders/update-order.js
View File

@@ -31,18 +31,14 @@ export default async (req, res) => {
throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
}
try {
const orderService = req.scope.resolve("orderService")
const orderService = req.scope.resolve("orderService")
await orderService.update(id, value)
await orderService.update(id, value)
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
const order = await orderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
res.status(200).json({ order })
} catch (err) {
throw err
}
res.status(200).json({ order })
}