@things-factory/marketplace-base 4.0.10 → 4.0.14

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

@@ -24,6 +24,8 @@ export const syncMarketplaceOrder = {
     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, {
@@ -41,6 +43,7 @@ export const syncMarketplaceOrder = {
         let marketplaceOrderItems = []
         let tracking_code = ''
         let deliveryProvider: string
+        let dropPickProvider: string
 
         if (marketplaceStore.platform == 'lazada') {
           if (order.trackingNo != '') {
@@ -60,7 +63,10 @@ export const syncMarketplaceOrder = {
             shippingProviderInfo[key] = value
           })
 
-          deliveryProvider = shippingProviderInfo.Delivery
+          dropPickProvider = shippingProviderInfo?.Pickup
+            ? shippingProviderInfo['Pickup']
+            : shippingProviderInfo['Drop-off']
+          deliveryProvider = shippingProviderInfo['Delivery']
         }
 
         let marketplaceOrder: MarketplaceOrder = new MarketplaceOrder()
@@ -76,6 +82,16 @@ export const syncMarketplaceOrder = {
         marketplaceOrder.orderUpdatedAt = order.orderUpdatedAt
         marketplaceOrder.marketplaceStore = marketplaceStore
         marketplaceOrder.domain = marketplaceStore.domain
+        marketplaceOrder.buyerUsername = order.buyerUsername
+        marketplaceOrder.payTime = order.payTime
+        marketplaceOrder.serviceFee = order.serviceFee
+        marketplaceOrder.commissionFee = order.commissionFee
+        marketplaceOrder.transactionFee = order.transactionFee
+        marketplaceOrder.shippingMode = order.shippingMode
+        marketplaceOrder.voucherAmount = order.voucherAmount
+        marketplaceOrder.totalRealeasedAmount = order.totalRealeasedAmount
+        marketplaceOrder.voucherCode = order.voucherCode
+        marketplaceOrder.shippingRebate = order.shippingRebate
 
         const existingMarketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
           where: { domain: marketplaceStore.domain, name: order.name },
@@ -103,52 +119,67 @@ export const syncMarketplaceOrder = {
             updater: user
           }
 
-          const cancelStatuses: string[] = ['cancelled', 'canceled']
-          const disallowCancelStatuses: string[] = ['CANCELLED', 'PENDING_CANCEL']
+          if (marketplaceOrder?.releaseOrderId) {
+            const fulfillmentCenter: FulfillmentCenter = marketplaceOrder.fulfillmentCenter
+            const centerId: string = fulfillmentCenter.centerId
+            const warehouseDomain: Domain = await tx.getRepository(Domain).findOne({ where: { subdomain: centerId } })
+            const customerBizplaces: Bizplace[] = await getCustomerBizplaces(warehouseDomain)
+            const customerBizplaceId: string = customerBizplaces[0].id
 
-          if (cancelStatuses.includes(marketplaceOrder.status) && marketplaceOrder?.releaseOrderId) {
-            if (existingMarketplaceOrder.isSplitted) {
-              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
-
-              let { items: releaseOrders }: any = await FulfillmentAPI.getOutboundOrders(fulfillmentCenter, {
-                customerBizplaceId,
-                refNo: marketplaceOrder.orderNo
-              })
+            let { items: releaseOrders }: any = await FulfillmentAPI.getOutboundOrders(fulfillmentCenter, {
+              customerBizplaceId,
+              refNo: marketplaceOrder.orderNo
+            })
 
-              releaseOrders = releaseOrders.filter(function (order) {
-                return !disallowCancelStatuses.includes(order.status)
-              })
+            let releaseOrder = Object.assign({}, releaseOrders[0])
+            let patch = {
+              id: releaseOrder.id,
+              marketplaceOrderStatus: marketplaceOrder.status,
+              trackingNo: marketplaceOrder.trackingNo,
+              transporter: dropPickProvider ? dropPickProvider : marketplaceOrder.shippingProvider
+            }
 
-              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
+            await FulfillmentAPI.updateReleaseGoodDetails(fulfillmentCenter, {
+              customerBizplaceId,
+              releaseOrder: { ...patch },
+              shippingOrder: null
+            })
 
-              const warehouseDomain: Domain = await tx.getRepository(Domain).findOne({ where: { subdomain: centerId } })
-              const customerBizplaces: Bizplace[] = await getCustomerBizplaces(warehouseDomain)
-              const customerBizplaceId: string = customerBizplaces[0].id
+            if (cancelStatuses.includes(marketplaceOrder.status)) {
+              if (existingMarketplaceOrder.isSplitted) {
+                releaseOrders = releaseOrders.filter(function (order) {
+                  return !disallowCancelStatuses.includes(order.status)
+                })
 
-              const { items: releaseOrders }: any = await FulfillmentAPI.getOutboundOrders(fulfillmentCenter, {
-                customerBizplaceId,
-                refNo: marketplaceOrder.orderNo
-              })
+                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 releaseOrderStatus = releaseOrders[0].status
+                const warehouseDomain: Domain = await tx
+                  .getRepository(Domain)
+                  .findOne({ where: { subdomain: centerId } })
+                const customerBizplaces: Bizplace[] = await getCustomerBizplaces(warehouseDomain)
+                const customerBizplaceId: string = customerBizplaces[0].id
 
-              if (!disallowCancelStatuses.includes(releaseOrderStatus)) {
-                await FulfillmentAPI.cancelReleaseOrder(fulfillmentCenter, {
+                const { items: releaseOrders }: any = await FulfillmentAPI.getOutboundOrders(fulfillmentCenter, {
                   customerBizplaceId,
-                  releaseOrderId: releaseOrders[0].id
+                  refNo: marketplaceOrder.orderNo
                 })
+
+                const releaseOrderStatus = releaseOrders[0].status
+
+                if (!disallowCancelStatuses.includes(releaseOrderStatus)) {
+                  await FulfillmentAPI.cancelReleaseOrder(fulfillmentCenter, {
+                    customerBizplaceId,
+                    releaseOrderId: releaseOrders[0].id
+                  })
+                }
               }
             }
           }
@@ -172,16 +203,20 @@ export const syncMarketplaceOrder = {
           marketplaceOrderShipping.attentionTo = orderShipping.attentionTo
           marketplaceOrderShipping.city = orderShipping.city
           marketplaceOrderShipping.country = orderShipping.country
-          marketplaceOrderShipping.state = orderShipping?.state
+          marketplaceOrderShipping.state = orderShipping?.state || null
           marketplaceOrderShipping.postCode = orderShipping.postCode
           marketplaceOrderShipping.phone1 = orderShipping.phone1
           marketplaceOrderShipping.phone2 = orderShipping.phone2
-          marketplaceOrderShipping.trackingNo = order.trackingNo
+          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) {
@@ -207,7 +242,11 @@ export const syncMarketplaceOrder = {
                   phone1: orderShipping.phone1,
                   phone2: orderShipping.phone2,
                   email: orderShipping?.email,
-                  trackingNo: order.trackingNo
+                  trackingNo: order?.trackingNo,
+                  shippingFee: orderShipping.shippingFee,
+                  actualShippingFee: orderShipping.actualShippingFee,
+                  marketplaceShippingFeeVoucher: orderShipping.marketplaceShippingFeeVoucher,
+                  sellerShippingFeeVoucher: orderShipping.sellerShippingFeeVoucher
                 }
               })
 
@@ -222,6 +261,11 @@ export const syncMarketplaceOrder = {
                 marketplaceOrderShipping = {
                   ...existingOrderShipping,
                   ...marketplaceOrderShipping,
+                  trackingNo: marketplaceOrderShipping?.trackingNo
+                    ? marketplaceOrderShipping.trackingNo
+                    : existingOrderShipping?.trackingNo
+                    ? existingOrderShipping.trackingNo
+                    : marketplaceOrderShipping.trackingNo,
                   updater: user
                 }
 
@@ -269,7 +313,27 @@ export const syncMarketplaceOrder = {
           marketplaceOrderItem.trackingCode = order.trackingNo
           marketplaceOrderItem.marketplaceOrder = marketplaceOrder
           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.taxAmount
 
           marketplaceOrderItems.push({ ...marketplaceOrderItem })
 
@@ -283,9 +347,7 @@ export const syncMarketplaceOrder = {
             existingOrderItems = existingMarketplaceOrder.marketplaceOrderItems
 
             marketplaceOrderItems = existingOrderItems.filter(
-              itm =>
-                itm.name == item.name &&
-                itm.marketplaceProductVariation.variationId == item.marketplaceProductVariation.variationId
+              itm => itm.name == item.name && itm.marketplaceProductVariation.variationId == item.variationId
             )
             marketplaceOrderItems = marketplaceOrderItems.map(marketplaceOrderitem => {
               return {
@@ -311,7 +373,7 @@ export const syncMarketplaceOrder = {
                   nonMatchedOrderItems.push({ ...item })
                 }
               })
-              if (nonMatchedOrderItems.length > 0)
+              if (nonMatchedOrderItems.length > 0 && !cancelStatuses.includes(marketplaceOrder.status))
                 await tx.getRepository(MarketplaceOrderItem).delete(nonMatchedOrderItems)
 
               existingOrderItems = marketplaceOrderItems.map(item => {

package/server/graphql/resolvers/marketplace-order-item/marketplace-order-items.ts

@@ -1,5 +1,7 @@
-import { ListParam, convertListParams } from '@things-factory/shell'
 import { getRepository } from 'typeorm'
+
+import { convertListParams, ListParam } from '@things-factory/shell'
+
 import { MarketplaceOrderItem } from '../../../entities'
 
 export const marketplaceOrderItemsResolver = {
@@ -9,6 +11,7 @@ export const marketplaceOrderItemsResolver = {
       ...convertedParams,
       relations: ['domain', 'creator', 'updater']
     })
+
     return { items, total }
   }
-}
+}

package/server/graphql/resolvers/marketplace-order-shipping/marketplace-order-shippings.ts

@@ -1,21 +1,42 @@
-import { ListParam, convertListParams } from '@things-factory/shell'
-import { getRepository } from 'typeorm'
+import { getRepository, SelectQueryBuilder } from 'typeorm'
+
+import { buildQuery, ListParam } from '@things-factory/shell'
+
 import { MarketplaceOrderShipping } from '../../../entities'
 
 export const marketplaceOrderShippingsResolver = {
   async marketplaceOrderShippings(_: any, params: ListParam, context: any) {
-    const convertedParams = convertListParams(params)
-    const [items, total] = await getRepository(MarketplaceOrderShipping).findAndCount({
-      ...convertedParams,
-      relations: [
-        'domain',
-        'marketplaceOrderItems',
-        'marketplaceOrderItems.marketplaceProductVariation',
-        'marketplaceStore',
-        'creator',
-        'updater'
-      ]
-    })
+    let dateFilter = params.filters.filter(filter => filter.name == 'createdAt')
+
+    params.filters = params.filters.filter(x => x.name != 'createdAt')
+
+    const qb: SelectQueryBuilder<MarketplaceOrderShipping> = getRepository(MarketplaceOrderShipping)
+      .createQueryBuilder('MOS')
+      .innerJoinAndSelect('MOS.marketplaceOrderItems', 'MOI')
+      .innerJoinAndSelect('MOI.marketplaceOrder', 'MO')
+      .innerJoinAndSelect('MOI.marketplaceProductVariation', 'MPV')
+      .innerJoinAndSelect('MOS.marketplaceStore', 'MS')
+      .innerJoinAndSelect('MOS.domain', 'domain')
+      .innerJoinAndSelect('MOS.creator', 'creator')
+      .leftJoinAndSelect('MOS.updater', 'updater')
+
+    buildQuery(qb, params, context, false)
+
+    if (dateFilter) {
+      if (dateFilter[0].operator == 'between') {
+        qb.andWhere('MO.orderCreatedAt BETWEEN :begin AND :end', {
+          begin: dateFilter[0].value[0],
+          end: dateFilter[0].value[1]
+        })
+      } else if (dateFilter[0].operator == 'gte') {
+        qb.andWhere('MO.orderCreatedAt >= :begin', { begin: dateFilter[0].value })
+      } else if (dateFilter[0].operator == 'lte') {
+        qb.andWhere('MO.orderCreatedAt <= :begin', { begin: dateFilter[0].value })
+      }
+    }
+
+    const [items, total] = await qb.getManyAndCount()
+
     return { items, total }
   }
 }

package/server/graphql/resolvers/marketplace-order-shipping/update-marketplace-order-shipping.ts

@@ -8,8 +8,16 @@ export const updateMarketplaceOrderShipping = {
       relations: ['marketplaceStore']
     })
 
+    if (!marketplaceOrderShipping) throw new Error(`Shipping not exist`)
+
     marketplaceOrderShipping.ownTrackingNo = patch.trackingNo
 
+    if (marketplaceOrderShipping.marketplaceStore.platform == 'lazada') {
+      if (patch?.trackingNo) {
+        patch.trackingNo = marketplaceOrderShipping.trackingNo
+      }
+    }
+
     marketplaceOrderShipping = await tx.getRepository(MarketplaceOrderShippingEntity).save({
       ...marketplaceOrderShipping,
       ...patch,

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,121 @@
+import { EntityManager, getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
+import { Domain } from '@things-factory/shell'
+
+import { MarketplaceRefundOrder, MarketplaceRefundOrderItem, MarketplaceProductVariation } from '../../../entities'
+
+export const syncAllMarketplaceRefundOrders = {
+  async syncAllMarketplaceRefundOrders(_: any, { companyDomainId, fromDate, toDate, blackListStores }, context: any) {
+    const { user, tx }: { user: User; tx: EntityManager } = context.state
+
+    const companyDomain: Domain = await getRepository(Domain).findOne(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: marketplaceStore.domain, 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: marketplaceStore.domain, name: item.variationId }
+                })
+
+              if (marketplaceStore.platform === 'lazada') {
+                existingVariation = await getRepository(MarketplaceProductVariation).findOne({
+                  where: { domain: marketplaceStore.domain, 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: marketplaceStore.domain, 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
+  }
+}

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

@@ -0,0 +1,103 @@
+import { EntityManager } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
+import { Domain } from '@things-factory/shell'
+import { MarketplaceRefundOrder, MarketplaceRefundOrderItem, MarketplaceProductVariation } from '../../../entities'
+
+export const syncMarketplaceRefundOrders = {
+  async syncMarketplaceRefundOrders(_: any, { storeId, fromDate, toDate }, context: any) {
+
+    const { domain, user, tx }: { domain: Domain; user: User; tx: EntityManager } = context.state
+
+    //@ahmedqaid, I think it would be better if this logic could be written inside a function. 
+    //That way sync-all-marketplace-refund-orders doesn't need to re-write the logic.
+    //By doing so, it would improve readability and maintainability easily.
+    const marketplaceStore: MarketplaceStore = await StoreAPI.getMarketplaceStore(storeId)
+
+    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 }
+      })
+
+      for (var i = 0; i < marketplaceRefundOrders.length; i++) {
+        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 tx.getRepository(MarketplaceRefundOrder).findOne({
+          where: { domain: marketplaceStore.domain, name: refundOrder.name },
+          relations: ['domain', 'marketplaceRefundOrderItems']
+        })
+
+        if (existingRefundOrder) {
+          marketplaceRefundOrder = {
+            ...existingRefundOrder,
+            ...marketplaceRefundOrder,
+            updater: user
+          }
+        }
+        marketplaceRefundOrder = await tx.getRepository(MarketplaceRefundOrder).save(marketplaceRefundOrder)
+
+        refundOrder.items.forEach(async (item) => {
+
+          let existingVariation: MarketplaceProductVariation = await tx.getRepository(MarketplaceProductVariation).findOne({
+            where: { domain: marketplaceStore.domain, name: item.variationId }
+          })
+
+          if (marketplaceStore.platform === 'lazada') {
+            existingVariation = await tx.getRepository(MarketplaceProductVariation).findOne({
+              where: { domain: marketplaceStore.domain, 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 tx
+            .getRepository(MarketplaceRefundOrderItem)
+            .findOne({
+              where: { domain: marketplaceStore.domain, name: item.name },
+              relations: ['domain']
+            })
+          if (existingRefundOrderItem) {
+            marketplaceRefundOrderItem = {
+              ...existingRefundOrderItem,
+              ...marketplaceRefundOrderItem,
+              updater: user
+            }
+          }
+
+          marketplaceRefundOrderItem = await tx.getRepository(MarketplaceRefundOrderItem).save(marketplaceRefundOrderItem)
+        })
+      }
+
+      if (more) page++
+      hasMorePage = more
+    }
+  }
+}

package/server/graphql/resolvers/marketplace-report/index.ts

@@ -0,0 +1,7 @@
+import { marketplaceSalesReportsResolver } from './marketplace-sales-report'
+
+export const MarketplaceReportResolver = {
+  Query: {
+    ...marketplaceSalesReportsResolver
+  }
+}