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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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