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

package/server/graphql/resolvers/marketplace-product-variation/index.ts

@@ -0,0 +1,30 @@
+import { createMarketplaceProductVariationResolver } from './create-marketplace-product-variation'
+import { deleteMarketplaceProductVariationResolver } from './delete-marketplace-product-variation'
+import { deleteMarketplaceProductVariationsResolver } from './delete-marketplace-product-variations'
+import { linkWarehouseMarketplaceProductVariationsResolver } from './link-warehouse-marketplace-product-variations'
+import { marketplaceProductVariationResolver } from './marketplace-product-variation'
+import { marketplaceProductVariationsResolver } from './marketplace-product-variations'
+import {
+  updateMarketplaceProductVariation,
+  updateMarketplaceProductVariationResolver
+} from './update-marketplace-product-variation'
+import { updateMultipleMarketplaceProductVariationQuantityResolver } from './update-multiple-marketplace-product-variation-quantity'
+import { updateMultipleMarketplaceProducVariationsResolver } from './update-multiple-marketplace-product-variations'
+
+export const MarketplaceProductVariationResolver = {
+  Query: {
+    ...marketplaceProductVariationsResolver,
+    ...marketplaceProductVariationResolver
+  },
+  Mutation: {
+    ...updateMarketplaceProductVariationResolver,
+    ...createMarketplaceProductVariationResolver,
+    ...deleteMarketplaceProductVariationResolver,
+    ...deleteMarketplaceProductVariationsResolver,
+    ...updateMultipleMarketplaceProductVariationQuantityResolver,
+    ...linkWarehouseMarketplaceProductVariationsResolver,
+    ...updateMultipleMarketplaceProducVariationsResolver
+  }
+}
+
+export { updateMarketplaceProductVariation }

package/server/graphql/resolvers/marketplace-product-variation/link-warehouse-marketplace-product-variations.ts

@@ -0,0 +1,59 @@
+import { SelectQueryBuilder } from 'typeorm'
+
+import { MarketplaceProductVariation } from '../../../entities'
+import { updateMarketplaceProductVariation } from './index'
+
+export const linkWarehouseMarketplaceProductVariationsResolver = {
+  async linkWarehouseMarketplaceProductVariations(
+    _: any,
+    { marketplaceStoreId, sku, patches },
+    context: any
+  ): Promise<any> {
+    const { tx } = context.state
+
+    const qb: SelectQueryBuilder<MarketplaceProductVariation> = tx
+      .getRepository(MarketplaceProductVariation)
+      .createQueryBuilder('mpv')
+      .innerJoinAndSelect('mpv.marketplaceProduct', 'mp')
+      .where('mpv.sku = :sku', { sku })
+      .andWhere('mp.marketplace_store_id = :marketplaceStoreId', { marketplaceStoreId })
+
+    let existingMarketplaceProductVariation = await qb.getMany()
+
+    let newMarketplaceProductVariationLink: MarketplaceProductVariation[] = patches.reduce((acc, curr) => {
+      if (!existingMarketplaceProductVariation.find(itm => itm.id == curr.id)) {
+        acc.push({ id: curr.id })
+      }
+      return acc
+    }, [])
+
+    let removeMarketplaceProductVariationLink: MarketplaceProductVariation[] =
+      existingMarketplaceProductVariation.reduce((acc, curr) => {
+        if (!patches.find(itm => itm.id == curr.id)) {
+          acc.push({ id: curr.id })
+        }
+        return acc
+      }, [])
+
+    if (newMarketplaceProductVariationLink.length > 0) {
+      for (let i = 0; i < newMarketplaceProductVariationLink.length; i++) {
+        const patch: MarketplaceProductVariation = { ...newMarketplaceProductVariationLink[i], sku }
+        await updateMarketplaceProductVariation(newMarketplaceProductVariationLink[i].id, patch, context.state.user, tx)
+      }
+    }
+
+    if (removeMarketplaceProductVariationLink.length > 0) {
+      for (let i = 0; i < removeMarketplaceProductVariationLink.length; i++) {
+        const patch: MarketplaceProductVariation = { ...removeMarketplaceProductVariationLink[i], sku: null }
+        await updateMarketplaceProductVariation(
+          removeMarketplaceProductVariationLink[i].id,
+          patch,
+          context.state.user,
+          tx
+        )
+      }
+    }
+
+    return true
+  }
+}

