@things-factory/marketplace-base 8.0.0-beta.9 → 8.0.2

package/server/graphql/resolvers/marketplace-order/index.ts

@@ -0,0 +1,75 @@
+import { autoInitialiseLogisticsByBatch } from './auto-initialise-logistics-by-batch'
+import { autoUpdateOrderReadyToShip } from './auto-update-order-ready-to-ship'
+import { cancelMarketplaceOrderResolver } from './cancel-marketplace-order'
+import { dashboardMarketplaceOrdersResolver } from './dashboard-marketplace-orders'
+import { dashboardMarketplaceSalesResolver } from './dashboard-marketplace-sales'
+import { dashboardMarketplaceSalesAverageResolver } from './dashboard-marketplace-sales-average'
+import { deleteMarketplaceOrders } from './delete-marketplace-orders'
+import { generateMarketplaceOrderResolver } from './generate-marketplace-order'
+import { getAddressList } from './get-address-list'
+import { getBranchList } from './get-branch-list'
+import { getETraxOrderDocumentFunction, getETraxOrderDocumentResolver } from './get-etrax-order-document'
+import { getLogisticsParam } from './get-logistics-param'
+import { getOrderDocumentResolver } from './get-order-document'
+import { getStoreLogistics } from './get-store-logistics'
+import { getTimeSlot } from './get-time-slot'
+import { initialiseLazadaLogisticsByBatch } from './initialise-lazada-logistics-by-batch'
+import { initialiseLogistics } from './initialise-logistics'
+import { initialiseLogisticsByBatch } from './initialise-logistics-by-batch'
+import { initialiseShopeeLogisticsByBatch } from './initialise-shopee-logistics-by-batch'
+import { marketplaceOrderResolver } from './marketplace-order'
+import { marketplaceOrdersResolver } from './marketplace-orders'
+import { marketplaceOrdersForBatchInitResolver } from './marketplace-orders-for-batch-init'
+import { marketplaceOrdersForExport } from './marketplace-orders-for-export'
+import { setMarketplaceOrderDelivered } from './set-marketplace-order-delivered'
+import { setMarketplaceOrderFailedDelivery } from './set-marketplace-order-failed-delivery'
+import { setOwnShippingProviderByOrdersResolver } from './set-own-shipping-provider-by-orders'
+import { splitOrdersByBatch } from './split-orders-by-batch'
+import { syncAllMarketplaceOrder } from './sync-all-marketplace-order'
+import { syncMarketplaceOrder } from './sync-marketplace-order'
+import { updateMarketplaceOrder } from './update-marketplace-order'
+import { updateOrderReadyToShip } from './update-order-ready-to-ship'
+import { syncShopeeAwb } from './sync-shopee-awb'
+import { syncMarketplaceOrdersByPlatform } from './sync-marketplace-orders-by-platform'
+
+export const MarketplaceOrderResolver = {
+  Query: {
+    ...marketplaceOrdersResolver,
+    ...marketplaceOrderResolver,
+    ...getOrderDocumentResolver,
+    ...getETraxOrderDocumentResolver,
+    ...getStoreLogistics,
+    ...getLogisticsParam,
+    ...getBranchList,
+    ...getAddressList,
+    ...getTimeSlot,
+    ...marketplaceOrdersForExport,
+    ...marketplaceOrdersForBatchInitResolver,
+    ...dashboardMarketplaceOrdersResolver,
+    ...dashboardMarketplaceSalesResolver,
+    ...dashboardMarketplaceSalesAverageResolver
+  },
+  Mutation: {
+    ...generateMarketplaceOrderResolver,
+    ...initialiseLogistics,
+    ...initialiseLogisticsByBatch,
+    ...setMarketplaceOrderDelivered,
+    ...setMarketplaceOrderFailedDelivery,
+    ...syncMarketplaceOrder,
+    ...syncAllMarketplaceOrder,
+    ...updateOrderReadyToShip,
+    ...deleteMarketplaceOrders,
+    ...initialiseShopeeLogisticsByBatch,
+    ...initialiseLazadaLogisticsByBatch,
+    ...cancelMarketplaceOrderResolver,
+    ...splitOrdersByBatch,
+    ...updateMarketplaceOrder,
+    ...setOwnShippingProviderByOrdersResolver,
+    ...autoInitialiseLogisticsByBatch,
+    ...autoUpdateOrderReadyToShip,
+    ...syncShopeeAwb,
+    ...syncMarketplaceOrdersByPlatform
+  }
+}
+
+export { getETraxOrderDocumentFunction }

