@things-factory/marketplace-base 4.0.9 → 4.0.13

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

@@ -39,6 +39,8 @@ export const syncAllMarketplaceOrder = {
       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, {
@@ -50,83 +52,87 @@ export const syncAllMarketplaceOrder = {
 
         if (marketplaceOrders?.length > 0) {
           for (var m = 0; m < marketplaceOrders.length; m++) {
-            var order = marketplaceOrders[m]
-
-            let marketplaceOrderItems = []
-            let tracking_code = ''
-            let deliveryProvider: 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(',')
-              }
+            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
-              })
+                const shippingProviderInfo: any = {}
+                order.shippingProvider.split(', ').forEach(s => {
+                  var [key, value] = s.split(': ')
+                  shippingProviderInfo[key] = value
+                })
 
-              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
-
-            const existingMarketplaceOrder: MarketplaceOrder = await getRepository(MarketplaceOrder).findOne({
-              where: { domain: marketplaceStore.domain, name: order.name },
-              relations: [
-                'domain',
-                'fulfillmentCenter',
-                'marketplaceOrderItems',
-                'marketplaceOrderItems.marketplaceProductVariation',
-                'marketplaceOrderItems.marketplaceOrderShipping'
-              ]
-            })
-
-            if (existingMarketplaceOrder) {
-              let otherInfoJSON: any = {}
-
-              if (existingMarketplaceOrder?.otherInfoJSON && deliveryProvider) {
-                otherInfoJSON = JSON.parse(existingMarketplaceOrder.otherInfoJSON)
-                otherInfoJSON.shippingProvider = deliveryProvider
+                dropPickProvider = shippingProviderInfo?.Pickup
+                  ? shippingProviderInfo['Pickup']
+                  : shippingProviderInfo['Drop-off']
+                deliveryProvider = shippingProviderInfo['Delivery']
               }
 
-              marketplaceOrder = {
-                ...existingMarketplaceOrder,
-                ...marketplaceOrder,
-                otherInfoJSON: otherInfoJSON ? JSON.stringify(otherInfoJSON) : null,
-                updater: user
-              }
+              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.marketplaceProductVariation',
+                  'marketplaceOrderItems.marketplaceOrderShipping'
+                ]
+              })
+
+              if (existingMarketplaceOrder) {
+                let otherInfoJSON: any = {}
 
-              const cancelStatuses: string[] = ['cancelled', 'canceled']
-              const disallowCancelStatuses: string[] = ['CANCELLED', 'PENDING_CANCEL']
+                if (existingMarketplaceOrder?.otherInfoJSON && deliveryProvider) {
+                  otherInfoJSON = JSON.parse(existingMarketplaceOrder.otherInfoJSON)
+                  otherInfoJSON.shippingProvider = deliveryProvider
+                }
 
-              if (cancelStatuses.includes(marketplaceOrder.status) && marketplaceOrder?.releaseOrderId) {
-                if (existingMarketplaceOrder.isSplitted) {
+                if (marketplaceOrder?.releaseOrderId) {
                   const fulfillmentCenter: FulfillmentCenter = marketplaceOrder.fulfillmentCenter
                   const centerId: string = fulfillmentCenter.centerId
-                  const warehouseDomain: Domain = await getRepository(Domain).findOne({
-                    where: { subdomain: centerId }
-                  })
+                  const warehouseDomain: Domain = await tx
+                    .getRepository(Domain)
+                    .findOne({ where: { subdomain: centerId } })
                   const customerBizplaces: Bizplace[] = await getCustomerBizplaces(warehouseDomain)
                   const customerBizplaceId: string = customerBizplaces[0].id
 
@@ -135,236 +141,294 @@ export const syncAllMarketplaceOrder = {
                     refNo: marketplaceOrder.orderNo
                   })
 
-                  releaseOrders = releaseOrders.filter(function (order) {
-                    return !disallowCancelStatuses.includes(order.status)
-                  })
-
-                  if (releaseOrders?.length) {
-                    for (var a = 0; a < releaseOrders.length; a++) {
-                      const releaseOrderId: string = releaseOrders[a].id
-                      await FulfillmentAPI.cancelReleaseOrder(fulfillmentCenter, { customerBizplaceId, releaseOrderId })
-                    }
+                  let releaseOrder = Object.assign({}, releaseOrders[0])
+                  let patch = {
+                    id: releaseOrder.id,
+                    marketplaceOrderStatus: marketplaceOrder.status,
+                    trackingNo: marketplaceOrder.trackingNo,
+                    transporter: dropPickProvider ? dropPickProvider : marketplaceOrder.shippingProvider
                   }
-                } 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, {
+                  await FulfillmentAPI.updateReleaseGoodDetails(fulfillmentCenter, {
                     customerBizplaceId,
-                    refNo: marketplaceOrder.orderNo
+                    releaseOrder: { ...patch },
+                    shippingOrder: null
                   })
 
-                  const releaseOrderStatus = releaseOrders[0].status
-
-                  if (!disallowCancelStatuses.includes(releaseOrderStatus)) {
-                    await FulfillmentAPI.cancelReleaseOrder(fulfillmentCenter, {
-                      customerBizplaceId,
-                      releaseOrderId: releaseOrders[0].id
-                    })
+                  if (cancelStatuses.includes(marketplaceOrder.status)) {
+                    if (existingMarketplaceOrder.isSplitted) {
+                      releaseOrders = releaseOrders.filter(function (order) {
+                        return !disallowCancelStatuses.includes(order.status)
+                      })
+
+                      if (releaseOrders?.length) {
+                        for (var 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
+                        })
+                      }
+                    }
                   }
                 }
               }
-            }
 
-            marketplaceOrder = await getRepository(MarketplaceOrder).save(marketplaceOrder)
+              marketplaceOrder = await getRepository(MarketplaceOrder).save(marketplaceOrder)
 
-            let savedMarketplaceOrderShipping: MarketplaceOrderShipping = new MarketplaceOrderShipping()
-
-            if (order?.orderShipping) {
+              let savedMarketplaceOrderShipping: MarketplaceOrderShipping = new MarketplaceOrderShipping()
               let savedMarketplaceOrderShippings: MarketplaceOrderShipping[] = []
-              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.postCode = orderShipping.postCode
-              marketplaceOrderShipping.phone1 = orderShipping.phone1
-              marketplaceOrderShipping.phone2 = orderShipping.phone2
-              marketplaceOrderShipping.trackingNo = order.trackingNo
-              marketplaceOrderShipping.orderNoRef = marketplaceOrder.orderNo
-              marketplaceOrderShipping.subOrderNoRef = marketplaceOrder.orderNo
-              marketplaceOrderShipping.marketplaceStore = marketplaceStore
-              marketplaceOrderShipping.creator = user
-              marketplaceOrderShipping.domain = marketplaceStore.domain
 
-              if (existingMarketplaceOrder) {
-                if (existingMarketplaceOrder.isSplitted) {
-                  let existingOrderShippings: MarketplaceOrderShipping[] = await getRepository(
-                    MarketplaceOrderShipping
-                  ).find({
-                    where: { domain, marketplaceStore, orderNoRef: marketplaceOrder.orderNo }
-                  })
+              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,
-                      postCode: orderShipping.postCode,
-                      phone1: orderShipping.phone1,
-                      phone2: orderShipping.phone2,
-                      trackingNo: order.trackingNo
-                    }
-                  })
+                    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,
+                        postCode: orderShipping.postCode,
+                        phone1: orderShipping.phone1,
+                        phone2: orderShipping.phone2,
+                        trackingNo: order.trackingNo,
+                        shippingFee: orderShipping.shippingFee,
+                        actualShippingFee: orderShipping.actualShippingFee,
+                        marketplaceShippingFeeVoucher: orderShipping.marketplaceShippingFeeVoucher,
+                        sellerShippingFeeVoucher: orderShipping.sellerShippingFeeVoucher
+                      }
+                    })
 
