@things-factory/marketplace-base 4.1.27 → 4.1.28

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

@@ -1,21 +1,10 @@
-import { getRepository, IsNull } from 'typeorm'
-import uuid from 'uuid/v4'
+import { getRepository } from 'typeorm'
 
 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 { Product, ProductBundle, ProductBundleSetting } from '@things-factory/product-base'
 import { Domain } from '@things-factory/shell'
 
-import {
-  MarketplaceOrder,
-  MarketplaceOrderItem,
-  MarketplaceOrderShipping,
-  MarketplaceOrderShippingItem,
-  MarketplaceProductVariation
-} from '../../../entities'
-import { NoGenerator } from '../../../utils'
+import { syncMarketplaceOrder } from './sync-marketplace-order'
 
 export const syncAllMarketplaceOrder = {
   async syncAllMarketplaceOrder(_: any, { companyDomainId, fromDate, toDate, blackListStores }, context: any) {
@@ -37,847 +26,9 @@ export const syncAllMarketplaceOrder = {
 
     for (var i = 0; i < whiteListStores?.length; i++) {
       const marketplaceStore = whiteListStores[i]
-      const domain: Domain = marketplaceStore.domain
-
-      let page: number = 0
-      let hasMorePage: boolean = true
-      let lastOrderId: string
-      var limit: number = 100
-      const cancelStatuses: string[] = ['cancelled', 'canceled']
-      const disallowCancelStatuses: string[] = ['CANCELLED', 'PENDING_CANCEL']
-
-      while (hasMorePage) {
-        const { results: marketplaceOrders, more } = await StoreAPI.getStoreOrders(marketplaceStore, {
-          fromDate,
-          toDate,
-          pagination: { page, limit },
-          lastOrderId
-        })
-
-        if (marketplaceOrders?.length > 0) {
-          for (var m = 0; m < marketplaceOrders.length; m++) {
-            try {
-              var order = marketplaceOrders[m]
-
-              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 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
-                }
-
-                if (
-                  !marketplaceOrder?.releaseOrderId &&
-                  cancelStatuses.includes(marketplaceOrder.status) &&
-                  !cancelStatuses.includes(existingMarketplaceOrder.status)
-                ) {
-                  for (let item of marketplaceOrder.marketplaceOrderItems) {
-                    let foundVariations = await getRepository(MarketplaceProductVariation).find({
-                      where: {
-                        domain: marketplaceOrder.domain,
-                        sku: item.marketplaceProductVariation.sku
-                      },
-                      relations: ['domain', 'marketplaceProduct', 'marketplaceProduct.marketplaceStore']
-                    })
-
-                    let activeVariations: MarketplaceProductVariation[] = foundVariations.filter(
-                      variation =>
-                        variation.marketplaceProduct.marketplaceStore.status != 'TERMINATED' && variation.sku != null
-                    )
-
-                    await Promise.all(
-                      activeVariations.map(async variation => {
-                        await calculateReserveQtyForBundle(variation, marketplaceOrder.domain, item.qty, '-')
-
-                        variation.reserveQty -= item.qty
-                        variation.qty += item.qty
-                        await getRepository(MarketplaceProductVariation).save(variation)
-                      })
-                    )
-                  }
-                }
-                if (marketplaceOrder?.releaseOrderId) {
-                  const fulfillmentCenter: FulfillmentCenter = marketplaceOrder.fulfillmentCenter
-                  const centerId: string = fulfillmentCenter.centerId
-                  const warehouseDomain: Domain = await 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 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
-                      }
-
-                      await FulfillmentAPI.updateReleaseGoodDetails(fulfillmentCenter, {
-                        customerBizplaceId,
-                        releaseOrder: { ...patch },
-                        shippingOrder: null
-                      })
-                    }
-                  } else {
-                    let releaseOrder = Object.assign({}, releaseOrders[0])
-                    const foundMarketplaceOrderShipping: MarketplaceOrderShipping = await 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,
-                      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 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 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 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 getRepository(MarketplaceOrderShipping).save(
-                        marketplaceOrderShipping
-                      )
-                    }
-                  }
-                } else {
-                  if (marketplaceStore.eTrax) delete marketplaceOrderShipping.trackingNo
-
-                  savedMarketplaceOrderShipping = await 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 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 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 => {
-                          for (var foundVariation of foundVariations) {
-                            if (foundVariation.sku) {
-                              let allVariations: MarketplaceProductVariation[] = await 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(variation, marketplaceOrder.domain, item.qty, '-')
-
-                                  variation.reserveQty -= item.qty
-                                  variation.qty += item.qty
-
-                                  variation = await getRepository(MarketplaceProductVariation).save(variation)
-                                })
-                              )
-                            }
-                          }
-                        })
-                      )
-
-                      await 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) {
-                            for (var foundVariation of foundVariations) {
-                              if (foundVariation.sku) {
-                                let allVariations: MarketplaceProductVariation[] = await 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 => {
-                                    if (
-                                      !existingMarketplaceOrder?.releaseOrderId &&
-                                      matchedOrderItem.qty - item.qty != 0
-                                    ) {
-                                      await calculateReserveQtyForBundle(
-                                        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 getRepository(MarketplaceProductVariation).save(variation)
-                                  })
-                                )
-                              }
-                            }
-                            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 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 => {
-                                    if (
-                                      !existingMarketplaceOrder?.releaseOrderId &&
-                                      matchedOrderItem.qty - item.qty != 0
-                                    ) {
-                                      await calculateReserveQtyForBundle(
-                                        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 getRepository(MarketplaceProductVariation).save(variation)
-                                  })
-                                )
-                              }
-                            }
-                            return {
-                              ...matchedOrderItem,
-                              ...item,
-                              updater: user
-                            }
-                          } else {
-                            for (var foundVariation of foundVariations) {
-                              if (foundVariation.sku) {
-                                let allVariations: MarketplaceProductVariation[] = await 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(variation, marketplaceOrder.domain, item.qty)
-
-                                    variation.reserveQty += item.qty
-                                    if (variation.qty - item.qty >= 0) {
-                                      variation.qty -= item.qty
-                                    }
-                                    variation = await getRepository(MarketplaceProductVariation).save(variation)
-                                  })
-                                )
-                              }
-                            }
-                            return {
-                              ...item,
-                              updater: user
-                            }
-                          }
-                        })
-                      )
-                    }
-                  }
-
-                  marketplaceOrderItems = existingOrderItems
-
-                  if (order?.orderShipping) {
-                    savedMarketplaceOrderShipping.totalWeight = orderTotalWeight
-                    if (marketplaceStore.eTrax) delete savedMarketplaceOrderShipping.trackingNo
-
-                    savedMarketplaceOrderShipping = await getRepository(MarketplaceOrderShipping).save(
-                      savedMarketplaceOrderShipping
-                    )
-                  }
-                }
-              } else {
-                if (!cancelStatuses.includes(marketplaceOrder.status)) {
-                  for (var foundVariation of foundVariations) {
-                    if (foundVariation.sku) {
-                      let allVariations: MarketplaceProductVariation[] = await 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(variation, marketplaceOrder.domain, item.qty)
-                          variation.reserveQty += item.qty
-                          if (variation.qty - item.qty >= 0) {
-                            variation.qty -= item.qty
-                          }
-
-                          variation = await getRepository(MarketplaceProductVariation).save(variation)
-                        })
-                      )
-                    }
-
-                    if (order?.orderShipping) {
-                      savedMarketplaceOrderShipping.totalWeight = orderTotalWeight
-                      if (marketplaceStore.eTrax) delete savedMarketplaceOrderShipping.trackingNo
-
-                      savedMarketplaceOrderShipping = await getRepository(MarketplaceOrderShipping).save(
-                        savedMarketplaceOrderShipping
-                      )
-                    }
-                  }
-                }
-              }
-
-              await getRepository(MarketplaceOrder).save(marketplaceOrder)
-              await 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 getRepository(
-                  MarketplaceOrderShippingItem
-                ).find({
-                  where: { domain: marketplaceStore.domain, marketplaceOrderItem }
-                })
-
-                let product: Product = await getRepository(Product).findOne({
-                  where: { domain: marketplaceStore.domain, sku: marketplaceProductVariation.sku, deletedAt: IsNull() },
-                  relations: ['productDetails']
-                })
-
-                let productBundle: ProductBundle
-                if (!product) {
-                  productBundle = await 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 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 getRepository(MarketplaceOrderShippingItem).save(marketplaceOrderShippingItem)
-                  }
-                }
-              }
-
-              if (m == marketplaceOrders.length - 1) {
-                lastOrderId = order.name
-              }
-            } catch (e) {}
-          }
-
-          if (more) page++
-          hasMorePage = more
-        } else {
-          hasMorePage = false
-        }
-      }
-
-      if (marketplaceStore.platform === 'shopee') {
-        let pageNo: number = 0
-        let hasMore = true
-        let perPage: number = 100
-        var payoutDateList = []
-
-        while (hasMore) {
-          const { result: payoutDates, more } = await StoreAPI.getStoreOrderPayoutDates(marketplaceStore, {
-            fromDate,
-            toDate,
-            pagination: { page: pageNo, limit: perPage }
-          })
-
-          payoutDateList.push(...payoutDates)
-          if (more) pageNo++
-          hasMore = more
-        }
-
-        await Promise.all(
-          payoutDateList.map(async item => {
-            await getRepository(MarketplaceOrder).update(
-              {
-                orderNo: item.orderNo
-              },
-              {
-                payoutDate: item.payoutDate
-              }
-            )
-          })
-        )
-      }
+      syncMarketplaceOrder.syncMarketplaceOrder(_, { storeId: marketplaceStore.id, fromDate, toDate }, context)
     }
 
     return true
   }
 }