package/server/graphql/resolvers/marketplace-order/initialise-lazada-logistics-by-batch.ts

@@ -0,0 +1,165 @@
+import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
+
+import { MarketplaceOrder, MarketplaceOrderItem } from '../../../entities'
+
+export const initialiseLazadaLogisticsByBatch = {
+  async initialiseLazadaLogisticsByBatch(_: any, { patches }, context: ResolverContext) {
+    try {
+      const { domain, tx } = context.state
+      await Promise.all(
+        patches.map(async patch => {
+          const foundMarketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+            where: { id: patch.id },
+            relations: [
+              'marketplaceStore',
+              'marketplaceOrderItems',
+              'marketplaceOrderItems.marketplaceOrderShippingItems',
+              'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping',
+              'marketplaceOrderItems.marketplaceProductVariation'
+            ]
+          })
+          if (!foundMarketplaceOrder) throw new Error('No order is found')
+
+          const storeId = foundMarketplaceOrder.marketplaceStore.id
+          const marketplaceStore: MarketplaceStore = await StoreAPI.getMarketplaceStore(storeId)
+          const storeOrder = await StoreAPI.getStoreOrder(marketplaceStore, { orderId: patch.orderNo })
+
+          const arrItemIds = storeOrder.orderItems.reduce((newItemID, item) => {
+            return [...newItemID, ...item.name.split(',')]
+          }, [])
+
+          if (
+            storeOrder?.status == 'pending' &&
+            patch.deliveryType &&
+            arrItemIds.length > 0 &&
+            patch.shippingProvider
+          ) {
+            const storeOrderItemsPBM = await StoreAPI.setStoreOrderStatusPackedByMarketplace(marketplaceStore, {
+              deliveryType: patch.deliveryType,
+              orderItemId: arrItemIds,
+              shippingProvider: patch.shippingProvider
+            })
+
+            ////// mockup function to simulate pending order
+            // const storeOrderItemsPBM = await mock_setStoreOrderStatusPackedByMarketplace(marketplaceStore, {
+            //     deliveryType: patch.deliveryType,
+            //     orderItemId: arrItemIds,
+            //     shippingProvider: patch.shippingProvider
+            //   }, patch.orderNo)
+
+            foundMarketplaceOrder.trackingNo = storeOrderItemsPBM.trackingNumber[0] || '[]'
+            foundMarketplaceOrder.otherInfoJSON = JSON.stringify({
+              deliveryType: patch.deliveryType,
+              shippingProvider: patch.shippingProvider
+            })
+          }
+
+          let updatedOrder = await StoreAPI.getStoreOrder(marketplaceStore, { orderId: patch.orderNo })
+
+          await tx.getRepository(MarketplaceOrder).save({
+            ...foundMarketplaceOrder,
+            status: updatedOrder.status,
+            orderUpdatedAt: storeOrder.orderUpdatedAt
+          })
+
+          for (let idx = 0; idx < foundMarketplaceOrder.marketplaceOrderItems.length; idx++) {
+            let matchItem = updatedOrder.orderItems.find(
+              i =>
+                i.variationId ==
+                foundMarketplaceOrder.marketplaceOrderItems[idx].marketplaceProductVariation.variationId
+            )
+
+            if (matchItem) {
+              let targetMarketplaceOrderItem = {
+                ...foundMarketplaceOrder.marketplaceOrderItems[idx],
+                shippingProvider: matchItem.shippingProvider,
+                trackingCode: matchItem.trackingNo,
+                status: matchItem.status
+              }
+
+              await tx.getRepository(MarketplaceOrderItem).save(targetMarketplaceOrderItem)
+            }
+          }
+        })
+      )
+      return true
+    } catch (error) {
+      return false
+    }
+  }
+}
+
+async function mock_setStoreOrderStatusPackedByMarketplace(marketplaceStore, req, orderNo) {
+  let order = await StoreAPI.getStoreOrder(marketplaceStore, { orderId: orderNo })
+
+  // Sample Data from response
+  // order_item_id:284297913341490
+  // package_id:'FP053011087573484'
+  // shipment_provider:'LEX MY'
+  // tracking_number:'MYMPA024700347'
+  let data = {
+    order_items: order.orderItems.reduce((acc, itm) => {
+      return [
+        ...acc,
+        ...JSON.parse(itm.trackingNo).map(t => {
+          return {
+            order_item_id: t.order_item_id,
+            tracking_number: t.tracking_code,
+            package_id: 'RANDOMSTRING',
+            shipment_provider: req.shippingProvider
+          }
+        })
+      ]
+    }, [])
+  }
+
+  var internal = {
+    denormalize: req => {
+      var { deliveryType: delivery_type, orderItemId: order_item_ids, shippingProvider: shipment_provider } = req
+      var output = '[' + order_item_ids.join(',') + ']'
+
+      return {
+        delivery_type,
+        order_item_ids: output,
+        shipment_provider
+      }
+    },
+    normalize: res => {
+      let results = res.order_items
+      results = results.reduce(
+        (orderItem, item) => {
+          orderItem = {
+            ...orderItem,
+            items: [
+              ...orderItem.items,
+              {
+                order_item_id: item.order_item_id,
+                tracking_code: item.tracking_number
+              }
+            ]
+          }
+
+          const foundtrackingNumber = orderItem.trackingNumber.find(f => f == item.tracking_number)
+
+          if (!foundtrackingNumber) {
+            orderItem = {
+              ...orderItem,
+              trackingNumber: [...orderItem.trackingNumber, item.tracking_number]
+            }
+          }
+
+          return orderItem
+        },
+        { items: [], trackingNumber: [] }
+      )
+
+      return results
+    }
+  }
+
+  const request = internal.denormalize(req)
+
+  const respond = internal.normalize(data)
+
+  return respond
+}

