@things-factory/marketplace-base 8.0.7 → 9.0.0-beta.12

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

@@ -1,940 +0,0 @@
-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
-}