package/server/graphql/resolvers/marketplace-product-variation/marketplace-product-variation.ts

@@ -0,0 +1,14 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceProductVariation } from '../../../entities'
+
+export const marketplaceProductVariationResolver = {
+  async marketplaceProductVariation(_: any, { name }, context: ResolverContext) {
+    const repository = getRepository(MarketplaceProductVariation)
+
+    return await getRepository(MarketplaceProductVariation).findOne({
+      where: { domain: { id: context.state.domain.id }, name },
+      relations: ['domain', 'creator', 'updater']
+    })
+  }
+}

package/server/graphql/resolvers/marketplace-product-variation/marketplace-product-variations.ts

@@ -0,0 +1,79 @@
+import { SelectQueryBuilder } from 'typeorm'
+
+import { buildQuery, getRepository, ListParam } from '@things-factory/shell'
+
+import { MarketplaceProductVariation } from '../../../entities'
+
+export const marketplaceProductVariationsResolver = {
+  async marketplaceProductVariations(_: any, params: ListParam, context: ResolverContext) {
+    const customFilterNames = ['marketplaceStoreId', 'sku', 'unAssignedSku']
+    const customFilters = params.filters.filter(x => customFilterNames.indexOf(x.name) >= 0)
+
+    params.filters = params.filters.filter(x => customFilterNames.indexOf(x.name) < 0)
+
+    params.sortings = params.sortings.map(sorting => {
+      let field = sorting.name.split('|')
+      if (field.length > 1) {
+        switch (field[0]) {
+          case 'marketplaceProduct':
+            return {
+              ...sorting,
+              name: `mp.${field[1]}`
+            }
+          case 'marketplaceStoreProduct':
+            return {
+              ...sorting,
+              name: `msp.${field[1]}`
+            }
+          case 'marketplaceStore':
+            return {
+              ...sorting,
+              name: `ms.${field[1]}`
+            }
+          default:
+            return {
+              ...sorting
+            }
+        }
+      }
+      return sorting
+    })
+
+    // const convertedParams = convertListParams(params)
+
+    let qb: SelectQueryBuilder<MarketplaceProductVariation> =
+      getRepository(MarketplaceProductVariation).createQueryBuilder('mpv')
+    buildQuery(qb, params, context)
+
+    qb.innerJoinAndSelect('mpv.marketplaceProduct', 'mp')
+    qb.innerJoinAndSelect('mp.marketplaceStore', 'ms')
+
+    qb.addOrderBy('ms.name', 'ASC')
+    qb.addOrderBy('mp.name', 'ASC')
+    qb.addOrderBy('mpv.name', 'ASC')
+
+    let marketplaceStoreId = customFilters.find(x => x.name == 'marketplaceStoreId')
+    if (marketplaceStoreId)
+      qb.andWhere('mp.marketplace_store_id = :storeId::uuid', {
+        storeId: marketplaceStoreId.value
+      })
+
+    let unAssignedSku = customFilters.find(x => x.name == 'unAssignedSku')
+    let sku = customFilters.find(x => x.name == 'sku')
+    if (unAssignedSku) {
+      if (unAssignedSku.value) {
+        qb.andWhere(`"mpv"."sku" IS NULL`)
+      } else {
+        qb.andWhere(`"mpv"."sku" IS NOT NULL`)
+      }
+    } else {
+      if (sku) {
+        qb.andWhere('mpv.sku = :sku', { sku: sku.value })
+      }
+    }
+
+    const [items, total] = await qb.getManyAndCount()
+
+    return { items, total }
+  }
+}

package/server/graphql/resolvers/marketplace-product-variation/update-marketplace-product-variation.ts