package/server/graphql/resolvers/marketplace-order/initialise-logistics-by-batch.ts

@@ -0,0 +1,41 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+
+import { MarketplaceOrder, MarketplaceOrderShipping } from '../../../entities'
+
+export const initialiseLogisticsByBatch = {
+  async initialiseLogisticsByBatch(_: any, { patches }, context: ResolverContext) {
+    const { user, tx } = context.state
+
+    await Promise.all(
+      patches.map(async patch => {
+        let marketplaceOrderShipping: MarketplaceOrderShipping = await tx.getRepository(MarketplaceOrderShipping).findOne({
+          where: { id: patch.id },
+          relations: ['marketplaceStore']
+        })
+
+        let marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+          where: { orderNo: marketplaceOrderShipping.orderNoRef },
+          relations: ['marketplaceStore']
+        })
+
+        if (!marketplaceOrder) throw new Error('No order is found')
+
+        marketplaceOrderShipping.trackingNo = patch?.trackingNo
+        marketplaceOrderShipping.transporter = patch?.shippingProvider
+        marketplaceOrderShipping.ownTransporter = patch?.shippingProvider
+        marketplaceOrderShipping.ownTrackingNo = patch.ownTrackingNo || patch?.trackingNo
+        marketplaceOrderShipping.trackingUrl = patch?.trackingUrl
+        await tx.getRepository(MarketplaceOrderShipping).save(marketplaceOrderShipping)
+
+        marketplaceOrder.shippingProvider = patch?.shippingProvider
+        marketplaceOrder.ownShippingProvider = patch?.shippingProvider
+        marketplaceOrder.trackingNo = patch?.trackingNo
+
+        await tx.getRepository(MarketplaceOrder).save(marketplaceOrder)
+      })
+    )
+    return true
+  }
+}

