@things-factory/marketplace-base 4.1.2 → 4.1.8

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

@@ -1,4 +1,5 @@
-import { EntityManager } from 'typeorm'
+import { EntityManager, IsNull } from 'typeorm'
+import uuid from 'uuid/v4'
 
 import { User } from '@things-factory/auth-base'
 import { Bizplace, getCustomerBizplaces } from '@things-factory/biz-base'
@@ -11,6 +12,7 @@ import {
   MarketplaceOrder,
   MarketplaceOrderItem,
   MarketplaceOrderShipping,
+  MarketplaceOrderShippingItem,
   MarketplaceProductVariation
 } from '../../../entities'
 import { NoGenerator } from '../../../utils'
@@ -100,8 +102,9 @@ export const syncMarketplaceOrder = {
             'domain',
             'fulfillmentCenter',
             'marketplaceOrderItems',
-            'marketplaceOrderItems.marketplaceProductVariation',
-            'marketplaceOrderItems.marketplaceOrderShipping'
+            'marketplaceOrderItems.marketplaceOrderShippingItems',
+            'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping',
+            'marketplaceOrderItems.marketplaceProductVariation'
           ]
         })
 
@@ -317,7 +320,9 @@ export const syncMarketplaceOrder = {
             } else {
               if (existingMarketplaceOrder?.marketplaceOrderItems) {
                 let existingOrderShipping: MarketplaceOrderShipping
-                existingOrderShipping = existingMarketplaceOrder.marketplaceOrderItems[0].marketplaceOrderShipping
+                existingOrderShipping =
+                  existingMarketplaceOrder.marketplaceOrderItems[0].marketplaceOrderShippingItems[0]
+                    .marketplaceOrderShipping
 
                 marketplaceOrderShipping = {
                   ...existingOrderShipping,
@@ -346,11 +351,13 @@ export const syncMarketplaceOrder = {
         let foundVariations = []
         for (var j = 0; j < order.orderItems.length; j++) {
           var item = order.orderItems[j]
-          let foundVariation = await tx.getRepository(MarketplaceProductVariation).findOne({
+          let foundVariationsQuery = await tx.getRepository(MarketplaceProductVariation).find({
             where: { domain: marketplaceStore.domain, variationId: item.variationId },
             relations: ['domain', 'marketplaceProduct', 'marketplaceProduct.marketplaceStore']
           })
 
+          let foundVariation = foundVariationsQuery.filter(fv => fv.marketplaceProduct.marketplaceStore.id == marketplaceStore.id)[0]
+
           if (foundVariation) {
             foundVariations.push(foundVariation)
           }
@@ -378,7 +385,6 @@ export const syncMarketplaceOrder = {
           marketplaceOrderItem.marketplaceProductVariation = foundVariation
           marketplaceOrderItem.trackingCode = order.trackingNo
           marketplaceOrderItem.marketplaceOrder = marketplaceOrder
-          marketplaceOrderItem.marketplaceOrderShipping = savedMarketplaceOrderShipping
           marketplaceOrderItem.originalPrice = item.originalPrice
           marketplaceOrderItem.discount = item.discount
           marketplaceOrderItem.promotionId = item.promotionId
@@ -676,6 +682,61 @@ export const syncMarketplaceOrder = {
         await tx.getRepository(MarketplaceOrder).save(marketplaceOrder)
         await tx.getRepository(MarketplaceOrderItem).save(marketplaceOrderItems)
 
+        for (let i = 0; i < marketplaceOrderItems.length; i++) {
+          const marketplaceOrderItem: MarketplaceOrderItem = marketplaceOrderItems[i]
+          const marketplaceProductVariation: MarketplaceProductVariation =
+            marketplaceOrderItem.marketplaceProductVariation
+          let existingMarketplaceOrderShippingItems: MarketplaceOrderShippingItem[] = await tx
+            .getRepository(MarketplaceOrderShippingItem)
+            .find({
+              where: { domain: marketplaceStore.domain, marketplaceOrderItem }
+            })
+
+          let product: Product = await tx.getRepository(Product).findOne({
+            where: { domain: marketplaceStore.domain, sku: marketplaceProductVariation.sku, deletedAt: IsNull() },
+            relations: ['productDetails']
+          })
+
+          let productBundle: ProductBundle
+          if (!product) {
+            productBundle = await tx.getRepository(ProductBundle).findOne({
+              where: { domain: marketplaceStore.domain, sku: marketplaceProductVariation.sku },
+              relations: ['productBundleSettings', 'productBundleSettings.product']
+            })
+          }
+
+          if (existingMarketplaceOrderShippingItems && existingMarketplaceOrderShippingItems?.length) {
+          } else {
+            if (productBundle) {
+              const productBundleSettings: ProductBundleSetting[] = productBundle.productBundleSettings
+              let marketplaceOrderShippingItems: MarketplaceOrderShippingItem[] = []
+              productBundleSettings.map(productBundleSetting => {
+                let marketplaceOrderShippingItem: MarketplaceOrderShippingItem = new MarketplaceOrderShippingItem()
+                marketplaceOrderShippingItem.name = uuid()
+                marketplaceOrderShippingItem.qty = marketplaceOrderItem.qty * productBundleSetting.bundleQty
+                marketplaceOrderShippingItem.domain = marketplaceStore.domain
+                marketplaceOrderShippingItem.marketplaceOrderItem = marketplaceOrderItem
+                marketplaceOrderShippingItem.marketplaceOrderShipping = savedMarketplaceOrderShipping
+                marketplaceOrderShippingItem.product = productBundleSetting.product
+
+                marketplaceOrderShippingItems.push(marketplaceOrderShippingItem)
+              })
+
+              await tx.getRepository(MarketplaceOrderShippingItem).save(marketplaceOrderShippingItems)
+            } else {
+              let marketplaceOrderShippingItem: MarketplaceOrderShippingItem = new MarketplaceOrderShippingItem()
+              marketplaceOrderShippingItem.name = uuid()
+              marketplaceOrderShippingItem.qty = marketplaceOrderItem.qty
+              marketplaceOrderShippingItem.domain = marketplaceStore.domain
+              marketplaceOrderShippingItem.marketplaceOrderItem = marketplaceOrderItem
+              marketplaceOrderShippingItem.marketplaceOrderShipping = savedMarketplaceOrderShipping
+              marketplaceOrderShippingItem.product = product ? product : null
+
+              await tx.getRepository(MarketplaceOrderShippingItem).save(marketplaceOrderShippingItem)
+            }
+          }
+        }
+
         if (i == marketplaceOrders.length - 1) {
           lastOrderId = order.name
         }

package/server/graphql/resolvers/marketplace-order/update-order-ready-to-ship.ts

@@ -1,18 +1,28 @@
 import { EntityManager } from 'typeorm'
 
 import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
+import { Domain } from '@things-factory/shell'
 
-import { MarketplaceOrder, MarketplaceOrderItem, MarketplaceOrderShipping } from '../../../entities'
+import {
+  MarketplaceOrder,
+  MarketplaceOrderItem,
+  MarketplaceOrderShipping,
+  MarketplaceOrderShippingItem
+} from '../../../entities'
 
 export const updateOrderReadyToShip = {
-  async updateOrderReadyToShip(_: any, { shippingProvider, deliveryType, orderNo }, context: any) {
+  async updateOrderReadyToShip(_: any, { shippingProvider, deliveryType, orderNo, orderId, domainId }, context: any) {
     const { tx }: { tx: EntityManager } = context.state
+
+    const domain: Domain = await tx.getRepository(Domain).findOne(domainId)
+
     let foundMarketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-      where: { name: orderNo },
+      where: { name: orderId, orderNo, domain },
       relations: [
         'marketplaceStore',
         'marketplaceOrderItems',
-        'marketplaceOrderItems.marketplaceOrderShipping',
+        'marketplaceOrderItems.marketplaceOrderShippingItems',
+        'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping',
         'marketplaceOrderItems.marketplaceProductVariation'
       ]
     })
@@ -25,54 +35,82 @@ export const updateOrderReadyToShip = {
     let marketplaceOrderShippings: MarketplaceOrderShipping[] = []
 
     foundMarketplaceOrder.marketplaceOrderItems.map(item => {
-      if (item?.marketplaceOrderShipping) {
-        marketplaceOrderShippings.push(item.marketplaceOrderShipping)
-      }
+      const marketplaceOrderShippingItems: MarketplaceOrderShippingItem[] = item.marketplaceOrderShippingItems
+      marketplaceOrderShippingItems.map(itm => {
+        if (itm?.marketplaceOrderShipping) {
+          marketplaceOrderShippings.push(itm.marketplaceOrderShipping)
+        }
+      })
     })
 
     const uniqueMarketplaceOrderShippings = Array.from(new Set(marketplaceOrderShippings.map(a => a.id))).map(id => {
       return marketplaceOrderShippings.find(a => a.id === id)
     })
 
-    if (uniqueMarketplaceOrderShippings.some(marketplaceOrderShipping => marketplaceOrderShipping.trackingNo != null)) {
-      uniqueMarketplaceOrderShippings.map((orderShipping: MarketplaceOrderShipping) => {
-        if (orderShipping?.trackingNo) {
-          const trackingNoInfo: any[] = JSON.parse(orderShipping.trackingNo)
-          const orderTrackingNos: string[] = trackingNoInfo.map(item => item.tracking_code)
-          const uniqueTrackingNos = [...new Set(orderTrackingNos)]
-
-          let orderItemIds: string[] = []
-
-          if (uniqueTrackingNos?.length == 1) {
-            orderItemIds = trackingNoInfo.map(item => item.order_item_id)
-            trackingInfoArr.push({ orderItemIds, trackingNo: uniqueTrackingNos[0] })
-          } else {
-            uniqueTrackingNos.map(trackingNo => {
-              orderItemIds = trackingNoInfo
-                .filter(info => info.tracking_code === trackingNo)
-                .map(filteredInfo => filteredInfo.order_item_id)
-
-              trackingInfoArr.push({ orderItemIds, trackingNo })
-            })
+    if (marketplaceStore.platform === 'lazada') {
+      if (
+        uniqueMarketplaceOrderShippings.some(marketplaceOrderShipping => marketplaceOrderShipping.trackingNo != null)
+      ) {
+        uniqueMarketplaceOrderShippings.map((orderShipping: MarketplaceOrderShipping) => {
+          if (orderShipping?.trackingNo) {
+            const trackingNoInfo: any[] = JSON.parse(orderShipping.trackingNo)
+            const orderTrackingNos: string[] = trackingNoInfo.map(item => item.tracking_code)
+            const uniqueTrackingNos = [...new Set(orderTrackingNos)]
+
+            let orderItemIds: string[] = []
+
+            if (uniqueTrackingNos?.length == 1) {
+              orderItemIds = trackingNoInfo.map(item => item.order_item_id)
+              trackingInfoArr.push({ orderItemIds, trackingNo: uniqueTrackingNos[0] })
+            } else {
+              uniqueTrackingNos.map(trackingNo => {
+                orderItemIds = trackingNoInfo
+                  .filter(info => info.tracking_code === trackingNo)
+                  .map(filteredInfo => filteredInfo.order_item_id)
+
+                trackingInfoArr.push({ orderItemIds, trackingNo })
+              })
+            }
           }
-        }
-      })
-    }
-
-    for (var i = 0; i < trackingInfoArr?.length; i++) {
-      const trackingInfo = trackingInfoArr[i]
-      const trackingNo = trackingInfo.trackingNo
-      const orderItemId = trackingInfo.orderItemIds
+        })
+      }
 
-      await StoreAPI.setStoreOrderStatusReadyToShip(marketplaceStore, {
-        shipmentProvider: shippingProvider,
-        deliveryType,
-        orderItemId,
-        trackingNo
-      })
+      for (var i = 0; i < trackingInfoArr?.length; i++) {
+        const trackingInfo = trackingInfoArr[i]
+        const trackingNo = trackingInfo.trackingNo
+        const orderItemId = trackingInfo.orderItemIds
+
+        const res = await StoreAPI.setStoreOrderStatusReadyToShip(marketplaceStore, {
+          shipmentProvider: shippingProvider,
+          deliveryType,
+          orderItemId,
+          trackingNo
+        })
+      }
+    } else {
+      let mos = uniqueMarketplaceOrderShippings.filter(mos => mos.trackingNo != null || mos.ownTrackingNo != null)
+      if (mos.length > 0) {
+        let trackingNo = mos[0].ownTrackingNo
+        const note = mos[0].trackingUrl || trackingNo
+
+        const res = await StoreAPI.setStoreOrderStatusReadyToShip(marketplaceStore, {
+          orderId,
+          trackingUrl: mos[0].trackingUrl || '',
+          trackingNo,
+          order: foundMarketplaceOrder,
+          note
+        })
+
+        if (marketplaceStore.platform === 'woocommerce') {
+          await StoreAPI.updateOrderStatus(marketplaceStore, {
+            orderId,
+            status: 'READY_TO_SHIP'
+          })
+        }
+      }
     }
 
-    const updatedOrder = await StoreAPI.getStoreOrder(marketplaceStore, { orderId: orderNo })
+    const updatedOrder = await StoreAPI.getStoreOrder(marketplaceStore, { orderId })
 
     foundMarketplaceOrder.status = updatedOrder.status
     foundMarketplaceOrder.orderUpdatedAt = updatedOrder.orderUpdatedAt

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

@@ -1,20 +1,25 @@
 import { getRepository } from 'typeorm'
+
 import { MarketplaceOrderShipping } from '../../../entities'
 
 export const marketplaceOrderShippingResolver = {
   async marketplaceOrderShipping(_: any, { name }, context: any) {
     const repository = getRepository(MarketplaceOrderShipping)
 
-    return await getRepository(MarketplaceOrderShipping).findOne({
+    const items: MarketplaceOrderShipping = await repository.findOne({
       where: { domain: context.state.domain, name },
       relations: [
         'domain',
         'creator',
         'updater',
-        'marketplaceOrderItems',
-        'marketplaceOrderItems.marketplaceProductVariation',
-        'marketplaceOrderItems.marketplaceProductVariation.marketplaceProduct'
+        'marketplaceOrderShippingItems',
+        'marketplaceOrderShippingItems.product',
+        'marketplaceOrderShippingItems.marketplaceOrderItem',
+        'marketplaceOrderShippingItems.marketplaceOrderItem.marketplaceProductVariation',
+        'marketplaceOrderShippingItems.marketplaceOrderItem.marketplaceProductVariation.marketplaceProduct'
       ]
     })
+
+    return items
   }
 }

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

@@ -12,7 +12,8 @@ export const marketplaceOrderShippingsResolver = {
 
     const qb: SelectQueryBuilder<MarketplaceOrderShipping> = getRepository(MarketplaceOrderShipping)
       .createQueryBuilder('MOS')
-      .innerJoinAndSelect('MOS.marketplaceOrderItems', 'MOI')
+      .innerJoinAndSelect('MOS.marketplaceOrderShippingItems', 'MOSI')
+      .innerJoinAndSelect('MOSI.marketplaceOrderItem', 'MOI')
       .innerJoinAndSelect('MOI.marketplaceOrder', 'MO')
       .innerJoinAndSelect('MOI.marketplaceProductVariation', 'MPV')
       .innerJoinAndSelect('MOS.marketplaceStore', 'MS')

package/server/graphql/resolvers/marketplace-order-shipping-item/create-marketplace-order-shipping-item.ts

@@ -0,0 +1,14 @@
+import { getRepository } from 'typeorm'
+
+import { MarketplaceOrderShippingItem } from '../../../entities'
+
+export const createMarketplaceOrderShippingItem = {
+  async createMarketplaceOrderShippingItem(_: any, { marketplaceOrderShippingItem }, context: any) {
+    return await getRepository(MarketplaceOrderShippingItem).save({
+      ...marketplaceOrderShippingItem,
+      domain: context.state.domain,
+      creator: context.state.user,
+      updater: context.state.user
+    })
+  }
+}

package/server/graphql/resolvers/marketplace-order-shipping-item/delete-marketplace-order-shipping-item.ts

@@ -0,0 +1,10 @@
+import { getRepository } from 'typeorm'
+
+import { MarketplaceOrderShippingItem } from '../../../entities'
+
+export const deleteMarketplaceOrderShippingItem = {
+  async deleteMarketplaceOrderShippingItem(_: any, { name }, context: any) {
+    await getRepository(MarketplaceOrderShippingItem).delete({ domain: context.state.domain, name })
+    return true
+  }
+}

package/server/graphql/resolvers/marketplace-order-shipping-item/delete-marketplace-order-shipping-items.ts

@@ -0,0 +1,13 @@
+import { getRepository, In } from 'typeorm'
+
+import { MarketplaceOrderShippingItem } from '../../../entities'
+
+export const deleteMarketplaceOrderShippingItems = {
+  async deleteMarketplaceOrderShippingItems(_: any, { names }, context: any) {
+    await getRepository(MarketplaceOrderShippingItem).delete({
+      domain: context.state.domain,
+      name: In(names)
+    })
+    return true
+  }
+}

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

@@ -0,0 +1,20 @@
+import { createMarketplaceOrderShippingItem } from './create-marketplace-order-shipping-item'
+import { deleteMarketplaceOrderShippingItem } from './delete-marketplace-order-shipping-item'
+import { deleteMarketplaceOrderShippingItems } from './delete-marketplace-order-shipping-items'
+import { marketplaceOrderShippingItemResolver } from './marketplace-order-shipping-item'
+import { updateMarketplaceOrderShippingItem } from './update-marketplace-order-shipping-item'
+import { updateMultipleMarketplaceOrderShippingItem } from './update-multiple-marketplace-order-shipping-item'
+
+export const MarketplaceOrderShippingItemResolver = {
+  Query: {
+    ...marketplaceOrderShippingItemResolver,
+    ...marketplaceOrderShippingItemResolver
+  },
+  Mutation: {
+    ...updateMarketplaceOrderShippingItem,
+    ...updateMultipleMarketplaceOrderShippingItem,
+    ...createMarketplaceOrderShippingItem,
+    ...deleteMarketplaceOrderShippingItem,
+    ...deleteMarketplaceOrderShippingItems
+  }
+}

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

@@ -0,0 +1,21 @@
+import { getRepository } from 'typeorm'
+
+import { MarketplaceOrderShippingItem } from '../../../entities'
+
+export const marketplaceOrderShippingItemResolver = {
+  async marketplaceOrderShippingItem(_: any, { name }, context: any) {
+    const repository = getRepository(MarketplaceOrderShippingItem)
+
+    return await getRepository(MarketplaceOrderShippingItem).findOne({
+      where: { domain: context.state.domain, name },
+      relations: [
+        'domain',
+        'creator',
+        'updater',
+        'marketplaceOrderItem',
+        'marketplaceOrderItem.marketplaceProductVariation',
+        'marketplaceOrderItem.marketplaceProductVariation.marketplaceProduct'
+      ]
+    })
+  }
+}

package/server/graphql/resolvers/marketplace-order-shipping-item/marketplace-order-shipping-items.ts

@@ -0,0 +1,16 @@
+import { getRepository } from 'typeorm'
+
+import { convertListParams, ListParam } from '@things-factory/shell'
+
+import { MarketplaceOrderShippingItem } from '../../../entities'
+
+export const marketplaceOrderShippingItemsResolver = {
+  async marketplaceOrderShippingItems(_: any, params: ListParam, context: any) {
+    const convertedParams = convertListParams(params)
+    const [items, total] = await getRepository(MarketplaceOrderShippingItem).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'creator', 'updater']
+    })
+    return { items, total }
+  }
+}

package/server/graphql/resolvers/marketplace-order-shipping-item/update-marketplace-order-shipping-item.ts

@@ -0,0 +1,18 @@
+import { getRepository } from 'typeorm'
+
+import { MarketplaceOrderShippingItem } from '../../../entities'
+
+export const updateMarketplaceOrderShippingItem = {
+  async updateMarketplaceOrderShippingItem(_: any, { name, patch }, context: any) {
+    const repository = getRepository(MarketplaceOrderShippingItem)
+    const marketplaceOrderShippingItem = await repository.findOne({
+      where: { domain: context.state.domain, name }
+    })
+
+    return await repository.save({
+      ...marketplaceOrderShippingItem,
+      ...patch,
+      updater: context.state.user
+    })
+  }
+}

package/server/graphql/resolvers/marketplace-order-shipping-item/update-multiple-marketplace-order-shipping-item.ts

@@ -0,0 +1,44 @@
+import { getRepository } from 'typeorm'
+
+import { MarketplaceOrderShippingItem } from '../../../entities'
+
+export const updateMultipleMarketplaceOrderShippingItem = {
+  async updateMultipleMarketplaceOrderShippingItem(_: any, { patches }, context: any) {
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const marketplaceOrderShippingItemRepo = getRepository(MarketplaceOrderShippingItem)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await marketplaceOrderShippingItemRepo.save({
+          ...newRecord,
+          domain: context.state.domain,
+          creator: context.state.user,
+          updater: context.state.user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const marketplaceOrderShippingItem = await marketplaceOrderShippingItemRepo.findOne(newRecord.id)
+
+        const result = await marketplaceOrderShippingItemRepo.save({
+          ...marketplaceOrderShippingItem,
+          ...newRecord,
+          updater: context.state.user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+}

package/server/graphql/resolvers/marketplace-report/marketplace-sales-report.ts

@@ -24,7 +24,8 @@ export const marketplaceSalesReportsResolver = {
     let qb: SelectQueryBuilder<MarketplaceOrderItem> = getRepository(MarketplaceOrderItem).createQueryBuilder('moi')
     buildQuery(qb, params, context)
     qb.leftJoinAndSelect('moi.domain', 'domain')
-      .leftJoinAndSelect('moi.marketplaceOrderShipping', 'mos')
+      .leftJoinAndSelect('moi.marketplaceOrderShippingItems', 'mosi')
+      .leftJoinAndSelect('mosi.marketplaceOrderShipping', 'mos')
       .leftJoinAndSelect('moi.marketplaceOrder', 'mo')
       .leftJoinAndSelect('mo.fulfillmentCenter', 'fc')
       .leftJoinAndSelect('mo.marketplaceStore', 'ms')

package/server/graphql/types/index.ts

@@ -10,3 +10,4 @@ export * from './store-replenishment-item'
 export * from './marketplace-product-variation-price'
 export * from './marketplace-refund-order'
 export * from './marketplace-report'
+export * from './marketplace-order-shipping-item'

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

@@ -23,13 +23,14 @@ export const MarketplaceOrderResolver = gql`
     generateMarketplaceOrder(marketplaceOrder: NewMarketplaceOrder!): MarketplaceOrder @transaction
     cancelMarketplaceOrder(orderNo: String!, patch: MarketplaceOrderPatch!): MarketplaceOrder @transaction
     syncMarketplaceOrder(storeId: String!, fromDate: String, toDate: String): Boolean @transaction
-    syncAllMarketplaceOrder(
-      companyDomainId: String
-      fromDate: String
-      toDate: String
-      blackListStores: String
-    ): Boolean
-    updateOrderReadyToShip(shippingProvider: String!, deliveryType: String, orderNo: String!): Boolean @transaction
+    syncAllMarketplaceOrder(companyDomainId: String, fromDate: String, toDate: String, blackListStores: String): Boolean
+    updateOrderReadyToShip(
+      shippingProvider: String
+      deliveryType: String
+      orderNo: String!
+      orderId: String!
+      domainId: String!
+    ): Boolean @transaction
     initialiseLogistics(deliveryType: LogisticsInit, orderNo: String!): Boolean @transaction
     initialiseLogisticsByBatch(patches: [LogisticsInfo]!): Boolean @transaction
     initialiseShopeeLogisticsByBatch(patches: [LogisticsInfo]!): Boolean

package/server/graphql/types/marketplace-order/logistics-info.ts

@@ -22,5 +22,6 @@ export const LogisticsInfo = gql`
     addressFlag: [String]
     trackingNo: String
     ownTrackingNo: String
+    trackingUrl: String
   }
 `

package/server/graphql/types/marketplace-order-item/marketplace-order-item.ts

@@ -6,8 +6,8 @@ export const MarketplaceOrderItem = gql`
     name: String
     domain: Domain
     marketplaceOrder: MarketplaceOrder
+    marketplaceOrderShippingItems: [MarketplaceOrderShippingItem]
     marketplaceProductVariation: MarketplaceProductVariation
-    marketplaceOrderShipping: MarketplaceOrderShipping
     orderType: String
     cancelBy: String
     returnStatus: String

package/server/graphql/types/marketplace-order-item/new-marketplace-order-item.ts

@@ -12,7 +12,6 @@ export const NewMarketplaceOrderItem = gql`
     packageId: String
     invoiceNo: String
     status: String
-    marketplaceOrderShipping: NewMarketplaceOrderShipping
     marketplaceProductVariation: MarketplaceProductVariationPatch
   }
 `

package/server/graphql/types/marketplace-order-shipping/marketplace-order-shipping-patch.ts

@@ -5,7 +5,6 @@ export const MarketplaceOrderShippingPatch = gql`
     id: String
     name: String
     description: String
-    marketplaceOrderItems: [ObjectRef]
     orderNoRef: String
     subOrderNoRef: String
     address1: String

package/server/graphql/types/marketplace-order-shipping/marketplace-order-shipping.ts

@@ -7,7 +7,7 @@ export const MarketplaceOrderShipping = gql`
     domain: Domain
     description: String
     marketplaceOrder: MarketplaceOrder
-    marketplaceOrderItems: [MarketplaceOrderItem]
+    marketplaceOrderShippingItems: [MarketplaceOrderShippingItem]
     marketplaceStore: MarketplaceStore
     orderNoRef: String
     subOrderNoRef: String
@@ -50,6 +50,7 @@ export const MarketplaceOrderShipping = gql`
     sellerShippingFeeVoucher: Float
     releaseOrderId: String
     fulfillmentCenter: FulfillmentCenter
+    trackingUrl: String
     updater: User
     creator: User
     updatedAt: String

package/server/graphql/types/marketplace-order-shipping/new-marketplace-order-shipping.ts

@@ -4,7 +4,6 @@ export const NewMarketplaceOrderShipping = gql`
   input NewMarketplaceOrderShipping {
     name: String
     description: String
-    marketplaceOrderItems: [ObjectRef]
     orderNoRef: String
     subOrderNoRef: String
     shippingId: String

package/server/graphql/types/marketplace-order-shipping-item/index.ts

@@ -0,0 +1,32 @@
+import gql from 'graphql-tag'
+
+export * from './marketplace-order-shipping-item'
+export * from './marketplace-order-shipping-item-list'
+export * from './marketplace-order-shipping-item-patch'
+export * from './new-marketplace-order-shipping-item'
+
+export const MarketplaceOrderShippingItemResolver = gql`
+  extend type Mutation {
+    createMarketplaceOrderShippingItem(
+      marketplaceOrderShippingItem: NewMarketplaceOrderShippingItem!
+    ): MarketplaceOrderShippingItem
+    updateMarketplaceOrderShippingItem(
+      name: String!
+      patch: MarketplaceOrderShippingItemPatch!
+    ): MarketplaceOrderShippingItem @transaction
+    updateMultipleMarketplaceOrderShippingItem(
+      patches: [MarketplaceOrderShippingItemPatch]!
+    ): [MarketplaceOrderShippingItem]
+    deleteMarketplaceOrderShippingItem(name: String!): Boolean
+    deleteMarketplaceOrderShippingItems(names: [String]!): Boolean
+  }
+
+  extend type Query {
+    marketplaceOrderShippingItems(
+      filters: [Filter]
+      pagination: Pagination
+      sortings: [Sorting]
+    ): MarketplaceOrderShippingItemList
+    marketplaceOrderShippingItem(name: String!): MarketplaceOrderShippingItem
+  }
+`

package/server/graphql/types/marketplace-order-shipping-item/marketplace-order-shipping-item-list.ts

@@ -0,0 +1,8 @@
+import gql from 'graphql-tag'
+
+export const MarketplaceOrderShippingItemList = gql`
+  type MarketplaceOrderShippingItemList {
+    items: [MarketplaceOrderShippingItemList]
+    total: Int
+  }
+`

package/server/graphql/types/marketplace-order-shipping-item/marketplace-order-shipping-item-patch.ts

@@ -0,0 +1,13 @@
+import gql from 'graphql-tag'
+
+export const MarketplaceOrderShippingItemPatch = gql`
+  input MarketplaceOrderShippingItemPatch {
+    id: String
+    name: String
+    marketplaceOrderItem: ObjectRef
+    marketplaceOrderShipping: ObjectRef
+    product: ObjectRef
+    qty: Int
+    cuFlag: String
+  }
+`