@@ -0,0 +1,32 @@
+import { EntityManager, Repository } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceProductVariation } from '../../../entities'
+
+export const updateMarketplaceProductVariationResolver = {
+  async updateMarketplaceProductVariation(_: any, { id, patch }, context: ResolverContext) {
+    try {
+      return updateMarketplaceProductVariation(id, patch, context.state.user)
+    } catch (error) {
+      throw error
+    }
+  }
+}
+
+export async function updateMarketplaceProductVariation(
+  id: string,
+  patch: MarketplaceProductVariation,
+  user: any,
+  trxMgr?: EntityManager
+) {
+  const marketplaceProductVariationRepo: Repository<MarketplaceProductVariation> =
+    trxMgr?.getRepository(MarketplaceProductVariation) || getRepository(MarketplaceProductVariation)
+  const product = await marketplaceProductVariationRepo.findOneBy({ id })
+
+  return marketplaceProductVariationRepo.save({
+    ...product,
+    ...patch,
+    updater: user
+  })
+}

package/server/graphql/resolvers/marketplace-product-variation/update-multiple-marketplace-product-variation-quantity.ts

@@ -0,0 +1,76 @@
+import { StoreAPI } from '@things-factory/integration-marketplace'
+
+import { MARKETPLACE_PLATFORM } from '../../../constants'
+import { MarketplaceProductVariation } from '../../../entities'
+
+export const updateMultipleMarketplaceProductVariationQuantityResolver = {
+  async updateMultipleMarketplaceProductVariationQuantity(_: any, { patches }, context: ResolverContext) {
+    try {
+      if (patches && patches.length > 0) {
+        const { tx } = context.state
+
+        await Promise.all(
+          patches.map(async itm => {
+            const repoProductVariation = tx.getRepository(MarketplaceProductVariation)
+
+            let productVariation = await repoProductVariation.findOne({
+              where: { id: itm.id },
+              relations: [
+                'marketplaceProduct',
+                'marketplaceProduct.marketplaceStore',
+                'marketplaceProduct.marketplaceStore.marketplaceDistributors',
+                'creator',
+                'updater'
+              ]
+            })
+
+            const marketplaceStore = productVariation?.marketplaceProduct?.marketplaceStore
+            const hasVariation = productVariation?.marketplaceProduct?.hasVariation
+
+            if (marketplaceStore) {
+              //Lazada Product quantity data update -> {sku, qty}
+              //Shopee Product quantity data update -> variation = false: {itemId, qty} | variation = true: {itemId, variationId, qty}
+              let adjustQty = itm.qty
+              let productVariationLocationId = productVariation.locationId
+              if (marketplaceStore.platform === MARKETPLACE_PLATFORM.SHOPIFY) {
+                adjustQty = itm.qty - productVariation.qty
+
+                let locationIds: any[] = JSON.parse(productVariationLocationId)
+                productVariationLocationId = locationIds[0].location_id
+              }
+
+              if (hasVariation) {
+                await StoreAPI.updateStoreProductVariationStock(marketplaceStore, [
+                  {
+                    itemId: productVariation.marketplaceProduct.itemId,
+                    variationId: productVariation.variationId,
+                    qty: adjustQty,
+                    locationId: productVariationLocationId,
+                    inventoryItemId: productVariation.inventoryItemId
+                  }
+                ])
+              } else {
+                await StoreAPI.updateStoreProductStock(marketplaceStore, [
+                  {
+                    itemId: productVariation.marketplaceProduct.itemId,
+                    variationId: productVariation.variationId,
+                    variationSku: productVariation.variationSku,
+                    qty: adjustQty,
+                    distributors: marketplaceStore.marketplaceDistributors
+                  }
+                ])
+              }
+              await repoProductVariation.save({ ...productVariation, qty: itm.qty })
+            }
+          })
+        )
+
+        return true
+      } else {
+        throw new Error('No data found.')
+      }
+    } catch (ex) {
+      throw ex
+    }
+  }
+}

package/server/graphql/resolvers/marketplace-product-variation/update-multiple-marketplace-product-variations.ts