package/server/graphql/resolvers/marketplace-order/initialise-logistics.ts

@@ -0,0 +1,29 @@
+import { EntityManager } from 'typeorm'
+
+import { config } from '@things-factory/env'
+import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
+
+import { MarketplaceOrder } from '../../../entities'
+
+const shopeeConfig = config.get('marketplaceIntegrationShopee', {})
+const { v2 } = shopeeConfig
+
+export const initialiseLogistics = {
+  async initialiseLogistics(_: any, { deliveryType, orderNo }, context: ResolverContext) {
+    const { tx } = context.state
+    const foundMarketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+      where: { name: orderNo },
+      relations: ['marketplaceStore', 'marketplaceOrderItems']
+    })
+    if (!foundMarketplaceOrder) throw new Error('No order is found')
+
+    const storeId = foundMarketplaceOrder.marketplaceStore.id
+    const marketplaceStore: MarketplaceStore = await StoreAPI.getMarketplaceStore(storeId)
+
+    await StoreAPI.initLogistics(marketplaceStore, { deliveryType, orderNo })
+    if (marketplaceStore.platform == 'shopee' && v2) {
+      await StoreAPI.createShippingDocument(marketplaceStore, { orderNo })
+    }
+    return true
+  }
+}

package/server/graphql/resolvers/marketplace-order/initialise-shopee-logistics-by-batch.ts

@@ -0,0 +1,97 @@
+import { config } from '@things-factory/env'
+import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceOrder, MarketplaceOrderShipping } from '../../../entities'
+
+const shopeeConfig = config.get('marketplaceIntegrationShopee', {})
+const { v2 } = shopeeConfig
+
+export const initialiseShopeeLogisticsByBatch = {
+  async initialiseShopeeLogisticsByBatch(_: any, { patches }, context: ResolverContext) {
+    await Promise.all(
+      patches.map(async patch => {
+        if (patch?.ownTrackingNo) {
+          patch.trackingNo = patch.ownTrackingNo
+        }
+        let foundMarketplaceOrder: MarketplaceOrder = await getRepository(MarketplaceOrder).findOne({
+          where: { id: patch.id },
+          relations: ['marketplaceStore', 'marketplaceOrderItems']
+        })
+        if (!foundMarketplaceOrder) throw new Error('No order is found')
+
+        const storeId = foundMarketplaceOrder.marketplaceStore.id
+        const marketplaceStore: MarketplaceStore = await StoreAPI.getMarketplaceStore(storeId)
+        let storeOrder = await StoreAPI.getStoreOrder(marketplaceStore, { orderNo: patch.orderNo })
+
+        if (storeOrder?.status == 'ready_to_ship' && patch.deliveryType) {
+          let deliveryType = {}
+          if (patch.deliveryType == 'pickup' && patch?.addressId && patch?.pickupTimeId) {
+            deliveryType = {
+              [patch.deliveryType]: {
+                addressId: patch.addressId,
+                pickupTimeId: patch.pickupTimeId
+              }
+            }
+          } else if (patch.deliveryType == 'dropoff') {
+            deliveryType = {
+              [patch.deliveryType]: {}
+            }
+
+            if (patch.branchId)
+              deliveryType[patch.deliveryType] = { ...deliveryType[patch.deliveryType], branchId: patch.branchId }
+            if (patch.senderRealName)
+              deliveryType[patch.deliveryType] = {
+                ...deliveryType[patch.deliveryType],
+                senderRealName: patch.senderRealName
+              }
+            if (patch.trackingNo)
+              deliveryType[patch.deliveryType] = { ...deliveryType[patch.deliveryType], trackingNo: patch.trackingNo }
+          } else if (patch.deliveryType == 'non_integrated') {
+            deliveryType = {
+              [patch.deliveryType]: {}
+            }
+
+            if (patch.trackingNo)
+              deliveryType[patch.deliveryType] = {
+                ...deliveryType[patch.deliveryType],
+                trackingNo: patch.trackingNo ? patch.trackingNo : patch.ownTrackingNo
+              }
+          } else {
+            return false
+          }
+
+          await StoreAPI.initLogistics(marketplaceStore, { deliveryType, orderNo: patch.orderNo })
+        }
+
+        storeOrder = await StoreAPI.getStoreOrder(marketplaceStore, { orderNo: patch.orderNo })
+
+        let marketplaceOrderShippings: MarketplaceOrderShipping[] = await getRepository(MarketplaceOrderShipping).find({
+          where: { orderNoRef: foundMarketplaceOrder.name }
+        })
+        for (let i = 0; i < marketplaceOrderShippings.length; i++) {
+          let marketplaceOrderShipping = marketplaceOrderShippings[i]
+
+          marketplaceOrderShipping.trackingNo = storeOrder?.trackingNo
+          marketplaceOrderShipping.transporter = patch?.shippingProvider || storeOrder?.orderShipping?.transporter
+          marketplaceOrderShipping.ownTransporter = patch?.shippingProvider || null
+          marketplaceOrderShipping.ownTrackingNo = patch.ownTrackingNo || null
+
+          await getRepository(MarketplaceOrderShipping).save(marketplaceOrderShipping)
+        }
+
+        foundMarketplaceOrder.shippingProvider = patch?.shippingProvider || storeOrder?.orderShipping?.transporter
+        foundMarketplaceOrder.ownShippingProvider = patch?.shippingProvider || null
+        foundMarketplaceOrder.trackingNo = storeOrder?.trackingNo
+        foundMarketplaceOrder.status = storeOrder.status
+
+        await getRepository(MarketplaceOrder).save(foundMarketplaceOrder)
+
+        // if (v2) {
+        //   await StoreAPI.createShippingDocument(marketplaceStore, { orderNo: patch.orderNo })
+        // }
+      })
+    )
+    return true
+  }
+}

