@things-factory/marketplace-base 8.0.0-beta.8 → 8.0.0

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

@@ -0,0 +1,940 @@
+import { getConnection, IsNull, SelectQueryBuilder } from 'typeorm'
+import { v4 as uuidv4 } from 'uuid'
+
+import { Bizplace, getCustomerBizplaces } from '@things-factory/biz-base'
+import { logger } from '@things-factory/env'
+import { FulfillmentAPI, FulfillmentCenter } from '@things-factory/integration-fulfillment'
+import { MarketplaceStore, MarketplaceTransporter, StoreAPI } from '@things-factory/integration-marketplace'
+import { Product, ProductBundle, ProductBundleSetting } from '@things-factory/product-base'
+import { Domain } from '@things-factory/shell'
+
+import { RESERVE_QTY_ORDER_STATUSES } from '../../../constants/reserve-qty-order-statuses'
+import {
+  MarketplaceOrder,
+  MarketplaceOrderItem,
+  MarketplaceOrderShipping,
+  MarketplaceOrderShippingItem,
+  MarketplaceProductVariation
+} from '../../../entities'
+import { NoGenerator } from '../../../utils'
+
+const cancelStatuses: string[] = [
+  'cancelled',
+  'canceled',
+  'failed',
+  'shipped_back_success',
+  'shipped_back',
+  'returned',
+  'to_return',
+  'refunded'
+]
+
+export const syncMarketplaceOrder = {
+  async syncMarketplaceOrder(
+    _: any,
+    { storeId, fromCreatedDate, toCreatedDate, scheduler = false },
+    context: ResolverContext
+  ) {
+    const { domain, user } = context.state
+
+    const marketplaceStore: MarketplaceStore = await StoreAPI.getMarketplaceStore(storeId)
+
+    let page: number = 0
+    let hasMorePage: boolean = true
+    let lastOrderId: string
+    var limit: number = 100
+    const disallowCancelStatuses: string[] = ['CANCELLED', 'PENDING_CANCEL']
+    let nextCursor: string
+
+    while (hasMorePage) {
+      const {
+        results: marketplaceOrders,
+        more,
+        cursor
+      } = await StoreAPI.getStoreOrders(marketplaceStore, {
+        fromCreatedDate,
+        toCreatedDate,
+        pagination: { page, limit },
+        lastOrderId,
+        nextCursor
+      })
+
+      nextCursor = cursor
+
+      if (marketplaceOrders?.length == 0) throw new Error('There is no order available to sync')
+      for (var i = 0; i < marketplaceOrders.length; i++) {
+        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(',')
+              }
+
+              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']
+            }
+
+            const marketplaceTransporter: MarketplaceTransporter = await tx
+              .getRepository(MarketplaceTransporter)
+              .findOne({
+                where: { marketplaceStore: { id: marketplaceStore.id } },
+                relations: ['pickupTransporter']
+              })
+
+            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: { id: marketplaceStore.domain.id },
+                name: order.name,
+                marketplaceStore: { id: marketplaceStore.id }
+              },
+              relations: [
+                'domain',
+                'fulfillmentCenter',
+                'marketplaceOrderItems',
+                'marketplaceOrderItems.marketplaceOrderShippingItems',
+                'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping',
+                'marketplaceOrderItems.marketplaceProductVariation',
+                'marketplaceStore'
+              ]
+            })
+
+            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
+              }
+
+              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
+                  )
+                }
+              }
+
+              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
+                })
+
+                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: { id: marketplaceStore.domain.id }, subOrderNoRef: releaseOrder.refNo2 }
+                      })
+                    let patch = {
+                      id: releaseOrder.id,
+                      marketplaceOrderStatus: marketplaceOrder.status,
+                      trackingNo: _extractTrackingNo(
+                        foundMarketplaceOrderShipping.ownTrackingNo,
+                        foundMarketplaceOrderShipping.trackingNo
+                      ),
+                      transporter: dropPickProvider ? dropPickProvider : marketplaceOrder.shippingProvider
+                    }
+
+                    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: { id: marketplaceStore.domain.id }, orderNoRef: releaseOrder.refNo }
+                    })
+                  let patch = {
+                    id: releaseOrder.id,
+                    marketplaceOrderStatus: marketplaceOrder.status,
+                    trackingNo: _extractTrackingNo(
+                      foundMarketplaceOrderShipping.ownTrackingNo,
+                      foundMarketplaceOrderShipping.trackingNo
+                    ),
+                    transporter: dropPickProvider ? dropPickProvider : marketplaceOrder.shippingProvider
+                  }
+
+                  await FulfillmentAPI.updateReleaseGoodDetails(fulfillmentCenter, {
+                    customerBizplaceId,
+                    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: { id: domain.id },
+                        marketplaceStore: { id: marketplaceStore.id },
+                        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: 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)
+              }
+            }
+
+            let orderTotalWeight: number = 0
+            let foundVariations = []
+            for (var j = 0; j < order.orderItems.length; j++) {
+              var item = order.orderItems[j]
+
+              const qb: SelectQueryBuilder<MarketplaceProductVariation> = await tx
+                .getRepository(MarketplaceProductVariation)
+                .createQueryBuilder('mpv')
+                .leftJoin('mpv.marketplaceProduct', 'mp')
+                .leftJoin('mp.marketplaceStore', 'ms')
+                .where('mpv.domain_id = :domainId')
+                .andWhere('mpv.variation_id = :variationId')
+                .andWhere('ms.id = :marketplaceStoreId')
+                .setParameters({
+                  domainId: marketplaceStore.domain.id,
+                  variationId: item.variationId,
+                  marketplaceStoreId: marketplaceStore.id
+                })
+
+              let foundVariation: MarketplaceProductVariation = await qb.getOne()
+
+              if (foundVariation) {
+                foundVariations.push(foundVariation)
+              } else {
+                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
+            }
+
+            if (existingMarketplaceOrder) {
+              let existingOrderItems: MarketplaceOrderItem[] = []
+              existingOrderItems = existingMarketplaceOrder.marketplaceOrderItems
+
+              existingOrderItems = await checkUpdateItemId(existingOrderItems, marketplaceOrderItems)
+
+              if (existingMarketplaceOrder.isSplitted) {
+                marketplaceOrderItems = existingOrderItems.filter(
+                  itm => itm.name == item.name && itm.marketplaceProductVariation.variationId == item.variationId
+                )
+
+                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.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 => {
+                        let foundVariation = foundVariations.find(fv => fv.sku == item.marketplaceProductVariation.sku)
+                        if (foundVariation.sku) {
+                          await updateQtyAndReserveQty(tx, foundVariation, marketplaceOrder, item.qty * -1)
+                        }
+                      })
+                    )
+
+                    await tx.getRepository(MarketplaceOrderItem).delete(nonMatchedOrderItems)
+                  }
+
+                  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
+                          }
+                        }
+                      })
+                    )
+                  }
+                } 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
+                          )
+                          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
+                          }
+                        }
+                      })
+                    )
+                  }
+                }
+
+                marketplaceOrderItems = existingOrderItems
+
+                if (order?.orderShipping) {
+                  savedMarketplaceOrderShipping.totalWeight = orderTotalWeight
+
+                  if (marketplaceStore.eTrax) delete savedMarketplaceOrderShipping.trackingNo
+
+                  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)
+                  }
+
+                  if (order?.orderShipping) {
+                    savedMarketplaceOrderShipping.totalWeight = orderTotalWeight
+                    if (marketplaceStore.eTrax) delete savedMarketplaceOrderShipping.trackingNo
+
+                    savedMarketplaceOrderShipping = await tx
+                      .getRepository(MarketplaceOrderShipping)
+                      .save(savedMarketplaceOrderShipping)
+                  }
+                }
+              }
+            }
+
+            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: { id: marketplaceStore.domain.id },
+                    marketplaceOrderItem: { id: marketplaceOrderItem.id }
+                  },
+                  relations: ['product']
+                })
+
+              let product: Product = await tx.getRepository(Product).findOne({
+                where: {
+                  domain: { id: marketplaceStore.domain.id },
+                  sku: marketplaceProductVariation.sku,
+                  deletedAt: IsNull()
+                },
+                relations: ['productDetails']
+              })
+
+              let productBundle: ProductBundle
+              if (!product) {
+                productBundle = await tx.getRepository(ProductBundle).findOne({
+                  where: { domain: { id: marketplaceStore.domain.id }, sku: marketplaceProductVariation.sku },
+                  relations: ['productBundleSettings', 'productBundleSettings.product']
+                })
+              }
+
+              if (!marketplaceOrder.isSplitted && !marketplaceOrder.releaseOrderId) {
+                if (
+                  existingMarketplaceOrderShippingItems?.length &&
+                  existingMarketplaceOrderShippingItems
+                    .map(e => {
+                      return e.product
+                    })
+                    .indexOf(null) != -1
+                ) {
+                  await tx.getRepository(MarketplaceOrderShippingItem).remove(existingMarketplaceOrderShippingItems)
+                }
+                if (
+                  (existingMarketplaceOrderShippingItems?.length &&
+                    existingMarketplaceOrderShippingItems
+                      .map(e => {
+                        return e.product
+                      })
+                      .indexOf(null) != -1) ||
+                  !existingMarketplaceOrderShippingItems?.length
+                ) {
+                  if (productBundle) {
+                    const productBundleSettings: ProductBundleSetting[] = productBundle.productBundleSettings
+                    let marketplaceOrderShippingItems: MarketplaceOrderShippingItem[] = []
+                    productBundleSettings.map(productBundleSetting => {
+                      let marketplaceOrderShippingItem: MarketplaceOrderShippingItem =
+                        new MarketplaceOrderShippingItem()
+                      marketplaceOrderShippingItem.name = uuidv4()
+                      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 = uuidv4()
+                    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
+            }
+          } catch (e) {
+            if (scheduler) {
+              logger.error(`Order no: ${marketplaceOrders[i].name}: ${e}`, e)
+            } else {
+              throw new Error(e)
+            }
+          }
+        })
+      }
+
+      if (more) page++
+      hasMorePage = more
+    }
+
+    try {
+      if (marketplaceStore.platform === 'shopee') {
+        let pageNo: number = 1
+        let hasMore = true
+        let perPage: number = 100
+        var payoutDateList = []
+
+        while (hasMore) {
+          const { result: payoutDates, more } = await StoreAPI.getStoreOrderPayoutDates(marketplaceStore, {
+            fromCreatedDate,
+            toCreatedDate,
+            pagination: { page: pageNo, limit: perPage }
+          })
+
+          payoutDateList.push(...payoutDates)
+          if (more) pageNo++
+          hasMore = more
+        }
+
+        await getConnection().transaction(async tx => {
+          await Promise.all(
+            payoutDateList.map(async item => {
+              await tx.getRepository(MarketplaceOrder).update(
+                {
+                  orderNo: item.orderNo
+                },
+                {
+                  payoutDate: item.payoutDate
+                }
+              )
+            })
+          )
+        })
+      }
+    } catch (e) {}
+    return true
+  }
+}
+
+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: { id: domain.id } },
+    relations: ['productBundleSettings', 'productBundleSettings.product']
+  })
+
+  if (productBundle) {
+    for (let setting of productBundle.productBundleSettings) {
+      const mpvs: MarketplaceProductVariation[] = await tx.getRepository(MarketplaceProductVariation).find({
+        where: { domain: { id: domain.id }, sku: setting.product.sku },
+        relations: ['domain']
+      })
+
+      for (let mpv of mpvs) {
+        let updatedReserveQty = 0
+        let updatedQty = 0
+
+        if (existingMarketplaceOrder) {
+          if (
+            ((statusAllowed && existingStatusNotAllowed) ||
+              (cancelStatuses.includes(marketplaceOrder.status) && !existingStatusNotAllowed)) &&
+            marketplaceOrder.marketplaceStore.reserveEnabled
+          ) {
+            updatedReserveQty += setting.bundleQty * qty
+          }
+
+          updatedQty += setting.bundleQty * qty - matchedOrderItemQty * setting.bundleQty
+        } else {
+          if (statusAllowed && qty > 0 && marketplaceOrder.marketplaceStore.reserveEnabled) {
+            updatedReserveQty += setting.bundleQty * qty
+          }
+
+          if (mpv.qty - setting.bundleQty * qty >= 0) {
+            updatedQty += setting.bundleQty * qty
+          }
+        }
+        await tx
+          .createQueryBuilder()
+          .update(MarketplaceProductVariation)
+          .set({
+            qty: () => `COALESCE("qty", 0) - ${updatedQty}`,
+            reserveQty: () => `COALESCE("reserve_qty", 0) + ${updatedReserveQty}`
+          })
+          .where('id = :id', { id: mpv.id })
+          .execute()
+      }
+    }
+  }
+}
+
+function checkUpdateItemId(existingOrderItems, marketplaceOrderItems) {
+  for (let item of marketplaceOrderItems) {
+    let existingItem = existingOrderItems.find(i => i.name == item.name)
+
+    if (!existingItem) {
+      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) {
+        if (marketplaceOrder.marketplaceStore.reserveEnabled) {
+          updatedReserveQty = roCreated
+            ? 0
+            : statusAllowed && existingStatusNotAllowed
+              ? qty
+              : qty - matchedOrderItemQty
+        }
+        updatedQty = roCreated ? 0 : qty - matchedOrderItemQty
+      } else {
+        if (((statusAllowed && qty > 0) || qty < 0) && marketplaceOrder.marketplaceStore.reserveEnabled) {
+          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()
+    })
+  )
+}
+
+function _extractTrackingNo(ownTrackingNo, trackingNo): string {
+  let finalTrackingNo: string = trackingNo == '[]' || !trackingNo ? ownTrackingNo : trackingNo
+
+  // For lazada order, tracking code is passed as JSON
+  // which will produce error in manifest stage later on
+  // solution: extract the tracking code as follows:
+  if (finalTrackingNo?.includes('tracking_code')) {
+    let extratedTrackingNo: any[] = JSON.parse(finalTrackingNo)
+    finalTrackingNo = extratedTrackingNo
+      .reduce((trackingNos, item) => {
+        if (!trackingNos.find(num => num === item.tracking_code)) trackingNos.push(item.tracking_code)
+        return trackingNos
+      }, [])
+      .join(', ')
+  }
+
+  return finalTrackingNo
+}