-
-async function calculateReserveQtyForBundle(variation, domain, qty, operator = '+') {
-  const productBundle: ProductBundle = await getRepository(ProductBundle).findOne({
-    where: { sku: variation.sku, domain }
-  })
-
-  if (productBundle) {
-    const productBundleSettings: ProductBundleSetting[] = await getRepository(ProductBundleSetting).find({
-      where: { productBundle },
-      relations: ['productBundle', 'product']
-    })
-
-    for (let setting of productBundleSettings) {
-      const product: Product = await getRepository(Product).findOne({
-        where: { id: setting.product.id }
-      })
-
-      const mpvs: MarketplaceProductVariation[] = await getRepository(MarketplaceProductVariation).find({
-        where: { domain, sku: product.sku },
-        relations: ['domain']
-      })
-
-      for (let mpv of mpvs) {
-        if (operator === '+') {
-          mpv.reserveQty += setting.bundleQty * qty
-          if (mpv.qty - setting.bundleQty * qty >= 0) {
-            mpv.qty -= setting.bundleQty * qty
-          }
-        }
-        if (operator === '-') {
-          mpv.reserveQty -= setting.bundleQty * qty
-          mpv.qty += setting.bundleQty * qty
-        }
-        await getRepository(MarketplaceProductVariation).save(mpv)
-      }
-    }
-  }
-}
-
-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
-      )
-      existingOrderItems = existingOrderItems.filter(i => i != existingItemByVariation)
-      existingItemByVariation.name = item.name
-      existingOrderItems.push(existingItemByVariation)
-    }
-  }
-  return existingOrderItems
-}