-                  savedMarketplaceOrderShippings = await getRepository(MarketplaceOrderShipping).save(
-                    existingOrderShippings
-                  )
-                } else {
-                  let existingOrderShipping: MarketplaceOrderShipping
-                  existingOrderShipping = existingMarketplaceOrder.marketplaceOrderItems[0].marketplaceOrderShipping
+                    savedMarketplaceOrderShippings = await getRepository(MarketplaceOrderShipping).save(
+                      existingOrderShippings
+                    )
+                  } else {
+                    if (existingMarketplaceOrder?.marketplaceOrderItems) {
+                      let existingOrderShipping: MarketplaceOrderShipping
+                      existingOrderShipping = existingMarketplaceOrder.marketplaceOrderItems[0].marketplaceOrderShipping
+
+                      marketplaceOrderShipping = {
+                        ...existingOrderShipping,
+                        ...marketplaceOrderShipping,
+                        trackingNo: order?.trackingNo ? order.trackingNo : existingOrderShipping.trackingNo,
+                        updater: user
+                      }
 
-                  marketplaceOrderShipping = {
-                    ...existingOrderShipping,
-                    ...marketplaceOrderShipping,
-                    updater: user
+                      savedMarketplaceOrderShipping = await getRepository(MarketplaceOrderShipping).save(
+                        marketplaceOrderShipping
+                      )
+                    }
                   }
-
+                } else {
                   savedMarketplaceOrderShipping = await getRepository(MarketplaceOrderShipping).save(
                     marketplaceOrderShipping
                   )
                 }