package/server/graphql/resolvers/marketplace-order/marketplace-order.ts

@@ -0,0 +1,12 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceOrder } from '../../../entities'
+
+export const marketplaceOrderResolver = {
+  async marketplaceOrder(_: any, { name }, context: ResolverContext) {
+    return await getRepository(MarketplaceOrder).findOne({
+      where: { name },
+      relations: ['domain', 'marketplaceStore', 'marketplaceOrderItems', 'creator', 'updater']
+    })
+  }
+}

package/server/graphql/resolvers/marketplace-order/marketplace-orders-for-batch-init.ts

@@ -0,0 +1,52 @@
+import { convertListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { MarketplaceOrder } from '../../../entities'
+import { getLogisticsParam } from '../marketplace-order/get-logistics-param'
+
+export const marketplaceOrdersForBatchInitResolver = {
+  async marketplaceOrdersForBatchInit(_: any, params: ListParam, context: ResolverContext) {
+    const convertedParams = convertListParams({
+      ...params,
+      filters: params.filters.filter(param => param.name != 'logisticsType')
+    })
+    let [items, total] = await getRepository(MarketplaceOrder).findAndCount({
+      ...convertedParams,
+      relations: [
+        'domain',
+        'marketplaceStore',
+        'marketplaceOrderItems',
+        'marketplaceOrderItems.marketplaceOrderShippingItems',
+        'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping',
+        'marketplaceOrderItems.marketplaceProductVariation',
+        'creator',
+        'updater'
+      ]
+    })
+
+    items = await Promise.all(
+      items.map(async (itm: any) => {
+        try {
+          if (itm.marketplaceStore.platform == 'shopee' && itm.status === 'ready_to_ship') {
+            let fullLogisticsDetail = await getLogisticsParam.getLogisticsParam(
+              _,
+              { storeId: itm.marketplaceStore.id, orderNo: itm.orderNo },
+              context
+            )
+
+            return { ...itm, fullLogisticsDetail }
+          } else {
+            return itm
+          }
+        } catch (e) {
+          /**
+           * To handle the case when any order was cancelled in marketplace
+           * but not synced, it will cause an error which blocks process
+           */
+          return null
+        }
+      })
+    )
+
+    return { items: items.filter(itm => itm && itm != null), total }
+  }
+}

package/server/graphql/resolvers/marketplace-order/marketplace-orders-for-export.ts

@@ -0,0 +1,63 @@
+import { In } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceOrder, MarketplaceOrderItem, MarketplaceOrderShippingItem } from '../../../entities'
+
+export const marketplaceOrdersForExport = {
+  async marketplaceOrdersForExport(_: any, { orderNos }, context: ResolverContext) {
+    const { domain } = context.state
+    const foundMarketplaceOrders: MarketplaceOrder[] = await getRepository(MarketplaceOrder).find({
+      where: { name: In(orderNos), domain: { id: domain.id } },
+      relations: [
+        'marketplaceStore',
+        'marketplaceOrderItems',
+        'marketplaceOrderItems.marketplaceOrderShippingItems',
+        'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping',
+        'marketplaceOrderItems.marketplaceProductVariation'
+      ]
+    })
+
+    let mergedOrder = []
+    let exportOrder = []
+    await Promise.all(
+      foundMarketplaceOrders.map((order: MarketplaceOrder) => {
+        const marketplaceOrderItems: MarketplaceOrderItem[] = order.marketplaceOrderItems
+        const orderNo = order.name
+        const shippingProvider: string = order.shippingProvider
+        const marketplaceStoreName = order.marketplaceStore.storeName
+        const marketplaceStorePlatform = order.marketplaceStore.platform
+        const status = order.status
+        const createdAt = order.orderCreatedAt
+        const updatedAt = order.orderUpdatedAt
+
+        mergedOrder = marketplaceOrderItems.map(orderItem => {
+          const marketplaceOrderShippingItems: MarketplaceOrderShippingItem[] = orderItem.marketplaceOrderShippingItems
+
+          const variationName: string = orderItem.marketplaceProductVariation.name
+          const marketplaceOrderShipping = marketplaceOrderShippingItems[0].marketplaceOrderShipping
+          const sku: string = orderItem.marketplaceProductVariation.sku
+          const itemQty: number = orderItem.qty
+          const trackingNo: string = marketplaceOrderShipping?.trackingNo
+
+          const mergedOrder: any = {
+            orderNo,
+            marketplaceStoreName,
+            marketplaceStorePlatform,
+            sku,
+            variationName,
+            trackingNo,
+            shippingProvider,
+            itemQty,
+            status,
+            createdAt,
+            updatedAt
+          }
+          exportOrder.push(mergedOrder)
+        })
+      })
+    )
+
+    return exportOrder
+  }
+}

