@things-factory/marketplace-base 4.1.22 → 4.1.29

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

@@ -1,12 +1,13 @@
-import { EntityManager, IsNull } from 'typeorm'
+import { EntityManager, IsNull, getConnection, SelectQueryBuilder } from 'typeorm'
 import uuid from 'uuid/v4'
 
 import { User } from '@things-factory/auth-base'
 import { Bizplace, getCustomerBizplaces } from '@things-factory/biz-base'
 import { FulfillmentAPI, FulfillmentCenter } from '@things-factory/integration-fulfillment'
-import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
+import { MarketplaceStore, StoreAPI, MarketplaceTransporter } from '@things-factory/integration-marketplace'
 import { Product, ProductBundle, ProductBundleSetting } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
+import { logger } from '@things-factory/env'
 
 import {
   MarketplaceOrder,
@@ -16,10 +17,22 @@ import {
   MarketplaceProductVariation
 } from '../../../entities'
 import { NoGenerator } from '../../../utils'
+import { RESERVE_QTY_ORDER_STATUSES } from '../../../constants/reserve-qty-order-statuses'
+
+const cancelStatuses: string[] = [
+  'cancelled',
+  'canceled',
+  'failed',
+  'shipped_back_success',
+  'shipped_back',
+  'returned',
+  'to_return',
+  'refunded'
+]
 
 export const syncMarketplaceOrder = {
-  async syncMarketplaceOrder(_: any, { storeId, fromDate, toDate }, context: any) {
-    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+  async syncMarketplaceOrder(_: any, { storeId, fromDate, toDate, scheduler = false }, context: any,) {
+    const { domain, user }: { domain: Domain; user: User; tx: EntityManager } = context.state
 
     const marketplaceStore: MarketplaceStore = await StoreAPI.getMarketplaceStore(storeId)
 
@@ -27,7 +40,6 @@ export const syncMarketplaceOrder = {
     let hasMorePage: boolean = true
     let lastOrderId: string
     var limit: number = 100
-    const cancelStatuses: string[] = ['cancelled', 'canceled']
     const disallowCancelStatuses: string[] = ['CANCELLED', 'PENDING_CANCEL']
 
     while (hasMorePage) {
@@ -39,713 +51,617 @@ export const syncMarketplaceOrder = {
       })
 
       if (marketplaceOrders?.length == 0) throw new Error('There is no order available to sync')
-
       for (var i = 0; i < marketplaceOrders.length; i++) {
-        var order = marketplaceOrders[i]
-
-        let marketplaceOrderItems = []
-        let tracking_code = ''
-        let deliveryProvider: string
-        let dropPickProvider: string
-
-        if (marketplaceStore.platform == 'lazada') {
-          if (order.trackingNo != '') {
-            tracking_code = JSON.parse(order.trackingNo)
-              .reduce((newItem, item) => {
-                if (newItem.indexOf(item.tracking_code) < 0) {
-                  newItem.push(item.tracking_code)
-                }
-                return newItem
-              }, [])
-              .join(',')
-          }
-
-          const shippingProviderInfo: any = {}
-          order.shippingProvider.split(', ').forEach(s => {
-            var [key, value] = s.split(': ')
-            shippingProviderInfo[key] = value
-          })
-
-          dropPickProvider = shippingProviderInfo?.Pickup
-            ? shippingProviderInfo['Pickup']
-            : shippingProviderInfo['Drop-off']
-          deliveryProvider = shippingProviderInfo['Delivery']
-        }
-
-        let marketplaceOrder: MarketplaceOrder = new MarketplaceOrder()
-        marketplaceOrder.name = order.name
-        marketplaceOrder.orderNo = order.orderNo
-        marketplaceOrder.itemCount = order.itemCount
-        marketplaceOrder.totalAmount = order.totalAmount
-        marketplaceOrder.status = order.status
-        marketplaceOrder.remark = order?.remark
-        marketplaceOrder.trackingNo = tracking_code ? tracking_code : order.trackingNo
-        marketplaceOrder.shippingProvider = order.shippingProvider
-        marketplaceOrder.orderCreatedAt = order.orderCreatedAt
-        marketplaceOrder.orderUpdatedAt = order.orderUpdatedAt
-        marketplaceOrder.marketplaceStore = marketplaceStore
-        marketplaceOrder.domain = marketplaceStore.domain
-        marketplaceOrder.buyerUsername = order.buyerUsername
-        marketplaceOrder.payTime = order.payTime
-        marketplaceOrder.serviceFee = order.serviceFee
-        marketplaceOrder.commissionFee = order.commissionFee
-        marketplaceOrder.transactionFee = order.transactionFee
-        marketplaceOrder.shippingMode = order.shippingMode
-        marketplaceOrder.voucherAmount = order.voucherAmount
-        marketplaceOrder.totalRealeasedAmount = order.totalRealeasedAmount
-        marketplaceOrder.voucherCode = order.voucherCode
-        marketplaceOrder.shippingRebate = order.shippingRebate
-
-        const existingMarketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-          where: { domain: marketplaceStore.domain, name: order.name },
-          relations: [
-            'domain',
-            'fulfillmentCenter',
-            'marketplaceOrderItems',
-            'marketplaceOrderItems.marketplaceOrderShippingItems',
-            'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping',
-            'marketplaceOrderItems.marketplaceProductVariation'
-          ]
-        })
-
-        if (existingMarketplaceOrder) {
-          let otherInfoJSON: any = {}
-
-          if (existingMarketplaceOrder?.otherInfoJSON && deliveryProvider) {
-            otherInfoJSON = JSON.parse(existingMarketplaceOrder.otherInfoJSON)
-            otherInfoJSON.shippingProvider = deliveryProvider
-          }
-
-          marketplaceOrder = {
-            ...existingMarketplaceOrder,
-            ...marketplaceOrder,
-            otherInfoJSON: otherInfoJSON ? JSON.stringify(otherInfoJSON) : null,
-            updater: user
-          }
+        await getConnection().transaction(async tx => {
+          try {
+            var order = marketplaceOrders[i]
+
+            let marketplaceOrderItems = []
+            let tracking_code = ''
+            let deliveryProvider: string
+            let dropPickProvider: string
+
+            if (marketplaceStore.platform == 'lazada') {
+              if (order.trackingNo != '') {
+                tracking_code = JSON.parse(order.trackingNo)
+                  .reduce((newItem, item) => {
+                    if (newItem.indexOf(item.tracking_code) < 0) {
+                      newItem.push(item.tracking_code)
+                    }
+                    return newItem
+                  }, [])
+                  .join(',')
+              }
 
-          if (
-            !marketplaceOrder?.releaseOrderId &&
-            cancelStatuses.includes(marketplaceOrder.status) &&
-            !cancelStatuses.includes(existingMarketplaceOrder.status)
-          ) {
-            for (let item of marketplaceOrder.marketplaceOrderItems) {
-              let foundVariations = await tx.getRepository(MarketplaceProductVariation).find({
-                where: { domain: marketplaceOrder.domain, sku: item.marketplaceProductVariation.sku },
-                relations: ['domain', 'marketplaceProduct', 'marketplaceProduct.marketplaceStore']
+              const shippingProviderInfo: any = {}
+              order.shippingProvider.split(', ').forEach(s => {
+                var [key, value] = s.split(': ')
+                shippingProviderInfo[key] = value
               })
 
-              let activeVariations: MarketplaceProductVariation[] = foundVariations.filter(
-                variation =>
-                  variation.marketplaceProduct.marketplaceStore.status != 'TERMINATED' && variation.sku != null
-              )
-
-              await Promise.all(
-                activeVariations.map(async variation => {
-                  await calculateReserveQtyForBundle(tx, variation, marketplaceOrder.domain, item.qty, '-')
-
-                  variation.reserveQty -= item.qty
-                  variation.qty += item.qty
-                  await tx.getRepository(MarketplaceProductVariation).save(variation)
-                })
-              )
+              dropPickProvider = shippingProviderInfo?.Pickup
+                ? shippingProviderInfo['Pickup']
+                : shippingProviderInfo['Drop-off']
+              deliveryProvider = shippingProviderInfo['Delivery']
             }
-          }
 
-          if (marketplaceOrder?.releaseOrderId) {
-            const fulfillmentCenter: FulfillmentCenter = marketplaceOrder.fulfillmentCenter
-            const centerId: string = fulfillmentCenter.centerId
-            const warehouseDomain: Domain = await tx.getRepository(Domain).findOne({ where: { subdomain: centerId } })
-            const customerBizplaces: Bizplace[] = await getCustomerBizplaces(warehouseDomain)
-            const customerBizplaceId: string = customerBizplaces.find(
-              customerBizplace => customerBizplace.company.domain.id == domain.id
-            ).id
-
-            let { items: releaseOrders }: any = await FulfillmentAPI.getOutboundOrders(fulfillmentCenter, {
-              customerBizplaceId,
-              refNo: marketplaceOrder.orderNo
+            const marketplaceTransporter: MarketplaceTransporter = await tx.getRepository(MarketplaceTransporter).findOne({
+              where: { marketplaceStore },
+              relations: ['pickupTransporter']
             })
 
-            if (existingMarketplaceOrder.isSplitted) {
-              for (let a = 0; a < releaseOrders.length; a++) {
-                const releaseOrder: any = releaseOrders[a]
-                const foundMarketplaceOrderShipping: MarketplaceOrderShipping = await tx
-                  .getRepository(MarketplaceOrderShipping)
-                  .findOne({
-                    where: { domain: marketplaceStore.domain, subOrderNoRef: releaseOrder.refNo2 }
-                  })
-                let patch = {
-                  id: releaseOrder.id,
-                  marketplaceOrderStatus: marketplaceOrder.status,
-                  trackingNo: foundMarketplaceOrderShipping?.trackingNo == '[]'
-                    ? foundMarketplaceOrderShipping.ownTrackingNo : 
-                    foundMarketplaceOrderShipping?.trackingNo
-                    ? foundMarketplaceOrderShipping.trackingNo
-                    : foundMarketplaceOrderShipping.ownTrackingNo,
-                  transporter: dropPickProvider ? dropPickProvider : marketplaceOrder.shippingProvider
-                }
+            let marketplaceOrder: MarketplaceOrder = new MarketplaceOrder()
+            marketplaceOrder.name = order.name
+            marketplaceOrder.orderNo = order.orderNo
+            marketplaceOrder.itemCount = order.itemCount
+            marketplaceOrder.totalAmount = order.totalAmount
+            marketplaceOrder.status = order.status
+            marketplaceOrder.remark = order?.remark
+            marketplaceOrder.trackingNo = tracking_code ? tracking_code : order.trackingNo
+            marketplaceOrder.shippingProvider = marketplaceStore.eTrax && marketplaceTransporter ? marketplaceTransporter.pickupTransporter.name : order.shippingProvider
+            marketplaceOrder.orderCreatedAt = order.orderCreatedAt
+            marketplaceOrder.orderUpdatedAt = order.orderUpdatedAt
+            marketplaceOrder.marketplaceStore = marketplaceStore
+            marketplaceOrder.domain = marketplaceStore.domain
+            marketplaceOrder.buyerUsername = order.buyerUsername
+            marketplaceOrder.payTime = order.payTime
+            marketplaceOrder.serviceFee = order.serviceFee
+            marketplaceOrder.commissionFee = order.commissionFee
+            marketplaceOrder.transactionFee = order.transactionFee
+            marketplaceOrder.shippingMode = order.shippingMode
+            marketplaceOrder.voucherAmount = order.voucherAmount
+            marketplaceOrder.totalRealeasedAmount = order.totalRealeasedAmount
+            marketplaceOrder.voucherCode = order.voucherCode
+            marketplaceOrder.shippingRebate = order.shippingRebate
+
+            const existingMarketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
+              where: { domain: marketplaceStore.domain, name: order.name },
+              relations: [
+                'domain',
+                'fulfillmentCenter',
+                'marketplaceOrderItems',
+                'marketplaceOrderItems.marketplaceOrderShippingItems',
+                'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping',
+                'marketplaceOrderItems.marketplaceProductVariation',
+                'marketplaceStore'
+              ]
+            })
 
-                await FulfillmentAPI.updateReleaseGoodDetails(fulfillmentCenter, {
-                  customerBizplaceId,
-                  releaseOrder: { ...patch },
-                  shippingOrder: null
-                })
-              }
-            } else {
-              let releaseOrder = Object.assign({}, releaseOrders[0])
-              const foundMarketplaceOrderShipping: MarketplaceOrderShipping = await tx
-                .getRepository(MarketplaceOrderShipping)
-                .findOne({
-                  where: { domain: marketplaceStore.domain, orderNoRef: releaseOrder.refNo }
-                })
-              let patch = {
-                id: releaseOrder.id,
-                marketplaceOrderStatus: marketplaceOrder.status,
-                trackingNo: foundMarketplaceOrderShipping?.trackingNo == '[]'
-                  ? foundMarketplaceOrderShipping.ownTrackingNo : 
-                  foundMarketplaceOrderShipping?.trackingNo
-                  ? foundMarketplaceOrderShipping.trackingNo
-                  : foundMarketplaceOrderShipping.ownTrackingNo,
-                transporter: dropPickProvider ? dropPickProvider : marketplaceOrder.shippingProvider
-              }
+            if (existingMarketplaceOrder) {
+              let otherInfoJSON: any = {}
 
-              await FulfillmentAPI.updateReleaseGoodDetails(fulfillmentCenter, {
-                customerBizplaceId,
-                releaseOrder: { ...patch },
-                shippingOrder: null
-              })
-            }
+              if (existingMarketplaceOrder?.otherInfoJSON && deliveryProvider) {
+                otherInfoJSON = JSON.parse(existingMarketplaceOrder.otherInfoJSON)
+                otherInfoJSON.shippingProvider = deliveryProvider
+              }
 
-            if (cancelStatuses.includes(marketplaceOrder.status)) {
-              if (existingMarketplaceOrder.isSplitted) {
-                releaseOrders = releaseOrders.filter(function (order) {
-                  return !disallowCancelStatuses.includes(order.status)
-                })
+              marketplaceOrder = {
+                ...existingMarketplaceOrder,
+                ...marketplaceOrder,
+                otherInfoJSON: otherInfoJSON ? JSON.stringify(otherInfoJSON) : null,
+                updater: user
+              }
 
-                if (releaseOrders?.length) {
-                  for (let a = 0; a < releaseOrders.length; a++) {
-                    const releaseOrderId: string = releaseOrders[a].id
-                    await FulfillmentAPI.cancelReleaseOrder(fulfillmentCenter, { customerBizplaceId, releaseOrderId })
-                  }
+              if (
+                !marketplaceOrder?.releaseOrderId &&
+                RESERVE_QTY_ORDER_STATUSES[marketplaceOrder.marketplaceStore.platform.toUpperCase()].includes(
+                  existingMarketplaceOrder.status
+                ) &&
+                cancelStatuses.includes(marketplaceOrder.status)
+              ) {
+                for (let item of marketplaceOrder.marketplaceOrderItems) {
+                  await updateQtyAndReserveQty(
+                    tx,
+                    item.marketplaceProductVariation,
+                    marketplaceOrder,
+                    item.qty * -1,
+                    null,
+                    existingMarketplaceOrder
+                  )
                 }
-              } else {
+              }
+
+              if (marketplaceOrder?.releaseOrderId) {
                 const fulfillmentCenter: FulfillmentCenter = marketplaceOrder.fulfillmentCenter
                 const centerId: string = fulfillmentCenter.centerId
-
                 const warehouseDomain: Domain = await tx
                   .getRepository(Domain)
                   .findOne({ where: { subdomain: centerId } })
                 const customerBizplaces: Bizplace[] = await getCustomerBizplaces(warehouseDomain)
-                const customerBizplaceId: string = customerBizplaces[0].id
+                const customerBizplaceId: string = customerBizplaces.find(
+                  customerBizplace => customerBizplace.company.domain.id == domain.id
+                ).id
 
-                const { items: releaseOrders }: any = await FulfillmentAPI.getOutboundOrders(fulfillmentCenter, {
+                let { items: releaseOrders }: any = await FulfillmentAPI.getOutboundOrders(fulfillmentCenter, {
                   customerBizplaceId,
                   refNo: marketplaceOrder.orderNo
                 })
 
-                const releaseOrderStatus = releaseOrders[0].status
+                if (existingMarketplaceOrder.isSplitted) {
+                  for (let a = 0; a < releaseOrders.length; a++) {
+                    const releaseOrder: any = releaseOrders[a]
+                    const foundMarketplaceOrderShipping: MarketplaceOrderShipping = await tx
+                      .getRepository(MarketplaceOrderShipping)
+                      .findOne({
+                        where: { domain: marketplaceStore.domain, subOrderNoRef: releaseOrder.refNo2 }
+                      })
+                    let patch = {
+                      id: releaseOrder.id,
+                      marketplaceOrderStatus: marketplaceOrder.status,
+                      trackingNo:
+                        foundMarketplaceOrderShipping?.trackingNo == '[]'
+                          ? foundMarketplaceOrderShipping.ownTrackingNo
+                          : foundMarketplaceOrderShipping?.trackingNo
+                          ? foundMarketplaceOrderShipping.trackingNo
+                          : foundMarketplaceOrderShipping.ownTrackingNo,
+                      transporter: dropPickProvider ? dropPickProvider : marketplaceOrder.shippingProvider
+                    }
 
-                if (!disallowCancelStatuses.includes(releaseOrderStatus)) {
-                  await FulfillmentAPI.cancelReleaseOrder(fulfillmentCenter, {
+                    await FulfillmentAPI.updateReleaseGoodDetails(fulfillmentCenter, {
+                      customerBizplaceId,
+                      releaseOrder: { ...patch },
+                      shippingOrder: null
+                    })
+                  }
+                } else {
+                  let releaseOrder = Object.assign({}, releaseOrders[0])
+                  const foundMarketplaceOrderShipping: MarketplaceOrderShipping = await tx
+                    .getRepository(MarketplaceOrderShipping)
+                    .findOne({
+                      where: { domain: marketplaceStore.domain, orderNoRef: releaseOrder.refNo }
+                    })
+                  let patch = {
+                    id: releaseOrder.id,
+                    marketplaceOrderStatus: marketplaceOrder.status,
+                    trackingNo:
+                      foundMarketplaceOrderShipping?.trackingNo == '[]'
+                        ? foundMarketplaceOrderShipping.ownTrackingNo
+                        : foundMarketplaceOrderShipping?.trackingNo
+                        ? foundMarketplaceOrderShipping.trackingNo
+                        : foundMarketplaceOrderShipping.ownTrackingNo,
+                    transporter: dropPickProvider ? dropPickProvider : marketplaceOrder.shippingProvider
+                  }
+
+                  await FulfillmentAPI.updateReleaseGoodDetails(fulfillmentCenter, {
                     customerBizplaceId,
-                    releaseOrderId: releaseOrders[0].id
+                    releaseOrder: { ...patch },
+                    shippingOrder: null
                   })
                 }
+
+                if (cancelStatuses.includes(marketplaceOrder.status)) {
+                  if (existingMarketplaceOrder.isSplitted) {
+                    releaseOrders = releaseOrders.filter(function (order) {
+                      return !disallowCancelStatuses.includes(order.status)
+                    })
+
+                    if (releaseOrders?.length) {
+                      for (let a = 0; a < releaseOrders.length; a++) {
+                        const releaseOrderId: string = releaseOrders[a].id
+                        await FulfillmentAPI.cancelReleaseOrder(fulfillmentCenter, {
+                          customerBizplaceId,
+                          releaseOrderId
+                        })
+                      }
+                    }
+                  } else {
+                    const fulfillmentCenter: FulfillmentCenter = marketplaceOrder.fulfillmentCenter
+                    const centerId: string = fulfillmentCenter.centerId
+
+                    const warehouseDomain: Domain = await tx
+                      .getRepository(Domain)
+                      .findOne({ where: { subdomain: centerId } })
+                    const customerBizplaces: Bizplace[] = await getCustomerBizplaces(warehouseDomain)
+                    const customerBizplaceId: string = customerBizplaces[0].id
+
+                    const { items: releaseOrders }: any = await FulfillmentAPI.getOutboundOrders(fulfillmentCenter, {
+                      customerBizplaceId,
+                      refNo: marketplaceOrder.orderNo
+                    })
+
+                    const releaseOrderStatus = releaseOrders[0].status
+
+                    if (!disallowCancelStatuses.includes(releaseOrderStatus)) {
+                      await FulfillmentAPI.cancelReleaseOrder(fulfillmentCenter, {
+                        customerBizplaceId,
+                        releaseOrderId: releaseOrders[0].id
+                      })
+                    }
+                  }
+                }
               }
             }
-          }
-        }
 
-        let savedMarketplaceOrderShipping: MarketplaceOrderShipping = new MarketplaceOrderShipping()
-        let savedMarketplaceOrderShippings: MarketplaceOrderShipping[] = []
-
-        if (order?.orderShipping) {
-          const orderShipping: any = order.orderShipping
-
-          let marketplaceOrderShipping: MarketplaceOrderShipping = new MarketplaceOrderShipping()
-          marketplaceOrderShipping.name = NoGenerator.orderShipping()
-          marketplaceOrderShipping.address1 = orderShipping.address1
-          marketplaceOrderShipping.address2 = orderShipping.address2
-          marketplaceOrderShipping.address3 = orderShipping.address3
-          marketplaceOrderShipping.address4 = orderShipping.address4
-          marketplaceOrderShipping.address5 = orderShipping.address5
-          marketplaceOrderShipping.attentionTo = orderShipping.attentionTo
-          marketplaceOrderShipping.city = orderShipping.city
-          marketplaceOrderShipping.country = orderShipping.country
-          marketplaceOrderShipping.state = orderShipping?.state || null
-          marketplaceOrderShipping.postCode = orderShipping.postCode
-          marketplaceOrderShipping.phone1 = orderShipping.phone1
-          marketplaceOrderShipping.phone2 = orderShipping.phone2
-          marketplaceOrderShipping.trackingNo = order?.trackingNo || null
-          marketplaceOrderShipping.orderNoRef = marketplaceOrder.orderNo
-          marketplaceOrderShipping.subOrderNoRef = marketplaceOrder.orderNo
-          marketplaceOrderShipping.marketplaceStore = marketplaceStore
-          marketplaceOrderShipping.creator = user
-          marketplaceOrderShipping.domain = marketplaceStore.domain
-          marketplaceOrderShipping.shippingFee = orderShipping.shippingFee
-          marketplaceOrderShipping.actualShippingFee = orderShipping.actualShippingFee
-          marketplaceOrderShipping.marketplaceShippingFeeVoucher = orderShipping.marketplaceShippingFeeVoucher
-          marketplaceOrderShipping.sellerShippingFeeVoucher = orderShipping.sellerShippingFeeVoucher
-
-          if (existingMarketplaceOrder) {
-            if (existingMarketplaceOrder.isSplitted) {
-              let existingOrderShippings: MarketplaceOrderShipping[] = await tx
-                .getRepository(MarketplaceOrderShipping)
-                .find({
-                  where: { domain, marketplaceStore, orderNoRef: marketplaceOrder.orderNo }
-                })
+            let savedMarketplaceOrderShipping: MarketplaceOrderShipping = new MarketplaceOrderShipping()
+            let savedMarketplaceOrderShippings: MarketplaceOrderShipping[] = []
 
-              existingOrderShippings = existingOrderShippings.map(item => {
-                return {
-                  ...item,
-                  address1: orderShipping.address1,
-                  address2: orderShipping.address2,
-                  address3: orderShipping.address3,
-                  address4: orderShipping.address4,
-                  address5: orderShipping.address5,
-                  attentionTo: orderShipping.attentionTo,
-                  city: orderShipping.city,
-                  country: orderShipping.country,
-                  state: orderShipping?.state,
-                  postCode: orderShipping.postCode,
-                  phone1: orderShipping.phone1,
-                  phone2: orderShipping.phone2,
-                  email: orderShipping?.email,
-                  trackingNo: order?.trackingNo,
-                  shippingFee: orderShipping.shippingFee,
-                  actualShippingFee: orderShipping.actualShippingFee,
-                  marketplaceShippingFeeVoucher: orderShipping.marketplaceShippingFeeVoucher,
-                  sellerShippingFeeVoucher: orderShipping.sellerShippingFeeVoucher
-                }
-              })
+            if (order?.orderShipping) {
+              const orderShipping: any = order.orderShipping
+
+              let marketplaceOrderShipping: MarketplaceOrderShipping = new MarketplaceOrderShipping()
+              marketplaceOrderShipping.name = NoGenerator.orderShipping()
+              marketplaceOrderShipping.address1 = orderShipping.address1
+              marketplaceOrderShipping.address2 = orderShipping.address2
+              marketplaceOrderShipping.address3 = orderShipping.address3
+              marketplaceOrderShipping.address4 = orderShipping.address4
+              marketplaceOrderShipping.address5 = orderShipping.address5
+              marketplaceOrderShipping.attentionTo = orderShipping.attentionTo
+              marketplaceOrderShipping.city = orderShipping.city
+              marketplaceOrderShipping.country = orderShipping.country
+              marketplaceOrderShipping.state = orderShipping?.state || null
+              marketplaceOrderShipping.postCode = orderShipping.postCode
+              marketplaceOrderShipping.phone1 = orderShipping.phone1
+              marketplaceOrderShipping.phone2 = orderShipping.phone2
+              marketplaceOrderShipping.trackingNo = order?.trackingNo || null
+              marketplaceOrderShipping.orderNoRef = marketplaceOrder.orderNo
+              marketplaceOrderShipping.subOrderNoRef = marketplaceOrder.orderNo
+              marketplaceOrderShipping.marketplaceStore = marketplaceStore
+              marketplaceOrderShipping.creator = user
+              marketplaceOrderShipping.domain = marketplaceStore.domain
+              marketplaceOrderShipping.shippingFee = orderShipping.shippingFee
+              marketplaceOrderShipping.actualShippingFee = orderShipping.actualShippingFee
+              marketplaceOrderShipping.marketplaceShippingFeeVoucher = orderShipping.marketplaceShippingFeeVoucher
+              marketplaceOrderShipping.sellerShippingFeeVoucher = orderShipping.sellerShippingFeeVoucher
+
+              if (existingMarketplaceOrder) {
+                if (existingMarketplaceOrder.isSplitted) {
+                  let existingOrderShippings: MarketplaceOrderShipping[] = await tx
+                    .getRepository(MarketplaceOrderShipping)
+                    .find({
+                      where: { domain, marketplaceStore, orderNoRef: marketplaceOrder.orderNo }
+                    })
+
+                  existingOrderShippings = existingOrderShippings.map(item => {
+                    return {
+                      ...item,
+                      address1: orderShipping.address1,
+                      address2: orderShipping.address2,
+                      address3: orderShipping.address3,
+                      address4: orderShipping.address4,
+                      address5: orderShipping.address5,
+                      attentionTo: orderShipping.attentionTo,
+                      city: orderShipping.city,
+                      country: orderShipping.country,
+                      state: orderShipping?.state,
+                      postCode: orderShipping.postCode,
+                      phone1: orderShipping.phone1,
+                      phone2: orderShipping.phone2,
+                      email: orderShipping?.email,
+                      trackingNo: marketplaceStore.eTrax ? item.trackingNo : order?.trackingNo,
+                      shippingFee: orderShipping.shippingFee,
+                      actualShippingFee: orderShipping.actualShippingFee,
+                      marketplaceShippingFeeVoucher: orderShipping.marketplaceShippingFeeVoucher,
+                      sellerShippingFeeVoucher: orderShipping.sellerShippingFeeVoucher
+                    }
+                  })
 
-              savedMarketplaceOrderShippings = await tx
-                .getRepository(MarketplaceOrderShipping)
-                .save(existingOrderShippings)
-            } else {
-              if (existingMarketplaceOrder?.marketplaceOrderItems) {
-                let existingOrderShipping: MarketplaceOrderShipping
-                existingOrderShipping =
-                  existingMarketplaceOrder.marketplaceOrderItems[0].marketplaceOrderShippingItems[0]
-                    .marketplaceOrderShipping
-
-                marketplaceOrderShipping = {
-                  ...existingOrderShipping,
-                  ...marketplaceOrderShipping,
-                  trackingNo: marketplaceOrderShipping?.trackingNo
-                    ? marketplaceOrderShipping.trackingNo
-                    : existingOrderShipping?.trackingNo
-                    ? existingOrderShipping.trackingNo
-                    : marketplaceOrderShipping.trackingNo,
-                  updater: user
+                  savedMarketplaceOrderShippings = await tx
+                    .getRepository(MarketplaceOrderShipping)
+                    .save(existingOrderShippings)
+                } else {
+                  if (existingMarketplaceOrder?.marketplaceOrderItems) {
+                    let existingOrderShipping: MarketplaceOrderShipping
+                    existingOrderShipping =
+                      existingMarketplaceOrder.marketplaceOrderItems[0].marketplaceOrderShippingItems[0]
+                        .marketplaceOrderShipping
+
+                    marketplaceOrderShipping = {
+                      ...existingOrderShipping,
+                      ...marketplaceOrderShipping,
+                      trackingNo: marketplaceStore.eTrax
+                        ? existingOrderShipping.trackingNo
+                        : marketplaceOrderShipping?.trackingNo
+                        ? marketplaceOrderShipping.trackingNo
+                        : existingOrderShipping?.trackingNo
+                        ? existingOrderShipping.trackingNo
+                        : marketplaceOrderShipping.trackingNo,
+                      updater: user
+                    }
+
+                    savedMarketplaceOrderShipping = await tx
+                      .getRepository(MarketplaceOrderShipping)
+                      .save(marketplaceOrderShipping)
+                  }
                 }
+              } else {
+                if (marketplaceStore.eTrax) delete marketplaceOrderShipping.trackingNo
 
                 savedMarketplaceOrderShipping = await tx
                   .getRepository(MarketplaceOrderShipping)
                   .save(marketplaceOrderShipping)
               }
             }
-          } else {
-            savedMarketplaceOrderShipping = await tx
-              .getRepository(MarketplaceOrderShipping)
-              .save(marketplaceOrderShipping)
-          }
-        }
-
-        let orderTotalWeight: number = 0
-        let foundVariations = []
-        for (var j = 0; j < order.orderItems.length; j++) {
-          var item = order.orderItems[j]
-          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)
-          }
-
-          if (!foundVariation) {
-            let newVariation: any = {
-              variationId: item.variationId,
-              name: item.variationName,
-              variationSku: item.variationSku,
-              channelSku: item.sku,
-              status: 'INACTIVE',
-              domain: marketplaceStore.domain
-            }
 
-            await tx.getRepository(MarketplaceProductVariation).save(newVariation)
-            foundVariation = newVariation
-          }
-
-          let marketplaceOrderItem: MarketplaceOrderItem = new MarketplaceOrderItem()
-          marketplaceOrderItem.domain = marketplaceStore.domain
-          marketplaceOrderItem.name = item.name
-          marketplaceOrderItem.qty = item.qty
-          marketplaceOrderItem.paidPrice = item.paidPrice
-          marketplaceOrderItem.status = marketplaceOrder.status
-          marketplaceOrderItem.docRefNo = item.docRefNo
-          marketplaceOrderItem.marketplaceProductVariation = foundVariation
-          marketplaceOrderItem.trackingCode = order.trackingNo
-          marketplaceOrderItem.marketplaceOrder = marketplaceOrder
-          marketplaceOrderItem.originalPrice = item.originalPrice
-          marketplaceOrderItem.discount = item.discount
-          marketplaceOrderItem.promotionId = item.promotionId
-          marketplaceOrderItem.creator = user
-          marketplaceOrderItem.paymentFee = item.paymentFee || null
-          marketplaceOrderItem.commissionFee = item.commissionFee || null
-          marketplaceOrderItem.shippingFeePaidByCustomer = item.shippingFeePaidByCustomer || null
-          marketplaceOrderItem.itemPriceCredit = item.itemPriceCredit || null
-          marketplaceOrderItem.promotionalCharges = item.promotionalCharges || null
-          marketplaceOrderItem.ordersMarketplaceFeesTotal = item.ordersMarketplaceFeesTotal || null
-          marketplaceOrderItem.ordersSalesTotal = item.ordersSalesTotal || null
-          marketplaceOrderItem.ordersMarketingFeesTotal = item.ordersMarketingFeesTotal || null
-          marketplaceOrderItem.ordersLogisticsTotal = item.ordersLogisticsTotal || null
-          marketplaceOrderItem.marketplaceBonus = item.marketplaceBonus
-          marketplaceOrderItem.marketplaceBonusSeller = item.marketplaceBonusSeller
-          marketplaceOrderItem.shippingFeeDiscountMarketplace = item.shippingFeeDiscountMarketplace
-          marketplaceOrderItem.shippingFeeDiscountSeller = item.shippingFeeDiscountSeller
-          marketplaceOrderItem.promotionalChargesFlexiCombo = item.promotionalChargesFlexiCombo
-          marketplaceOrderItem.autoShippingSubsidyMarketplace = item.autoShippingSubsidyMarketplace
-          marketplaceOrderItem.originalShippingFee = item.originalShippingFee
-          marketplaceOrderItem.taxAmount = item.taxAmount
-
-          marketplaceOrderItems.push({ ...marketplaceOrderItem })
-
-          if (foundVariation?.primaryUnitValue)
-            orderTotalWeight += parseFloat(foundVariation.primaryUnitValue.toFixed(3)) * item.qty || 0
-        }
+            let orderTotalWeight: number = 0
+            let foundVariations = []
+            for (var j = 0; j < order.orderItems.length; j++) {
+              var item = order.orderItems[j]
+              let foundVariationsQuery = await tx.getRepository(MarketplaceProductVariation).find({
+                where: { domain: marketplaceStore.domain, variationId: item.variationId },
+                relations: ['domain', 'marketplaceProduct', 'marketplaceProduct.marketplaceStore']
+              })
 
-        if (existingMarketplaceOrder) {
-          let existingOrderItems: MarketplaceOrderItem[] = []
-          existingOrderItems = existingMarketplaceOrder.marketplaceOrderItems
+              let foundVariation = foundVariationsQuery.filter(
+                fv => fv.marketplaceProduct.marketplaceStore.id == marketplaceStore.id
+              )[0]
 
-          existingOrderItems = await checkUpdateItemId(existingOrderItems, marketplaceOrderItems)
+              if (foundVariation) {
+                foundVariations.push(foundVariation)
+              }
 
-          if (existingMarketplaceOrder.isSplitted) {
-            marketplaceOrderItems = existingOrderItems.filter(
-              itm => itm.name == item.name && itm.marketplaceProductVariation.variationId == item.variationId
-            )
+              if (!foundVariation) {
+                let newVariation: any = {
+                  variationId: item.variationId,
+                  name: item.variationName,
+                  variationSku: item.variationSku,
+                  channelSku: item.sku,
+                  status: 'INACTIVE',
+                  domain: marketplaceStore.domain
+                }
 
-            marketplaceOrderItems = marketplaceOrderItems.map(marketplaceOrderitem => {
-              return {
-                ...marketplaceOrderitem,
-                status: order.status,
-                trackingCode: order.trackingNo
+                await tx.getRepository(MarketplaceProductVariation).save(newVariation)
+                foundVariation = newVariation
               }
-            })
-          } else {
-            if (existingOrderItems.length > marketplaceOrderItems.length) {
-              let nonMatchedOrderItems = []
-              existingOrderItems.map(item => {
-                const matchedOrderItem = marketplaceOrderItems.find(
-                  itm =>
-                    itm.name === item.name &&
-                    itm.marketplaceProductVariation.variationId == item.marketplaceProductVariation.variationId
-                )
-                if (!matchedOrderItem) {
-                  nonMatchedOrderItems.push({ ...item })
-                }
-              })
-              if (nonMatchedOrderItems.length > 0 && !cancelStatuses.includes(marketplaceOrder.status)) {
-                await Promise.all(
-                  nonMatchedOrderItems.map(async item => {
-                    for (var foundVariation of foundVariations) {
-                      if (foundVariation.sku) {
-                        let allVariations: MarketplaceProductVariation[] = await tx
-                          .getRepository(MarketplaceProductVariation)
-                          .find({
-                            where: { domain: foundVariation.domain, sku: foundVariation.sku },
-                            relations: [
-                              'domain',
-                              'marketplaceProduct',
-                              'marketplaceProduct.marketplaceStore',
-                              'marketplaceProduct.marketplaceStore.marketplaceDistributors'
-                            ]
-                          })
-
-                        let activeVariations: MarketplaceProductVariation[] = allVariations.filter(
-                          variation => variation.marketplaceProduct.marketplaceStore.status != 'TERMINATED'
-                        )
 
-                        await Promise.all(
-                          activeVariations.map(async variation => {
-                            await calculateReserveQtyForBundle(tx, variation, marketplaceOrder.domain, item.qty, '-')
+              let marketplaceOrderItem: MarketplaceOrderItem = new MarketplaceOrderItem()
+              marketplaceOrderItem.domain = marketplaceStore.domain
+              marketplaceOrderItem.name = item.name
+              marketplaceOrderItem.qty = item.qty
+              marketplaceOrderItem.paidPrice = item.paidPrice
+              marketplaceOrderItem.status = marketplaceOrder.status
+              marketplaceOrderItem.docRefNo = item.docRefNo
+              marketplaceOrderItem.marketplaceProductVariation = foundVariation
+              marketplaceOrderItem.trackingCode = order.trackingNo
+              marketplaceOrderItem.marketplaceOrder = marketplaceOrder
+              marketplaceOrderItem.originalPrice = item.originalPrice
+              marketplaceOrderItem.discount = item.discount
+              marketplaceOrderItem.promotionId = item.promotionId
+              marketplaceOrderItem.creator = user
+              marketplaceOrderItem.paymentFee = item.paymentFee || null
+              marketplaceOrderItem.commissionFee = item.commissionFee || null
+              marketplaceOrderItem.shippingFeePaidByCustomer = item.shippingFeePaidByCustomer || null
+              marketplaceOrderItem.itemPriceCredit = item.itemPriceCredit || null
+              marketplaceOrderItem.promotionalCharges = item.promotionalCharges || null
+              marketplaceOrderItem.ordersMarketplaceFeesTotal = item.ordersMarketplaceFeesTotal || null
+              marketplaceOrderItem.ordersSalesTotal = item.ordersSalesTotal || null
+              marketplaceOrderItem.ordersMarketingFeesTotal = item.ordersMarketingFeesTotal || null
+              marketplaceOrderItem.ordersLogisticsTotal = item.ordersLogisticsTotal || null
+              marketplaceOrderItem.marketplaceBonus = item.marketplaceBonus
+              marketplaceOrderItem.marketplaceBonusSeller = item.marketplaceBonusSeller
+              marketplaceOrderItem.shippingFeeDiscountMarketplace = item.shippingFeeDiscountMarketplace
+              marketplaceOrderItem.shippingFeeDiscountSeller = item.shippingFeeDiscountSeller
+              marketplaceOrderItem.promotionalChargesFlexiCombo = item.promotionalChargesFlexiCombo
+              marketplaceOrderItem.autoShippingSubsidyMarketplace = item.autoShippingSubsidyMarketplace
+              marketplaceOrderItem.originalShippingFee = item.originalShippingFee
+              marketplaceOrderItem.taxAmount = item.taxAmount
+
+              marketplaceOrderItems.push({ ...marketplaceOrderItem })
+
+              if (foundVariation?.primaryUnitValue)
+                orderTotalWeight += parseFloat(foundVariation.primaryUnitValue.toFixed(3)) * item.qty || 0
+            }
 
-                            variation.reserveQty -= item.qty
-                            variation.qty += item.qty
+            if (existingMarketplaceOrder) {
+              let existingOrderItems: MarketplaceOrderItem[] = []
+              existingOrderItems = existingMarketplaceOrder.marketplaceOrderItems
 
-                            variation = await tx.getRepository(MarketplaceProductVariation).save(variation)
-                          })
-                        )
-                      }
-                    }
-                  })
-                )
+              existingOrderItems = await checkUpdateItemId(existingOrderItems, marketplaceOrderItems)
 
-                await tx.getRepository(MarketplaceOrderItem).delete(nonMatchedOrderItems)
-              }
+              if (existingMarketplaceOrder.isSplitted) {
+                marketplaceOrderItems = existingOrderItems.filter(
+                  itm => itm.name == item.name && itm.marketplaceProductVariation.variationId == item.variationId
+                )
 
-              if (!cancelStatuses.includes(marketplaceOrder.status)) {
-                existingOrderItems = await Promise.all(
-                  marketplaceOrderItems.map(async item => {
-                    const matchedOrderItem = existingOrderItems.find(
+                marketplaceOrderItems = marketplaceOrderItems.map(marketplaceOrderitem => {
+                  return {
+                    ...marketplaceOrderitem,
+                    status: order.status,
+                    trackingCode: order.trackingNo
+                  }
+                })
+              } else {
+                if (existingOrderItems.length > marketplaceOrderItems.length) {
+                  let nonMatchedOrderItems = []
+                  existingOrderItems.map(item => {
+                    const matchedOrderItem = marketplaceOrderItems.find(
                       itm =>
-                        itm.name == item.name &&
+                        itm.name === item.name &&
                         itm.marketplaceProductVariation.variationId == item.marketplaceProductVariation.variationId
                     )
-                    if (matchedOrderItem) {
-                      for (var foundVariation of foundVariations) {
+                    if (!matchedOrderItem) {
+                      nonMatchedOrderItems.push({ ...item })
+                    }
+                  })
+                  if (nonMatchedOrderItems.length > 0 && !cancelStatuses.includes(marketplaceOrder.status)) {
+                    await Promise.all(
+                      nonMatchedOrderItems.map(async item => {
+                        let foundVariation = foundVariations.find(fv => fv.sku == item.marketplaceProductVariation.sku)
                         if (foundVariation.sku) {
-                          let allVariations: MarketplaceProductVariation[] = await tx
-                            .getRepository(MarketplaceProductVariation)
-                            .find({
-                              where: { domain: foundVariation.domain, sku: foundVariation.sku },
-                              relations: ['domain', 'marketplaceProduct', 'marketplaceProduct.marketplaceStore']
-                            })
-
-                          let activeVariations: MarketplaceProductVariation[] = allVariations.filter(
-                            variation => variation.marketplaceProduct.marketplaceStore.status != 'TERMINATED'
-                          )
+                          await updateQtyAndReserveQty(tx, foundVariation, marketplaceOrder, item.qty * -1)
+                        }
+                      })
+                    )
+
+                    await tx.getRepository(MarketplaceOrderItem).delete(nonMatchedOrderItems)
+                  }
 
-                          await Promise.all(
-                            activeVariations.map(async variation => {
-                              if (!existingMarketplaceOrder?.releaseOrderId && matchedOrderItem.qty - item.qty != 0) {
-                                await calculateReserveQtyForBundle(
-                                  tx,
-                                  variation,
-                                  marketplaceOrder.domain,
-                                  matchedOrderItem.qty - item.qty
-                                )
-                              }
-
-                              variation.reserveQty = existingMarketplaceOrder?.releaseOrderId
-                                ? variation.reserveQty
-                                : variation.reserveQty - item.qty + matchedOrderItem.qty
-
-                              variation.qty = existingMarketplaceOrder?.releaseOrderId
-                                ? variation.qty
-                                : variation.qty + item.qty - matchedOrderItem.qty
-
-                              variation = await tx.getRepository(MarketplaceProductVariation).save(variation)
-                            })
+                  if (!cancelStatuses.includes(marketplaceOrder.status)) {
+                    existingOrderItems = await Promise.all(
+                      marketplaceOrderItems.map(async item => {
+                        const matchedOrderItem = existingOrderItems.find(
+                          itm =>
+                            itm.name == item.name &&
+                            itm.marketplaceProductVariation.variationId == item.marketplaceProductVariation.variationId
+                        )
+                        if (matchedOrderItem) {
+                          foundVariation = foundVariations.find(
+                            fv => fv.variationId == matchedOrderItem.marketplaceProductVariation.variationId
                           )
+                          if (foundVariation.sku) {
+                            await updateQtyAndReserveQty(
+                              tx,
+                              foundVariation,
+                              marketplaceOrder,
+                              item.qty,
+                              matchedOrderItem.qty,
+                              existingMarketplaceOrder
+                            )
+                          }
+                          return {
+                            ...matchedOrderItem,
+                            ...item,
+                            updater: user
+                          }
                         }
-                      }
-                      return {
-                        ...matchedOrderItem,
-                        ...item,
-                        updater: user
-                      }
-                    }
-                  })
-                )
-              }
-            } else {
-              if (!cancelStatuses.includes(marketplaceOrder.status)) {
-                existingOrderItems = await Promise.all(
-                  marketplaceOrderItems.map(async item => {
-                    const matchedOrderItem = existingOrderItems.find(
-                      itm =>
-                        itm.name == item.name &&
-                        itm.marketplaceProductVariation.variationId == item.marketplaceProductVariation.variationId
+                      })
                     )
-                    if (matchedOrderItem) {
-                      for (var foundVariation of foundVariations) {
-                        if (foundVariation.sku) {
-                          let allVariations: MarketplaceProductVariation[] = await tx
-                            .getRepository(MarketplaceProductVariation)
-                            .find({
-                              where: { domain: foundVariation.domain, sku: foundVariation.sku },
-                              relations: ['domain', 'marketplaceProduct', 'marketplaceProduct.marketplaceStore']
-                            })
-
-                          let activeVariations: MarketplaceProductVariation[] = allVariations.filter(
-                            variation => variation.marketplaceProduct.marketplaceStore.status != 'TERMINATED'
+                  }
+                } else {
+                  if (!cancelStatuses.includes(marketplaceOrder.status)) {
+                    existingOrderItems = await Promise.all(
+                      marketplaceOrderItems.map(async item => {
+                        const matchedOrderItem = existingOrderItems.find(
+                          itm =>
+                            itm.name == item.name &&
+                            itm.marketplaceProductVariation.variationId == item.marketplaceProductVariation.variationId
+                        )
+                        if (matchedOrderItem) {
+                          foundVariation = foundVariations.find(
+                            fv => fv.variationId == matchedOrderItem.marketplaceProductVariation.variationId
                           )
-
-                          await Promise.all(
-                            activeVariations.map(async variation => {
-                              if (!existingMarketplaceOrder?.releaseOrderId && matchedOrderItem.qty - item.qty != 0) {
-                                await calculateReserveQtyForBundle(
-                                  tx,
-                                  variation,
-                                  marketplaceOrder.domain,
-                                  matchedOrderItem.qty - item.qty
-                                )
-                              }
-
-                              variation.reserveQty = existingMarketplaceOrder?.releaseOrderId
-                                ? variation.reserveQty
-                                : variation.reserveQty - item.qty + matchedOrderItem.qty
-
-                              variation.qty = existingMarketplaceOrder?.releaseOrderId
-                                ? variation.qty
-                                : variation.qty + item.qty - matchedOrderItem.qty
-
-                              variation = await tx.getRepository(MarketplaceProductVariation).save(variation)
-                            })
+                          if (foundVariation.sku) {
+                            await updateQtyAndReserveQty(
+                              tx,
+                              foundVariation,
+                              marketplaceOrder,
+                              item.qty,
+                              matchedOrderItem.qty,
+                              existingMarketplaceOrder
+                            )
+                          }
+                          return {
+                            ...matchedOrderItem,
+                            ...item,
+                            updater: user
+                          }
+                        } else {
+                          let foundVariation = foundVariations.find(
+                            fv => (fv.sku = item.marketplaceProductVariation.sku)
                           )
+                          if (foundVariation.sku) {
+                            await updateQtyAndReserveQty(tx, foundVariation, marketplaceOrder, item.qty)
+                          }
+                          return {
+                            ...item,
+                            updater: user
+                          }
                         }
-                      }
-                      return {
-                        ...matchedOrderItem,
-                        ...item,
-                        updater: user
-                      }
-                    } else {
-                      for (var foundVariation of foundVariations) {
-                        if (foundVariation.sku) {
-                          let allVariations: MarketplaceProductVariation[] = await tx
-                            .getRepository(MarketplaceProductVariation)
-                            .find({
-                              where: { domain: foundVariation.domain, sku: foundVariation.sku },
-                              relations: ['domain', 'marketplaceProduct', 'marketplaceProduct.marketplaceStore']
-                            })
-
-                          let activeVariations: MarketplaceProductVariation[] = allVariations.filter(
-                            variation => variation.marketplaceProduct.marketplaceStore.status != 'TERMINATED'
-                          )
+                      })
+                    )
+                  }
+                }
 
-                          await Promise.all(
-                            activeVariations.map(async variation => {
-                              await calculateReserveQtyForBundle(tx, variation, marketplaceOrder.domain, item.qty)
+                marketplaceOrderItems = existingOrderItems
 
-                              variation.reserveQty += item.qty
+                if (order?.orderShipping) {
+                  savedMarketplaceOrderShipping.totalWeight = orderTotalWeight
 
-                              if (variation.qty - item.qty >= 0) {
-                                variation.qty -= item.qty
-                              }
+                  if (marketplaceStore.eTrax) delete savedMarketplaceOrderShipping.trackingNo
 
-                              variation = await tx.getRepository(MarketplaceProductVariation).save(variation)
-                            })
-                          )
-                        }
-                      }
-                      return {
-                        ...item,
-                        updater: user
-                      }
-                    }
-                  })
-                )
+                  savedMarketplaceOrderShipping = await tx
+                    .getRepository(MarketplaceOrderShipping)
+                    .save(savedMarketplaceOrderShipping)
+                }
               }
-            }
+            } else {
+              if (!cancelStatuses.includes(marketplaceOrder.status)) {
+                for (var foundVariation of foundVariations) {
+                  if (foundVariation.sku) {
+                    let item = order.orderItems.find(e => e.variationId == foundVariation.variationId)
+                    await updateQtyAndReserveQty(tx, foundVariation, marketplaceOrder, item.qty)
+                  }
 
-            marketplaceOrderItems = existingOrderItems
+                  if (order?.orderShipping) {
+                    savedMarketplaceOrderShipping.totalWeight = orderTotalWeight
+                    if (marketplaceStore.eTrax) delete savedMarketplaceOrderShipping.trackingNo
 
-            if (order?.orderShipping) {
-              savedMarketplaceOrderShipping.totalWeight = orderTotalWeight
-              savedMarketplaceOrderShipping = await tx
-                .getRepository(MarketplaceOrderShipping)
-                .save(savedMarketplaceOrderShipping)
+                    savedMarketplaceOrderShipping = await tx
+                      .getRepository(MarketplaceOrderShipping)
+                      .save(savedMarketplaceOrderShipping)
+                  }
+                }
+              }
             }
-          }
-        } else {
-          if (!cancelStatuses.includes(marketplaceOrder.status)) {
-            for (var foundVariation of foundVariations) {
-              if (foundVariation.sku) {
-                let allVariations: MarketplaceProductVariation[] = await tx
-                  .getRepository(MarketplaceProductVariation)
-                  .find({
-                    where: { domain: foundVariation.domain, sku: foundVariation.sku },
-                    relations: ['domain', 'marketplaceProduct', 'marketplaceProduct.marketplaceStore']
-                  })
 
-                let activeVariations: MarketplaceProductVariation[] = allVariations.filter(
-                  variation => variation.marketplaceProduct.marketplaceStore.status != 'TERMINATED'
-                )
-                let item = order.orderItems.find(e => e.variationId == foundVariation.variationId)
-                await Promise.all(
-                  activeVariations.map(async variation => {
-                    await calculateReserveQtyForBundle(tx, variation, marketplaceOrder.domain, item.qty)
+            await tx.getRepository(MarketplaceOrder).save(marketplaceOrder)
+            await tx.getRepository(MarketplaceOrderItem).save(marketplaceOrderItems)
 
-                    variation.reserveQty += item.qty
+            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 }
+                })
 
-                    if (variation.qty - item.qty >= 0) {
-                      variation.qty -= item.qty
-                    }
+              let product: Product = await tx.getRepository(Product).findOne({
+                where: { domain: marketplaceStore.domain, sku: marketplaceProductVariation.sku, deletedAt: IsNull() },
+                relations: ['productDetails']
+              })
 
-                    variation = await tx.getRepository(MarketplaceProductVariation).save(variation)
-                  })
-                )
+              let productBundle: ProductBundle
+              if (!product) {
+                productBundle = await tx.getRepository(ProductBundle).findOne({
+                  where: { domain: marketplaceStore.domain, sku: marketplaceProductVariation.sku },
+                  relations: ['productBundleSettings', 'productBundleSettings.product']
+                })
               }
 
-              if (order?.orderShipping) {
-                savedMarketplaceOrderShipping.totalWeight = orderTotalWeight
-                savedMarketplaceOrderShipping = await tx
-                  .getRepository(MarketplaceOrderShipping)
-                  .save(savedMarketplaceOrderShipping)
+              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)
+                }
               }
             }
-          }
-        }
-
-        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)
+            if (i == marketplaceOrders.length - 1) {
+              lastOrderId = order.name
+            }
+          } catch (e) {
+            if (scheduler) {
+              logger.error(`Order no: ${marketplaceOrders[i]}: ${e}`)
             } 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)
+              throw new Error(e)
             }
           }
-        }
-
-        if (i == marketplaceOrders.length - 1) {
-          lastOrderId = order.name
-        }
+        })
       }
 
       if (more) page++
@@ -770,56 +686,85 @@ export const syncMarketplaceOrder = {
         hasMore = more
       }
 
-      await Promise.all(
-        payoutDateList.map(async item => {
-          await tx.getRepository(MarketplaceOrder).update(
-            {
-              orderNo: item.orderNo
-            },
-            {
-              payoutDate: item.payoutDate
-            }
-          )
-        })
-      )
+      await getConnection().transaction(async tx => {
+        await Promise.all(
+          payoutDateList.map(async item => {
+            await tx.getRepository(MarketplaceOrder).update(
+              {
+                orderNo: item.orderNo
+              },
+              {
+                payoutDate: item.payoutDate
+              }
+            )
+          })
+        )
+      })
     }
     return true
   }
 }
 
-async function calculateReserveQtyForBundle(tx, variation, domain, qty, operator = '+') {
+async function updateQtyAndReserveQtyBundle(
+  tx,
+  variation,
+  domain,
+  qty,
+  marketplaceOrder,
+  existingMarketplaceOrder = null,
+  matchedOrderItemQty = null
+) {
+  let statusAllowed = RESERVE_QTY_ORDER_STATUSES[marketplaceOrder.marketplaceStore.platform.toUpperCase()].includes(
+    marketplaceOrder.status
+  )
+  let existingStatusNotAllowed = existingMarketplaceOrder
+    ? !RESERVE_QTY_ORDER_STATUSES[existingMarketplaceOrder.marketplaceStore.platform.toUpperCase()].includes(
+        existingMarketplaceOrder.status
+      )
+    : false
   const productBundle: ProductBundle = await tx.getRepository(ProductBundle).findOne({
-    where: { sku: variation.sku, domain }
+    where: { sku: variation.sku, domain },
+    relations: ['productBundleSettings', 'productBundleSettings.product']
   })
 
   if (productBundle) {
-    const productBundleSettings: ProductBundleSetting[] = await tx.getRepository(ProductBundleSetting).find({
-      where: { productBundle },
-      relations: ['productBundle', 'product']
-    })
-
-    for (let setting of productBundleSettings) {
-      const product: Product = await tx.getRepository(Product).findOne({
-        where: { id: setting.product.id }
-      })
-
+    for (let setting of productBundle.productBundleSettings) {
       const mpvs: MarketplaceProductVariation[] = await tx.getRepository(MarketplaceProductVariation).find({
-        where: { domain, sku: product.sku },
+        where: { domain, sku: setting.product.sku },
         relations: ['domain']
       })
 
       for (let mpv of mpvs) {
-        if (operator === '+') {
-          mpv.reserveQty += setting.bundleQty * qty
+        let updatedReserveQty = 0
+        let updatedQty = 0
+
+        if (existingMarketplaceOrder) {
+          if (
+            (statusAllowed && existingStatusNotAllowed) ||
+            (cancelStatuses.includes(marketplaceOrder.status) && !existingStatusNotAllowed)
+          ) {
+            updatedReserveQty += setting.bundleQty * qty
+          }
+
+          updatedQty += setting.bundleQty * qty - matchedOrderItemQty * setting.bundleQty
+        } else {
+          if (statusAllowed && qty > 0) {
+            updatedReserveQty += setting.bundleQty * qty
+          }
+
           if (mpv.qty - setting.bundleQty * qty >= 0) {
-            mpv.qty -= setting.bundleQty * qty
+            updatedQty += setting.bundleQty * qty
           }
         }
-        if (operator === '-') {
-          mpv.reserveQty -= setting.bundleQty * qty
-          mpv.qty += setting.bundleQty * qty
-        }
-        await tx.getRepository(MarketplaceProductVariation).save(mpv)
+        await tx
+          .createQueryBuilder()
+          .update(MarketplaceProductVariation)
+          .set({
+            qty: () => `COALESCE("qty", 0) - ${updatedQty}`,
+            reserveQty: () => `COALESCE("reserve_qty", 0) + ${updatedReserveQty}`
+          })
+          .where('id = :id', { id: mpv.id })
+          .execute()
       }
     }
   }
@@ -827,14 +772,87 @@ async function calculateReserveQtyForBundle(tx, variation, domain, qty, operator
 
 function checkUpdateItemId(existingOrderItems, marketplaceOrderItems) {
   for (let item of marketplaceOrderItems) {
-    let existingItem = existingOrderItems.find(i => i.name ==  item.name)
+    let existingItem = existingOrderItems.find(i => i.name == item.name)
 
     if (!existingItem) {
-      let existingItemByVariation = existingOrderItems.find(i => i.marketplaceProductVariation.id ==  item.marketplaceProductVariation.id)
-      existingOrderItems = existingOrderItems.filter(i => i != existingItemByVariation)
-      existingItemByVariation.name = item.name
-      existingOrderItems.push(existingItemByVariation)
+      let existingItemByVariation = existingOrderItems.find(
+        i => i.marketplaceProductVariation.id == item.marketplaceProductVariation.id
+      )
+      if (existingItemByVariation) {
+        existingOrderItems = existingOrderItems.filter(i => i != existingItemByVariation)
+        existingItemByVariation.name = item.name
+        existingOrderItems.push(existingItemByVariation)
+      }
     }
   }
   return existingOrderItems
-}
+}
+
+async function updateQtyAndReserveQty(
+  tx,
+  foundVariation,
+  marketplaceOrder,
+  qty,
+  matchedOrderItemQty = null,
+  existingMarketplaceOrder = null
+) {
+  let roCreated = existingMarketplaceOrder ? existingMarketplaceOrder?.realaseOrderId : false
+  let existingStatusNotAllowed = existingMarketplaceOrder
+    ? !RESERVE_QTY_ORDER_STATUSES[existingMarketplaceOrder.marketplaceStore.platform.toUpperCase()].includes(
+        existingMarketplaceOrder.status
+      )
+    : false
+  let activeVariations: MarketplaceProductVariation[] = await tx
+    .getRepository(MarketplaceProductVariation)
+    .createQueryBuilder('mpv')
+    .innerJoin('mpv.marketplaceProduct', 'marketplaceProduct')
+    .innerJoin('marketplaceProduct.marketplaceStore', 'marketplaceStore')
+    .where('mpv.domain_id = :domainId', { domainId: marketplaceOrder.domain.id })
+    .andWhere('mpv.sku = :sku', { sku: foundVariation.sku })
+    .andWhere(`marketplaceStore.status != 'TERMINATED'`)
+    .getMany()
+
+  let statusAllowed = RESERVE_QTY_ORDER_STATUSES[marketplaceOrder.marketplaceStore.platform.toUpperCase()].includes(
+    marketplaceOrder.status
+  )
+
+  if (existingMarketplaceOrder && !roCreated) {
+    await updateQtyAndReserveQtyBundle(
+      tx,
+      foundVariation,
+      marketplaceOrder.domain,
+      qty,
+      marketplaceOrder,
+      existingMarketplaceOrder,
+      matchedOrderItemQty
+    )
+  } else {
+    await updateQtyAndReserveQtyBundle(tx, foundVariation, marketplaceOrder.domain, qty, marketplaceOrder)
+  }
+  await Promise.all(
+    activeVariations.map(async variation => {
+      let updatedReserveQty = 0
+      let updatedQty = 0
+      if (matchedOrderItemQty) {
+        updatedReserveQty = roCreated ? 0 : statusAllowed && existingStatusNotAllowed ? qty : qty - matchedOrderItemQty
+        updatedQty = roCreated ? 0 : qty - matchedOrderItemQty
+      } else {
+        if ((statusAllowed && qty > 0) || qty < 0) {
+          updatedReserveQty = qty
+        }
+        if (variation.qty - qty >= 0) {
+          updatedQty = qty
+        }
+      }
+      await tx
+        .createQueryBuilder()
+        .update(MarketplaceProductVariation)
+        .set({
+          qty: () => `COALESCE("qty", 0) - ${updatedQty}`,
+          reserveQty: () => `COALESCE("reserve_qty", 0) + ${updatedReserveQty}`
+        })
+        .where('id = :id', { id: variation.id })
+        .execute()
+    })
+  )
+}