-              } else {
-                savedMarketplaceOrderShipping = await getRepository(MarketplaceOrderShipping).save(
-                  marketplaceOrderShipping
-                )
               }
-            }
-
-            let orderTotalWeight: number = 0
-            let foundVariation
-            for (var j = 0; j < order.orderItems.length; j++) {
-              var item = order.orderItems[j]
-              foundVariation = await getRepository(MarketplaceProductVariation).findOne({
-                where: { variationId: item.variationId }
-              })
 
-              if (!foundVariation) {
-                let newVariation: any = {
-                  variationId: item.variationId,
-                  name: item.variationName,
-                  variationSku: item.variationSku,
-                  channelSku: item.sku,
-                  status: 'INACTIVE'
+              let orderTotalWeight: number = 0
+              let foundVariation
+              for (var j = 0; j < order.orderItems.length; j++) {
+                var item = order.orderItems[j]
+                foundVariation = await getRepository(MarketplaceProductVariation).findOne({
+                  where: { domain: marketplaceStore.domain, variationId: item.variationId }
+                })
+
+                if (!foundVariation) {
+                  let newVariation: any = {
+                    variationId: item.variationId,
+                    name: item.variationName,
+                    variationSku: item.variationSku,
+                    channelSku: item.sku,
+                    status: 'INACTIVE'
+                  }
+
+                  await getRepository(MarketplaceProductVariation).save(newVariation)
+                  foundVariation = newVariation
                 }
 
-                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.marketplaceOrder = marketplaceOrder
+                marketplaceOrderItem.trackingCode = order.trackingNo
+                marketplaceOrderItem.marketplaceOrderShipping = savedMarketplaceOrderShipping
+                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.autoShippingSubsidyMarketplace
+
+                marketplaceOrderItems.push({ ...marketplaceOrderItem })
+
+                if (foundVariation?.primaryUnitValue)
+                  orderTotalWeight += parseFloat(foundVariation.primaryUnitValue.toFixed(3)) * item.qty || 0
               }
 
-              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.marketplaceOrder = marketplaceOrder
-              marketplaceOrderItem.trackingCode = order.trackingNo
-              marketplaceOrderItem.marketplaceOrderShipping = savedMarketplaceOrderShipping
-              marketplaceOrderItem.creator = user
-
-              marketplaceOrderItems.push({ ...marketplaceOrderItem })
-
-              if (foundVariation?.primaryUnitValue)
-                orderTotalWeight += parseFloat(foundVariation.primaryUnitValue.toFixed(3)) * item.qty || 0
-            }
-
-            if (existingMarketplaceOrder) {
-              if (existingMarketplaceOrder.isSplitted) {
-                let existingOrderItems: MarketplaceOrderItem[] = []
-                existingOrderItems = existingMarketplaceOrder.marketplaceOrderItems
-
-                marketplaceOrderItems = existingOrderItems.filter(
-                  itm =>
-                    itm.name == item.name &&
-                    itm.marketplaceProductVariation.variationId == item.marketplaceProductVariation.variationId
-                )
-                marketplaceOrderItems = marketplaceOrderItems.map(marketplaceOrderitem => {
-                  return {
-                    ...marketplaceOrderitem,
-                    status: order.status,
-                    marketplaceProductVariation: foundVariation,
-                    trackingCode: order.trackingNo
-                  }
-                })
-              } else {
-                let existingOrderItems: MarketplaceOrderItem[] = []
-                existingOrderItems = existingMarketplaceOrder.marketplaceOrderItems
-
-                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)
-                    await getRepository(MarketplaceOrderItem).delete(nonMatchedOrderItems)
-
-                  existingOrderItems = marketplaceOrderItems.map(item => {
-                    const matchedOrderItem = existingOrderItems.find(
-                      itm =>
-                        itm.name == item.name &&
-                        itm.marketplaceProductVariation.variationId == item.marketplaceProductVariation.variationId
-                    )
-                    if (matchedOrderItem) {
-                      return {
-                        ...matchedOrderItem,
-                        ...item,
-                        updater: user
-                      }
+              if (existingMarketplaceOrder) {
+                if (existingMarketplaceOrder.isSplitted) {
+                  let existingOrderItems: MarketplaceOrderItem[] = []
+                  existingOrderItems = existingMarketplaceOrder.marketplaceOrderItems
+
+                  marketplaceOrderItems = existingOrderItems.filter(
+                    itm => itm.name == item.name && itm.marketplaceProductVariation.variationId == item.variationId
+                  )
+                  marketplaceOrderItems = marketplaceOrderItems.map(marketplaceOrderitem => {
+                    return {
+                      ...marketplaceOrderitem,
+                      status: order.status,
+                      marketplaceProductVariation: foundVariation,
+                      trackingCode: order.trackingNo
                     }
                   })
                 } else {
-                  existingOrderItems = marketplaceOrderItems.map(item => {
-                    const matchedOrderItem = existingOrderItems.find(
-                      itm =>
-                        itm.name == item.name &&
-                        itm.marketplaceProductVariation.variationId == item.marketplaceProductVariation.variationId
-                    )
-                    if (matchedOrderItem) {
-                      return {
-                        ...matchedOrderItem,
-                        ...item,
-                        updater: user
+                  let existingOrderItems: MarketplaceOrderItem[] = []
+                  existingOrderItems = existingMarketplaceOrder.marketplaceOrderItems
+
+                  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 })
                       }
-                    } else {
-                      return {
-                        ...item,
-                        updater: user
+                    })
+                    if (nonMatchedOrderItems.length > 0 && !cancelStatuses.includes(marketplaceOrder.status))
+                      await getRepository(MarketplaceOrderItem).delete(nonMatchedOrderItems)
+
+                    existingOrderItems = marketplaceOrderItems.map(item => {
+                      const matchedOrderItem = existingOrderItems.find(
+                        itm =>
+                          itm.name == item.name &&
+                          itm.marketplaceProductVariation.variationId == item.marketplaceProductVariation.variationId
+                      )
+                      if (matchedOrderItem) {
+                        return {
+                          ...matchedOrderItem,
+                          ...item,
+                          updater: user
+                        }
                       }
-                    }
-                  })
-                }
+                    })
+                  } else {
+                    existingOrderItems = marketplaceOrderItems.map(item => {
+                      const matchedOrderItem = existingOrderItems.find(
+                        itm =>
+                          itm.name == item.name &&
+                          itm.marketplaceProductVariation.variationId == item.marketplaceProductVariation.variationId
+                      )
+                      if (matchedOrderItem) {
+                        return {
+                          ...matchedOrderItem,
+                          ...item,
+                          updater: user
+                        }
+                      } else {
+                        return {
+                          ...item,
+                          updater: user
+                        }
+                      }
+                    })
+                  }
 
-                marketplaceOrderItems = existingOrderItems
+                  marketplaceOrderItems = existingOrderItems
 
+                  if (order?.orderShipping) {
+                    savedMarketplaceOrderShipping.totalWeight = orderTotalWeight
+                    savedMarketplaceOrderShipping = await getRepository(MarketplaceOrderShipping).save(
+                      savedMarketplaceOrderShipping
+                    )
+                  }
+                }
+              } else {
                 if (order?.orderShipping) {
                   savedMarketplaceOrderShipping.totalWeight = orderTotalWeight
                   savedMarketplaceOrderShipping = await getRepository(MarketplaceOrderShipping).save(
@@ -372,24 +436,19 @@ export const syncAllMarketplaceOrder = {
                   )
                 }
               }
-            } else {
-              if (order?.orderShipping) {
-                savedMarketplaceOrderShipping.totalWeight = orderTotalWeight
-                savedMarketplaceOrderShipping = await getRepository(MarketplaceOrderShipping).save(
-                  savedMarketplaceOrderShipping
-                )
-              }
-            }
 
-            await getRepository(MarketplaceOrderItem).save(marketplaceOrderItems)
+              await getRepository(MarketplaceOrderItem).save(marketplaceOrderItems)
 
-            if (m == marketplaceOrders.length - 1) {
-              lastOrderId = order.name
-            }
+              if (m == marketplaceOrders.length - 1) {
+                lastOrderId = order.name
+              }
+            } catch (e) {}
           }
 
           if (more) page++
           hasMorePage = more
+        } else {
+          hasMorePage = false
         }
       }
     }