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

Fix linting errors in admin/draft-orders (#676)

Browse Source
This commit is contained in:
Daniel Tiringer
2021-10-26 17:59:36 +00:00
committed by GitHub
parent 748270a75d
commit c648a3c960
11 changed files with 235 additions and 288 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.eslintignore
View File

@@ -26,7 +26,6 @@
/packages/medusa/src/api/routes/admin/apps
/packages/medusa/src/api/routes/admin/auth
/packages/medusa/src/api/routes/admin/collections
/packages/medusa/src/api/routes/admin/draft-orders
/packages/medusa/src/api/routes/admin/notes
/packages/medusa/src/api/routes/admin/orders
/packages/medusa/src/api/routes/admin/return-reasons

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

@@ -98,23 +98,15 @@ import { defaultFields, defaultRelations } from "."
export default async (req, res) => {
const schema = Validator.object().keys({
status: Validator.string()
.valid("open", "completed")
.optional(),
email: Validator.string()
.email()
.required(),
status: Validator.string().valid("open", "completed").optional(),
email: Validator.string().email().required(),
billing_address: Validator.address().optional(),
shipping_address: Validator.address().optional(),
items: Validator.array()
.items({
variant_id: Validator.string()
.optional()
.allow(""),
variant_id: Validator.string().optional().allow(""),
unit_price: Validator.number().optional(),
title: Validator.string()
.optional()
.allow(""),
title: Validator.string().optional().allow(""),
quantity: Validator.number().required(),
metadata: Validator.object().default({}),
})
@@ -131,11 +123,7 @@ export default async (req, res) => {
.items({
option_id: Validator.string().required(),
data: Validator.object().optional(),
price: Validator.number()
.integer()
.integer()
.allow(0)
.optional(),
price: Validator.number().integer().integer().allow(0).optional(),
})
.required(),
metadata: Validator.object().optional(),
@@ -148,17 +136,13 @@ export default async (req, res) => {
value = transformIdableFields(value, ["shipping_address", "billing_address"])
try {
const draftOrderService = req.scope.resolve("draftOrderService")
let draftOrder = await draftOrderService.create(value)
const draftOrderService = req.scope.resolve("draftOrderService")
let draftOrder = await draftOrderService.create(value)
draftOrder = await draftOrderService.retrieve(draftOrder.id, {
relations: defaultRelations,
select: defaultFields,
})
draftOrder = await draftOrderService.retrieve(draftOrder.id, {
relations: defaultRelations,
select: defaultFields,
})
res.status(200).json({ draft_order: draftOrder })
} catch (err) {
throw err
}
res.status(200).json({ draft_order: draftOrder })
}

94
packages/medusa/src/api/routes/admin/draft-orders/create-line-item.js
View File

@@ -55,57 +55,53 @@ export default async (req, res) => {
throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
}
try {
const draftOrderService = req.scope.resolve("draftOrderService")
const cartService = req.scope.resolve("cartService")
const lineItemService = req.scope.resolve("lineItemService")
const entityManager = req.scope.resolve("manager")
const draftOrderService = req.scope.resolve("draftOrderService")
const cartService = req.scope.resolve("cartService")
const lineItemService = req.scope.resolve("lineItemService")
const entityManager = req.scope.resolve("manager")
await entityManager.transaction(async manager => {
const draftOrder = await draftOrderService
await entityManager.transaction(async (manager) => {
const draftOrder = await draftOrderService
.withTransaction(manager)
.retrieve(id, { select: defaultFields, relations: ["cart"] })
if (draftOrder.status === "completed") {
throw new MedusaError(
MedusaError.Types.NOT_ALLOWED,
"You are only allowed to update open draft orders"
)
}
if (value.variant_id) {
const line = await lineItemService.generate(
value.variant_id,
draftOrder.cart.region_id,
value.quantity,
{ metadata: value.metadata, unit_price: value.unit_price }
)
await cartService
.withTransaction(manager)
.retrieve(id, { select: defaultFields, relations: ["cart"] })
.addLineItem(draftOrder.cart_id, line)
} else {
// custom line items can be added to a draft order
await lineItemService.withTransaction(manager).create({
cart_id: draftOrder.cart_id,
has_shipping: true,
title: value.title || "Custom item",
allow_discounts: false,
unit_price: value.unit_price || 0,
quantity: value.quantity,
})
}
if (draftOrder.status === "completed") {
throw new MedusaError(
MedusaError.Types.NOT_ALLOWED,
"You are only allowed to update open draft orders"
)
}
draftOrder.cart = await cartService
.withTransaction(manager)
.retrieve(draftOrder.cart_id, {
relations: defaultCartRelations,
select: defaultCartFields,
})
if (value.variant_id) {
const line = await lineItemService.generate(
value.variant_id,
draftOrder.cart.region_id,
value.quantity,
{ metadata: value.metadata, unit_price: value.unit_price }
)
await cartService
.withTransaction(manager)
.addLineItem(draftOrder.cart_id, line)
} else {
// custom line items can be added to a draft order
await lineItemService.withTransaction(manager).create({
cart_id: draftOrder.cart_id,
has_shipping: true,
title: value.title || "Custom item",
allow_discounts: false,
unit_price: value.unit_price || 0,
quantity: value.quantity,
})
}
draftOrder.cart = await cartService
.withTransaction(manager)
.retrieve(draftOrder.cart_id, {
relations: defaultCartRelations,
select: defaultCartFields,
})
res.status(200).json({ draft_order: draftOrder })
})
} catch (err) {
throw err
}
res.status(200).json({ draft_order: draftOrder })
})
}

19
packages/medusa/src/api/routes/admin/draft-orders/delete-draft-order.js
View File

@@ -27,15 +27,12 @@
export default async (req, res) => {
const { id } = req.params
try {
const draftOrderService = req.scope.resolve("draftOrderService")
await draftOrderService.delete(id)
res.json({
id,
object: "draft-order",
deleted: true,
})
} catch (err) {
throw err
}
const draftOrderService = req.scope.resolve("draftOrderService")
await draftOrderService.delete(id)
res.json({
id,
object: "draft-order",
deleted: true,
})
}

54
packages/medusa/src/api/routes/admin/draft-orders/delete-line-item.js
View File

@@ -1,4 +1,4 @@
import { MedusaError, Validator } from "medusa-core-utils"
import { MedusaError } from "medusa-core-utils"
import { defaultCartFields, defaultCartRelations, defaultFields } from "."
/**
@@ -25,37 +25,33 @@ import { defaultCartFields, defaultCartRelations, defaultFields } from "."
export default async (req, res) => {
const { id, line_id } = req.params
try {
const draftOrderService = req.scope.resolve("draftOrderService")
const cartService = req.scope.resolve("cartService")
const entityManager = req.scope.resolve("manager")
const draftOrderService = req.scope.resolve("draftOrderService")
const cartService = req.scope.resolve("cartService")
const entityManager = req.scope.resolve("manager")
await entityManager.transaction(async manager => {
const draftOrder = await draftOrderService
.withTransaction(manager)
.retrieve(id, { select: defaultFields })
await entityManager.transaction(async (manager) => {
const draftOrder = await draftOrderService
.withTransaction(manager)
.retrieve(id, { select: defaultFields })
if (draftOrder.status === "completed") {
throw new MedusaError(
MedusaError.Types.NOT_ALLOWED,
"You are only allowed to update open draft orders"
)
}
if (draftOrder.status === "completed") {
throw new MedusaError(
MedusaError.Types.NOT_ALLOWED,
"You are only allowed to update open draft orders"
)
}
await cartService
.withTransaction(manager)
.removeLineItem(draftOrder.cart_id, line_id)
await cartService
.withTransaction(manager)
.removeLineItem(draftOrder.cart_id, line_id)
draftOrder.cart = await cartService
.withTransaction(manager)
.retrieve(draftOrder.cart_id, {
relations: defaultCartRelations,
select: defaultCartFields,
})
draftOrder.cart = await cartService
.withTransaction(manager)
.retrieve(draftOrder.cart_id, {
relations: defaultCartRelations,
select: defaultCartFields,
})
res.status(200).json({ draft_order: draftOrder })
})
} catch (err) {
throw err
}
res.status(200).json({ draft_order: draftOrder })
})
}

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

@@ -28,22 +28,18 @@ import {
export default async (req, res) => {
const { id } = req.params
try {
const draftOrderService = req.scope.resolve("draftOrderService")
const cartService = req.scope.resolve("cartService")
const draftOrderService = req.scope.resolve("draftOrderService")
const cartService = req.scope.resolve("cartService")
const draftOrder = await draftOrderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
const draftOrder = await draftOrderService.retrieve(id, {
select: defaultFields,
relations: defaultRelations,
})
draftOrder.cart = await cartService.retrieve(draftOrder.cart_id, {
relations: defaultCartRelations,
select: defaultCartFields,
})
draftOrder.cart = await cartService.retrieve(draftOrder.cart_id, {
relations: defaultCartRelations,
select: defaultCartFields,
})
res.json({ draft_order: draftOrder })
} catch (error) {
throw error
}
res.json({ draft_order: draftOrder })
}

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

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

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

@@ -1,4 +1,3 @@
import _ from "lodash"
import { defaultFields, defaultRelations } from "./"
/**
@@ -20,33 +19,29 @@ import { defaultFields, defaultRelations } from "./"
*/
export default async (req, res) => {
try {
const draftOrderService = req.scope.resolve("draftOrderService")
const draftOrderService = req.scope.resolve("draftOrderService")
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
}
const listConfig = {
select: defaultFields,
relations: defaultRelations,
skip: offset,
take: limit,
order: { created_at: "DESC" },
}
const [draftOrders, count] = await draftOrderService.listAndCount(
selector,
listConfig
)
res.json({ draft_orders: draftOrders, count, offset, limit })
} catch (error) {
throw error
if ("q" in req.query) {
selector.q = req.query.q
}
const listConfig = {
select: defaultFields,
relations: defaultRelations,
skip: offset,
take: limit,
order: { created_at: "DESC" },
}
const [draftOrders, count] = await draftOrderService.listAndCount(
selector,
listConfig
)
res.json({ draft_orders: draftOrders, count, offset, limit })
}

86
packages/medusa/src/api/routes/admin/draft-orders/register-payment.js
View File

@@ -26,59 +26,53 @@ import {
export default async (req, res) => {
const { id } = req.params
try {
const draftOrderService = req.scope.resolve("draftOrderService")
const paymentProviderService = req.scope.resolve("paymentProviderService")
const orderService = req.scope.resolve("orderService")
const cartService = req.scope.resolve("cartService")
const entityManager = req.scope.resolve("manager")
const draftOrderService = req.scope.resolve("draftOrderService")
const paymentProviderService = req.scope.resolve("paymentProviderService")
const orderService = req.scope.resolve("orderService")
const cartService = req.scope.resolve("cartService")
const entityManager = req.scope.resolve("manager")
let result
await entityManager.transaction(async manager => {
const draftOrder = await draftOrderService
.withTransaction(manager)
.retrieve(id)
let result
await entityManager.transaction(async (manager) => {
const draftOrder = await draftOrderService
.withTransaction(manager)
.retrieve(id)
const cart = await cartService
.withTransaction(manager)
.retrieve(draftOrder.cart_id, {
select: ["total"],
relations: [
"discounts",
"discounts.rule",
"discounts.rule.valid_for",
"shipping_methods",
"region",
"items",
],
})
const cart = await cartService
.withTransaction(manager)
.retrieve(draftOrder.cart_id, {
select: ["total"],
relations: [
"discounts",
"discounts.rule",
"discounts.rule.valid_for",
"shipping_methods",
"region",
"items",
],
})
await paymentProviderService
.withTransaction(manager)
.createSession("system", cart)
await paymentProviderService
.withTransaction(manager)
.createSession("system", cart)
await cartService
.withTransaction(manager)
.setPaymentSession(cart.id, "system")
await cartService
.withTransaction(manager)
.setPaymentSession(cart.id, "system")
await cartService.withTransaction(manager).authorizePayment(cart.id)
await cartService.withTransaction(manager).authorizePayment(cart.id)
result = await orderService
.withTransaction(manager)
.createFromCart(cart.id)
result = await orderService.withTransaction(manager).createFromCart(cart.id)
await draftOrderService
.withTransaction(manager)
.registerCartCompletion(draftOrder.id, result.id)
})
await draftOrderService
.withTransaction(manager)
.registerCartCompletion(draftOrder.id, result.id)
})
const order = await orderService.retrieve(result.id, {
relations: defaultOrderRelations,
select: defaultOrderFields,
})
const order = await orderService.retrieve(result.id, {
relations: defaultOrderRelations,
select: defaultOrderFields,
})
res.status(200).json({ order })
} catch (err) {
throw err
}
res.status(200).json({ order })
}

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

@@ -1,5 +1,5 @@
import { MedusaError, Validator } from "medusa-core-utils"
import { defaultCartFields, defaultCartRelations, defaultFields } from "."
import { defaultCartFields, defaultCartRelations } from "."
/**
* @oas [post] /admin/draft-orders/{id}
@@ -60,9 +60,7 @@ export default async (req, res) => {
const schema = Validator.object().keys({
region_id: Validator.string().optional(),
country_code: Validator.string().optional(),
email: Validator.string()
.email()
.optional(),
email: Validator.string().email().optional(),
billing_address: Validator.object().optional(),
shipping_address: Validator.object().optional(),
discounts: Validator.array()
@@ -79,35 +77,31 @@ export default async (req, res) => {
throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
}
try {
const draftOrderService = req.scope.resolve("draftOrderService")
const cartService = req.scope.resolve("cartService")
const draftOrderService = req.scope.resolve("draftOrderService")
const cartService = req.scope.resolve("cartService")
const draftOrder = await draftOrderService.retrieve(id)
const draftOrder = await draftOrderService.retrieve(id)
if (draftOrder.status === "completed") {
throw new MedusaError(
MedusaError.Types.NOT_ALLOWED,
"You are only allowed to update open draft orders"
)
}
if ("no_notification_order" in value) {
await draftOrderService.update(draftOrder.id, {
no_notification_order: value.no_notification_order,
})
delete value.no_notification_order
}
await cartService.update(draftOrder.cart_id, value)
draftOrder.cart = await cartService.retrieve(draftOrder.cart_id, {
relations: defaultCartRelations,
select: defaultCartFields,
})
res.status(200).json({ draft_order: draftOrder })
} catch (err) {
throw err
if (draftOrder.status === "completed") {
throw new MedusaError(
MedusaError.Types.NOT_ALLOWED,
"You are only allowed to update open draft orders"
)
}
if ("no_notification_order" in value) {
await draftOrderService.update(draftOrder.id, {
no_notification_order: value.no_notification_order,
})
delete value.no_notification_order
}
await cartService.update(draftOrder.cart_id, value)
draftOrder.cart = await cartService.retrieve(draftOrder.cart_id, {
relations: defaultCartRelations,
select: defaultCartFields,
})
res.status(200).json({ draft_order: draftOrder })
}

96
packages/medusa/src/api/routes/admin/draft-orders/update-line-item.js
View File

@@ -51,64 +51,60 @@ export default async (req, res) => {
throw new MedusaError(MedusaError.Types.INVALID_DATA, error.details)
}
try {
const draftOrderService = req.scope.resolve("draftOrderService")
const cartService = req.scope.resolve("cartService")
const entityManager = req.scope.resolve("manager")
const draftOrderService = req.scope.resolve("draftOrderService")
const cartService = req.scope.resolve("cartService")
const entityManager = req.scope.resolve("manager")
await entityManager.transaction(async manager => {
const draftOrder = await draftOrderService
await entityManager.transaction(async (manager) => {
const draftOrder = await draftOrderService
.withTransaction(manager)
.retrieve(id, {
select: defaultFields,
relations: ["cart", "cart.items"],
})
if (draftOrder.status === "completed") {
throw new MedusaError(
MedusaError.Types.NOT_ALLOWED,
"You are only allowed to update open draft orders"
)
}
if (value.quantity === 0) {
await cartService
.withTransaction(manager)
.retrieve(id, {
select: defaultFields,
relations: ["cart", "cart.items"],
})
.removeLineItem(draftOrder.cart.id, line_id)
} else {
const existing = draftOrder.cart.items.find((i) => i.id === line_id)
if (draftOrder.status === "completed") {
if (!existing) {
throw new MedusaError(
MedusaError.Types.NOT_ALLOWED,
"You are only allowed to update open draft orders"
MedusaError.Types.INVALID_DATA,
"Could not find the line item"
)
}
if (value.quantity === 0) {
await cartService
.withTransaction(manager)
.removeLineItem(draftOrder.cart.id, line_id)
} else {
const existing = draftOrder.cart.items.find(i => i.id === line_id)
if (!existing) {
throw new MedusaError(
MedusaError.Types.INVALID_DATA,
"Could not find the line item"
)
}
const lineItemUpdate = {
...value,
region_id: draftOrder.cart.region_id,
}
if (existing.variant_id) {
lineItemUpdate.variant_id = existing.variant_id
}
await cartService
.withTransaction(manager)
.updateLineItem(draftOrder.cart_id, line_id, lineItemUpdate)
const lineItemUpdate = {
...value,
region_id: draftOrder.cart.region_id,
}
draftOrder.cart = await cartService
.withTransaction(manager)
.retrieve(draftOrder.cart_id, {
relations: defaultCartRelations,
select: defaultCartFields,
})
if (existing.variant_id) {
lineItemUpdate.variant_id = existing.variant_id
}
res.status(200).json({ draft_order: draftOrder })
})
} catch (err) {
throw err
}
await cartService
.withTransaction(manager)
.updateLineItem(draftOrder.cart_id, line_id, lineItemUpdate)
}
draftOrder.cart = await cartService
.withTransaction(manager)
.retrieve(draftOrder.cart_id, {
relations: defaultCartRelations,
select: defaultCartFields,
})
res.status(200).json({ draft_order: draftOrder })
})
}