@@ -0,0 +1,49 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceProductVariation } from '../../../entities'
+
+export const updateMultipleMarketplaceProducVariationsResolver = {
+  async updateMultipleMarketplaceProductVariations(_: any, { patches }, context: ResolverContext) {
+    const { domain, user } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const marketplaceProductVariationRepo = getRepository(MarketplaceProductVariation)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await marketplaceProductVariationRepo.save({
+          ...newRecord,
+          domain: domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const marketplaceProductVariationPrice = await marketplaceProductVariationRepo.findOneBy({
+          domain: { id: domain.id },
+          id: newRecord.id
+        })
+
+        const result = await marketplaceProductVariationRepo.save({
+          ...marketplaceProductVariationPrice,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return true
+  }
+}

package/server/graphql/resolvers/marketplace-product-variation-price/create-marketplace-product-variation-price.ts

@@ -0,0 +1,16 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceProductVariationPrice } from '../../../entities'
+
+export const createMarketplaceProductVariationPrice = {
+  async createMarketplaceProductVariationPrice(_: any, { marketplaceProductVariationPrice }, context: ResolverContext) {
+    const { domain, user } = context.state
+
+    return await getRepository(MarketplaceProductVariationPrice).save({
+      ...marketplaceProductVariationPrice,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+}

package/server/graphql/resolvers/marketplace-product-variation-price/delete-marketplace-product-variation-price.ts

@@ -0,0 +1,13 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceProductVariationPrice } from '../../../entities'
+
+export const deleteMarketplaceProductVariationPrice = {
+  async deleteMarketplaceProductVariationPrice(_: any, { name }, context: ResolverContext) {
+    const { domain, user } = context.state
+
+    await getRepository(MarketplaceProductVariationPrice).delete({ domain: { id: domain.id }, name })
+
+    return true
+  }
+}

package/server/graphql/resolvers/marketplace-product-variation-price/delete-marketplace-product-variation-prices.ts

@@ -0,0 +1,18 @@
+import { In } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceProductVariationPrice } from '../../../entities'
+
+export const deleteMarketplaceProductVariationPrices = {
+  async deleteMarketplaceProductVariationPrices(_: any, { names }, context: ResolverContext) {
+    const { domain, user } = context.state
+
+    await getRepository(MarketplaceProductVariationPrice).delete({
+      domain: { id: domain.id },
+      name: In(names)
+    })
+
+    return true
+  }
+}

package/server/graphql/resolvers/marketplace-product-variation-price/index.ts

@@ -0,0 +1,19 @@
+import { Query, MarketplaceProductVariationPrice } from './marketplace-product-variation-price-query'
+
+import { updateMarketplaceProductVariationPrice } from './update-marketplace-product-variation-price'
+import { updateMultipleMarketplaceProductVariationPrice } from './update-multiple-marketplace-product-variation-price'
+import { createMarketplaceProductVariationPrice } from './create-marketplace-product-variation-price'
+import { deleteMarketplaceProductVariationPrice } from './delete-marketplace-product-variation-price'
+import { deleteMarketplaceProductVariationPrices } from './delete-marketplace-product-variation-prices'
+
+export const MarketplaceProductVariationPriceResolver = {
+  MarketplaceProductVariationPrice,
+  Query,
+  Mutation: {
+    ...updateMarketplaceProductVariationPrice,
+    ...updateMultipleMarketplaceProductVariationPrice,
+    ...createMarketplaceProductVariationPrice,
+    ...deleteMarketplaceProductVariationPrice,
+    ...deleteMarketplaceProductVariationPrices
+  }
+}

package/server/graphql/resolvers/marketplace-product-variation-price/marketplace-product-variation-price-query.ts

@@ -0,0 +1,52 @@
+import { convertListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { MarketplaceProductVariationPrice as MarketplaceProductVariationPriceEntity } from '../../../entities'
+
+export const Query = {
+  async marketplaceProductVariationPrice(_: any, { name }, context: ResolverContext) {
+    const { domain, user } = context.state
+    const repository = getRepository(MarketplaceProductVariationPriceEntity)
+
+    return await repository.findOne({
+      where: { domain: { id: domain.id }, name }
+    })
+  },
+
+  async marketplaceProductVariationPrices(_: any, params: ListParam, context: ResolverContext) {
+    const convertedParams = convertListParams(params)
+    const [items, total] = await getRepository(MarketplaceProductVariationPriceEntity).findAndCount({
+      ...convertedParams
+    })
+
+    return { items, total }
+  }
+}
+
+export const MarketplaceProductVariationPrice = {
+  async domain(marketplaceProductVariationPrice) {
+    return (
+      await getRepository(MarketplaceProductVariationPriceEntity).findOne({
+        where: { id: marketplaceProductVariationPrice.id },
+        relations: ['domain']
+      })
+    )?.domain
+  },
+
+  async updater(marketplaceProductVariationPrice) {
+    return (
+      await getRepository(MarketplaceProductVariationPriceEntity).findOne({
+        where: { id: marketplaceProductVariationPrice.id },
+        relations: ['updater']
+      })
+    )?.updater
+  },
+
+  async creator(marketplaceProductVariationPrice) {
+    return (
+      await getRepository(MarketplaceProductVariationPriceEntity).findOne({
+        where: { id: marketplaceProductVariationPrice.id },
+        relations: ['creator']
+      })
+    )?.creator
+  }
+}

package/server/graphql/resolvers/marketplace-product-variation-price/update-marketplace-product-variation-price.ts

@@ -0,0 +1,20 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceProductVariationPrice } from '../../../entities'
+
+export const updateMarketplaceProductVariationPrice = {
+  async updateMarketplaceProductVariationPrice(_: any, { name, patch }, context: ResolverContext) {
+    const { domain, user } = context.state
+
+    const repository = getRepository(MarketplaceProductVariationPrice)
+    const marketplaceProductVariationPrice = await repository.findOne({
+      where: { domain: { id: domain.id }, name }
+    })
+
+    return await repository.save({
+      ...marketplaceProductVariationPrice,
+      ...patch,
+      updater: user
+    })
+  }
+}

package/server/graphql/resolvers/marketplace-product-variation-price/update-multiple-marketplace-product-variation-price.ts

@@ -0,0 +1,49 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceProductVariationPrice } from '../../../entities'
+
+export const updateMultipleMarketplaceProductVariationPrice = {
+  async updateMultipleMarketplaceProductVariationPrice(_: any, { patches }, context: ResolverContext) {
+    const { domain, user } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const marketplaceProductVariationPriceRepo = getRepository(MarketplaceProductVariationPrice)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await marketplaceProductVariationPriceRepo.save({
+          ...newRecord,
+          domain: domain,
+          creator: user,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const marketplaceProductVariationPrice = await marketplaceProductVariationPriceRepo.findOneBy({
+          domain: { id: domain.id },
+          id: newRecord.id
+        })
+
+        const result = await marketplaceProductVariationPriceRepo.save({
+          ...marketplaceProductVariationPrice,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+}

package/server/graphql/resolvers/marketplace-refund-order/index.ts

@@ -0,0 +1,9 @@
+import { syncMarketplaceRefundOrders } from './sync-marketplace-refund-orders'
+import { syncAllMarketplaceRefundOrders } from './sync-all-marketplace-refund-orders'
+
+export const MarketplaceRefundOrderResolver = {
+    Mutation: {
+        ...syncMarketplaceRefundOrders,
+        ...syncAllMarketplaceRefundOrders
+    }
+}

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

@@ -0,0 +1,122 @@
+import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
+import { Domain, getRepository } from '@things-factory/shell'
+
+import { MarketplaceProductVariation, MarketplaceRefundOrder, MarketplaceRefundOrderItem } from '../../../entities'
+
+export const syncAllMarketplaceRefundOrders = {
+  async syncAllMarketplaceRefundOrders(
+    _: any,
+    { companyDomainId, fromDate, toDate, blackListStores },
+    context: ResolverContext
+  ) {
+    const { user, tx } = context.state
+
+    const companyDomain: Domain = await getRepository(Domain).findOneBy({ id: companyDomainId })
+
+    // Step 1: get all available marketplace-store
+    const marketplaceStores: MarketplaceStore[] = await StoreAPI.getMarketplaceStores(companyDomain)
+
+    // Step 2: get marketplace refund orders based on each marketplace-store
+    if (marketplaceStores?.length === 0) throw new Error('No active marketplace store')
+    let whiteListStores: MarketplaceStore[] = marketplaceStores
+
+    if (blackListStores && blackListStores?.length) {
+      whiteListStores = marketplaceStores.filter(store => blackListStores.indexOf(store.name) < 0)
+    }
+
+    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
+      var limit: number = 100
+
+      while (hasMorePage) {
+        const { results: marketplaceRefundOrders, more } = await StoreAPI.getStoreRefundOrders(marketplaceStore, {
+          fromDate,
+          toDate,
+          pagination: { page, limit }
+        })
+
+        if (marketplaceRefundOrders?.length > 0) {
+          for (var m = 0; m < marketplaceRefundOrders.length; m++) {
+            var refundOrder = marketplaceRefundOrders[i]
+
+            let marketplaceRefundOrder: MarketplaceRefundOrder = new MarketplaceRefundOrder()
+            marketplaceRefundOrder.name = refundOrder.name
+            marketplaceRefundOrder.orderNo = refundOrder.orderNo
+            marketplaceRefundOrder.amount = refundOrder.amount
+            marketplaceRefundOrder.status = refundOrder.status
+            marketplaceRefundOrder.originalOrderNo = refundOrder.originalOrderNo
+            marketplaceRefundOrder.domain = marketplaceStore.domain
+            marketplaceRefundOrder.creator = user
+            marketplaceRefundOrder.updater = user
+
+            const existingRefundOrder: MarketplaceRefundOrder = await getRepository(MarketplaceRefundOrder).findOne({
+              where: { domain: { id: marketplaceStore.domain.id }, name: refundOrder.name },
+              relations: ['domain', 'marketplaceRefundOrderItems']
+            })
+
+            if (existingRefundOrder) {
+              marketplaceRefundOrder = {
+                ...existingRefundOrder,
+                ...marketplaceRefundOrder,
+                updater: user
+              }
+            }
+            marketplaceRefundOrder = await getRepository(MarketplaceRefundOrder).save(marketplaceRefundOrder)
+
+            refundOrder.items.forEach(async item => {
+              let existingVariation: MarketplaceProductVariation = await getRepository(
+                MarketplaceProductVariation
+              ).findOne({
+                where: { domain: { id: marketplaceStore.domain.id }, name: item.variationId }
+              })
+
+              if (marketplaceStore.platform === 'lazada') {
+                existingVariation = await getRepository(MarketplaceProductVariation).findOne({
+                  where: { domain: { id: marketplaceStore.domain.id }, channelSku: item.channelSku }
+                })
+              }
+
+              let marketplaceRefundOrderItem: MarketplaceRefundOrderItem = new MarketplaceRefundOrderItem()
+
+              marketplaceRefundOrderItem.name = item.name
+              marketplaceRefundOrderItem.orderItemId = item.orderItemId
+              marketplaceRefundOrderItem.price = item.price
+              marketplaceRefundOrderItem.qty = item.qty
+              marketplaceRefundOrderItem.status = item.status
+              marketplaceRefundOrderItem.domain = marketplaceStore.domain
+              marketplaceRefundOrderItem.creator = user
+              marketplaceRefundOrderItem.updater = user
+              marketplaceRefundOrderItem.marketplaceRefundOrder = marketplaceRefundOrder
+              marketplaceRefundOrderItem.marketplaceProductVariation = existingVariation
+
+              const existingRefundOrderItem: MarketplaceRefundOrderItem = await getRepository(
+                MarketplaceRefundOrderItem
+              ).findOne({
+                where: { domain: { id: marketplaceStore.domain.id }, name: item.name },
+                relations: ['domain']
+              })
+              if (existingRefundOrderItem) {
+                marketplaceRefundOrderItem = {
+                  ...existingRefundOrderItem,
+                  ...marketplaceRefundOrderItem,
+                  updater: user
+                }
+              }
+
+              marketplaceRefundOrderItem = await getRepository(MarketplaceRefundOrderItem).save(
+                marketplaceRefundOrderItem
+              )
+            })
+          }
+        }
+        if (more) page++
+        hasMorePage = more
+      }
+    }
+    return true
+  }
+}