package/server/graphql/resolvers/marketplace-order/marketplace-orders.ts

@@ -0,0 +1,56 @@
+import { SelectQueryBuilder } from 'typeorm'
+
+import { buildQuery, getRepository, ListParam } from '@things-factory/shell'
+
+import { MarketplaceOrder } from '../../../entities'
+
+export const marketplaceOrdersResolver = {
+  async marketplaceOrders(_: any, params: ListParam, context: ResolverContext) {
+    let postCodeSorter = params.sortings.find(sort => sort.name === 'postCode')
+    const noOfItemsFilter = params.filters.find(param => param.name === 'itemCount')
+    const skuFilter = params.filters.find(param => param.name === 'sku')
+
+    params.sortings = params.sortings.filter(sort => sort.name !== 'postCode')
+
+    if (noOfItemsFilter && noOfItemsFilter.value == 1) {
+      params.filters.find(param => param.name === 'itemCount').operator = 'eq'
+    }
+
+    if (skuFilter) {
+      params.filters = params.filters.filter(param => param.name !== 'sku')
+    }
+
+    let qb: SelectQueryBuilder<MarketplaceOrder> = getRepository(MarketplaceOrder).createQueryBuilder('mo')
+    buildQuery(qb, params, context)
+    qb.leftJoinAndSelect('mo.domain', 'domain')
+      .leftJoinAndSelect('mo.marketplaceStore', 'ms')
+      .leftJoinAndSelect('mo.marketplaceOrderItems', 'mi')
+      .leftJoinAndSelect('mi.marketplaceOrderShippingItems', 'mosi')
+      .leftJoinAndSelect('mi.marketplaceProductVariation', 'mpv')
+      .leftJoinAndSelect('mpv.marketplaceProduct', 'mp')
+      .leftJoinAndSelect('mosi.marketplaceOrderShipping', 'mos')
+      .leftJoinAndSelect('mo.creator', 'creator')
+      .leftJoinAndSelect('mo.updater', 'updater')
+
+    if (postCodeSorter) {
+      qb.addOrderBy('mos.postCode', postCodeSorter?.desc ? 'DESC' : 'ASC')
+    }
+
+    if (skuFilter) {
+      qb.andWhere(
+        `
+        exists (select * from marketplace_order_items moi
+        inner join marketplace_product_variations mpv
+        on moi.marketplace_product_variation_id = mpv.id
+        where moi.marketplace_order_id = mo.id
+        and lower(mpv.sku) like :sku)
+      `,
+        { sku: skuFilter.value.toLowerCase() }
+      )
+    }
+
+    let [items, total] = await qb.getManyAndCount()
+
+    return { items, total }
+  }
+}

package/server/graphql/resolvers/marketplace-order/set-marketplace-order-delivered.ts

@@ -0,0 +1,25 @@
+import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
+
+import { MarketplaceOrder } from '../../../entities'
+
+export const setMarketplaceOrderDelivered = {
+  async setMarketplaceOrderDelivered(_: any, { orderNo }, context: ResolverContext) {
+    const { tx } = context.state
+    const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+      where: { name: orderNo },
+      relations: ['marketplaceStore', 'marketplaceOrderItems']
+    })
+    if (!marketplaceOrder) throw new Error('No order is found')
+
+    const storeId = marketplaceOrder.marketplaceStore.id
+    const marketplaceStore: MarketplaceStore = await StoreAPI.getMarketplaceStore(storeId)
+
+    const storeOrder = await StoreAPI.getStoreOrder(marketplaceStore, { orderId: marketplaceOrder.orderNo })
+    const arrItemIds: string[] = storeOrder.orderItems.reduce((newItemID, item) => {
+      return [...newItemID, ...item.name.split(',')]
+    }, [])
+
+    await StoreAPI.setStoreOrderStatusDelivered(marketplaceStore, { orderItemId: arrItemIds })
+    return true
+  }
+}

package/server/graphql/resolvers/marketplace-order/set-marketplace-order-failed-delivery.ts

@@ -0,0 +1,25 @@
+import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
+
+import { MarketplaceOrder } from '../../../entities'
+
+export const setMarketplaceOrderFailedDelivery = {
+  async setMarketplaceOrderFailedDelivery(_: any, { orderNo }, context: ResolverContext) {
+    const { tx } = context.state
+    const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+      where: { name: orderNo },
+      relations: ['marketplaceStore', 'marketplaceOrderItems']
+    })
+    if (!marketplaceOrder) throw new Error('No order is found')
+
+    const storeId = marketplaceOrder.marketplaceStore.id
+    const marketplaceStore: MarketplaceStore = await StoreAPI.getMarketplaceStore(storeId)
+
+    const storeOrder = await StoreAPI.getStoreOrder(marketplaceStore, { orderId: marketplaceOrder.orderNo })
+    const arrItemIds: string[] = storeOrder.orderItems.reduce((newItemID, item) => {
+      return [...newItemID, ...item.name.split(',')]
+    }, [])
+
+    await StoreAPI.setStoreOrderStatusFailedDelivery(marketplaceStore, { orderItemId: arrItemIds })
+    return true
+  }
+}