@things-factory/marketplace-base 3.7.6 → 3.7.10

package/server/entities/marketplace-refund-order.ts

@@ -0,0 +1,62 @@
+import {
+  Column,
+  CreateDateColumn,
+  Entity,
+  Index,
+  ManyToOne,
+  OneToMany,
+  PrimaryGeneratedColumn,
+  UpdateDateColumn
+} from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { MarketplaceRefundOrderItem, MarketplaceOrder } from '../entities'
+import { Domain } from '@things-factory/shell'
+
+@Entity()
+@Index(
+  'ix_marketplace-refund-order_0',
+  (marketplaceRefundOrder: MarketplaceRefundOrder) => [marketplaceRefundOrder.domain, marketplaceRefundOrder.name],
+  { unique: true }
+)
+export class MarketplaceRefundOrder {
+    @PrimaryGeneratedColumn('uuid')
+    id: string
+  
+    @ManyToOne(type => Domain)
+    domain: Domain
+
+    @Column()
+    name: string  
+  
+    @OneToMany(type => MarketplaceRefundOrderItem, marketplaceRefundOrderItem => marketplaceRefundOrderItem.marketplaceRefundOrder)
+    marketplaceRefundOrderItems: MarketplaceRefundOrderItem[]
+
+    @Column()
+    originalOrderNo: string
+
+    @Column()
+    orderNo: string
+
+    @Column({ nullable: true, type: 'float' })
+    amount: number
+
+    @Column({ nullable: true })
+    status: string
+
+    @CreateDateColumn()
+    createdAt: Date
+  
+    @UpdateDateColumn()
+    updatedAt: Date
+  
+    @ManyToOne(type => User, {
+      nullable: true
+    })
+    creator: User
+  
+    @ManyToOne(type => User, {
+      nullable: true
+    })
+    updater: User    
+}

package/server/graphql/resolvers/index.ts

@@ -7,5 +7,7 @@ export * from './marketplace-product-category'
 export * from './marketplace-product-variation'
 export * from './store-replenishment'
 export * from './store-replenishment-item'
+export * from './marketplace-refund-order'
+export * from './marketplace-report'
 
 export * from './marketplace-product-variation-price'

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

@@ -6,7 +6,7 @@ import { MarketplaceOrder } from '../../../entities'
 
 export const marketplaceOrdersResolver = {
   async marketplaceOrders(_: any, params: ListParam, context: any) {
-    let postCodeSorter = params.sortings.filter(sort => sort.name === 'postCode')
+    let postCodeSorter = params.sortings.find(sort => sort.name === 'postCode')
 
     params.sortings = params.sortings.filter(sort => sort.name !== 'postCode')
 
@@ -22,26 +22,11 @@ export const marketplaceOrdersResolver = {
       .leftJoinAndSelect('mo.updater', 'updater')
 
     if (postCodeSorter) {
-      qb.addOrderBy('mos.postCode', postCodeSorter[0]?.desc ? 'DESC' : 'ASC')
+      qb.addOrderBy('mos.postCode', postCodeSorter?.desc ? 'DESC' : 'ASC')
     }
 
     let [items, total] = await qb.getManyAndCount()
 
-    // const convertedParams = convertListParams(params, context.state.domain.id)
-    // const [items, total] = await getRepository(MarketplaceOrder).findAndCount({
-    //   ...convertedParams,
-    //   relations: [
-    //     'domain',
-    //     'marketplaceStore',
-    //     'marketplaceOrderItems',
-    //     'marketplaceOrderItems.marketplaceProductVariation',
-    //     'marketplaceOrderItems.marketplaceProductVariation.marketplaceProduct',
-    //     'marketplaceOrderItems.marketplaceOrderShipping',
-    //     'creator',
-    //     'updater'
-    //   ]
-    // })
-
     return { items, total }
   }
 }

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

@@ -92,6 +92,8 @@ export const syncAllMarketplaceOrder = {
             marketplaceOrder.orderUpdatedAt = order.orderUpdatedAt
             marketplaceOrder.marketplaceStore = marketplaceStore
             marketplaceOrder.domain = marketplaceStore.domain
+            marketplaceOrder.buyerUsername = order.buyerUsername
+            marketplaceOrder.payTime = order.payTime
 
             const existingMarketplaceOrder: MarketplaceOrder = await getRepository(MarketplaceOrder).findOne({
               where: { domain: marketplaceStore.domain, name: order.name },
@@ -174,9 +176,9 @@ export const syncAllMarketplaceOrder = {
             marketplaceOrder = await getRepository(MarketplaceOrder).save(marketplaceOrder)
 
             let savedMarketplaceOrderShipping: MarketplaceOrderShipping = new MarketplaceOrderShipping()
+            let savedMarketplaceOrderShippings: MarketplaceOrderShipping[] = []
 
             if (order?.orderShipping) {
-              let savedMarketplaceOrderShippings: MarketplaceOrderShipping[] = []
               const orderShipping: any = order.orderShipping
 
               let marketplaceOrderShipping: MarketplaceOrderShipping = new MarketplaceOrderShipping()
@@ -189,15 +191,20 @@ export const syncAllMarketplaceOrder = {
               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
+              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) {
@@ -221,7 +228,11 @@ export const syncAllMarketplaceOrder = {
                       postCode: orderShipping.postCode,
                       phone1: orderShipping.phone1,
                       phone2: orderShipping.phone2,
-                      trackingNo: order.trackingNo
+                      trackingNo: order.trackingNo,
+                      shippingFee: orderShipping.shippingFee,
+                      actualShippingFee: orderShipping.actualShippingFee,
+                      marketplaceShippingFeeVoucher: orderShipping.marketplaceShippingFeeVoucher,
+                      sellerShippingFeeVoucher: orderShipping.sellerShippingFeeVoucher
                     }
                   })
 
@@ -229,19 +240,21 @@ export const syncAllMarketplaceOrder = {
                     existingOrderShippings
                   )
                 } else {
-                  let existingOrderShipping: MarketplaceOrderShipping
-                  existingOrderShipping = existingMarketplaceOrder.marketplaceOrderItems[0].marketplaceOrderShipping
-
-                  marketplaceOrderShipping = {
-                    ...existingOrderShipping,
-                    ...marketplaceOrderShipping,
-                    trackingNo: order?.trackingNo ? order.trackingNo : existingOrderShipping.trackingNo,
-                    updater: user
-                  }
+                  if (existingMarketplaceOrder?.marketplaceOrderItems) {
+                    let existingOrderShipping: MarketplaceOrderShipping
+                    existingOrderShipping = existingMarketplaceOrder.marketplaceOrderItems[0].marketplaceOrderShipping
+
+                    marketplaceOrderShipping = {
+                      ...existingOrderShipping,
+                      ...marketplaceOrderShipping,
+                      trackingNo: order?.trackingNo ? order.trackingNo : existingOrderShipping.trackingNo,
+                      updater: user
+                    }
 
-                  savedMarketplaceOrderShipping = await getRepository(MarketplaceOrderShipping).save(
-                    marketplaceOrderShipping
-                  )
+                    savedMarketplaceOrderShipping = await getRepository(MarketplaceOrderShipping).save(
+                      marketplaceOrderShipping
+                    )
+                  }
                 }
               } else {
                 savedMarketplaceOrderShipping = await getRepository(MarketplaceOrderShipping).save(
@@ -282,7 +295,13 @@ export const syncAllMarketplaceOrder = {
               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
+              if (marketplaceStore.platform === 'lazada' && item.paymentFee) {
+                marketplaceOrderItem.paymentFee = item.paymentFee
+              }
 
               marketplaceOrderItems.push({ ...marketplaceOrderItem })
 
@@ -390,6 +409,8 @@ export const syncAllMarketplaceOrder = {
 
           if (more) page++
           hasMorePage = more
+        } else {
+          hasMorePage = false
         }
       }
     }

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

@@ -183,8 +183,8 @@ export const syncMarketplaceOrder = {
           marketplaceOrderShipping.marketplaceStore = marketplaceStore
           marketplaceOrderShipping.creator = user
           marketplaceOrderShipping.domain = marketplaceStore.domain
-          marketplaceOrderShipping.shippingFee = parseFloat(orderShipping.shippingFee)
-          marketplaceOrderShipping.actualShippingFee = parseFloat(orderShipping.actualShippingFee)
+          marketplaceOrderShipping.shippingFee = orderShipping.shippingFee
+          marketplaceOrderShipping.actualShippingFee = orderShipping.actualShippingFee
           marketplaceOrderShipping.marketplaceShippingFeeVoucher = orderShipping.marketplaceShippingFeeVoucher
           marketplaceOrderShipping.sellerShippingFeeVoucher = orderShipping.sellerShippingFeeVoucher
 
@@ -212,7 +212,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
                 }
               })
 
@@ -279,6 +283,9 @@ export const syncMarketplaceOrder = {
           marketplaceOrderItem.discount = item.discount
           marketplaceOrderItem.promotionId = item.promotionId
           marketplaceOrderItem.creator = user
+          if (marketplaceStore.platform === 'lazada' && item.paymentFee) {
+            marketplaceOrderItem.paymentFee = item.paymentFee
+          }
 
           marketplaceOrderItems.push({ ...marketplaceOrderItem })
 

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-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
+  }
+}

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

@@ -0,0 +1,100 @@
+import { getRepository, SelectQueryBuilder } from 'typeorm'
+
+import { buildQuery, ListParam } from '@things-factory/shell'
+
+import { MarketplaceOrderItem } from '../../../entities'
+
+export const marketplaceSalesReportsResolver = {
+  async marketplaceSalesReports(_: any, params: ListParam, context: any) {
+    const { page, limit } = params.pagination
+
+    let marketplaceStoreSorter = params.sortings.find(sort => sort.name === 'marketplaceStore')
+    let orderNoSorter = params.sortings.find(sort => sort.name === 'orderNo')
+
+    let platformFilter = params.filters.find(filter => filter.name === 'platform')
+    let marketplaceStoreFilter = params.filters.find(filter => filter.name === 'marketplaceStoreId')
+    let fromDateFilter = params.filters.find(filter => filter.name === 'fromDate')
+    let toDateFilter = params.filters.find(filter => filter.name === 'toDate')
+
+    params.sortings = params.sortings.filter(sort => ['marketplaceStore', 'orderNo'].indexOf(sort.name) == -1)
+    params.filters = params.filters.filter(
+      filter => ['platform', 'marketplaceStoreId', 'fromDate', 'toDate'].indexOf(filter.name) == -1
+    )
+
+    let qb: SelectQueryBuilder<MarketplaceOrderItem> = getRepository(MarketplaceOrderItem).createQueryBuilder('moi')
+    buildQuery(qb, params, context)
+    qb.leftJoinAndSelect('moi.domain', 'domain')
+      .leftJoinAndSelect('moi.marketplaceOrderShipping', 'mos')
+      .leftJoinAndSelect('moi.marketplaceOrder', 'mo')
+      .leftJoinAndSelect('mo.marketplaceStore', 'ms')
+      .leftJoinAndSelect('moi.marketplaceProductVariation', 'mpv')
+      .leftJoinAndSelect('mpv.marketplaceProduct', 'mp')
+      .leftJoinAndSelect('moi.creator', 'creator')
+      .leftJoinAndSelect('moi.updater', 'updater')
+      .leftJoinAndSelect(
+        'marketplace_refund_orders',
+        'mro',
+        'mo.name = mro.original_order_no AND mo.domain_id = mro.domain_id'
+      )
+
+    if (marketplaceStoreSorter) {
+      qb.addOrderBy('ms.name', marketplaceStoreSorter.desc ? 'DESC' : 'ASC')
+    }
+
+    if (orderNoSorter) {
+      qb.addOrderBy('mo.name', orderNoSorter.desc ? 'DESC' : 'ASC')
+    }
+
+    if (platformFilter) {
+      qb.andWhere('ms.platform = :platform', { platform: platformFilter.value })
+    }
+
+    if (marketplaceStoreFilter) {
+      qb.andWhere('ms.id = :marketplaceStore', { marketplaceStore: marketplaceStoreFilter.value })
+    }
+
+    if (fromDateFilter && toDateFilter) {
+      qb.andWhere('mo.order_created_at BETWEEN :fromDate AND :toDate', {
+        fromDate: fromDateFilter.value,
+        toDate: toDateFilter.value
+      })
+    }
+
+    let items = await qb
+      .offset((page - 1) * limit)
+      .limit(limit)
+      .getRawMany()
+
+    const total = await qb.getCount()
+
+    items = items.map(item => {
+      return {
+        orderNo: item.mo_name,
+        orderCreatedAt: item.mo_order_created_at,
+        buyerUsername: item.mo_buyer_username,
+        payTime: item.mo_pay_time,
+        totalAmount: item.mo_total_amount,
+        refundAmount: item.mro_amount,
+        shippingProvider: item.mo_shipping_provider,
+        storeName: item.ms_name,
+        storeDescription: item.ms_description,
+        promotionId: item.moi_promotion_id,
+        originalPrice: item.moi_original_price,
+        paidPrice: item.moi_paid_price,
+        sku: item.mpv_name,
+        qty: item.moi_qty,
+        variationSku: item.mpv_variation_sku,
+        productName: item.mp_name,
+        productSku: item.mp_isku,
+        productDiscount: item.moi_discount,
+        paymentFee: item.moi_payment_fee,
+        shippingFee: item.mos_shipping_fee,
+        actualShippingFee: item.mos_actual_shipping_fee,
+        marketplaceShippingFeeVoucher: item.mos_marketplace_shipping_fee_voucher,
+        sellerShippingFeeVoucher: item.mos_seller_shipping_fee_voucher
+      }
+    })
+
+    return { items, total }
+  }
+}

package/server/graphql/types/index.ts

@@ -8,3 +8,5 @@ export * from './marketplace-product-variation'
 export * from './store-replenishment'
 export * from './store-replenishment-item'
 export * from './marketplace-product-variation-price'
+export * from './marketplace-refund-order'
+export * from './marketplace-report'

package/server/graphql/types/marketplace-order-item/marketplace-order-item.ts

@@ -23,6 +23,7 @@ export const MarketplaceOrderItem = gql`
     originalPrice: Float
     discount: Float
     promotionId: String
+    paymentFee: Float
     updater: User
     creator: User
     updatedAt: String

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

@@ -0,0 +1,16 @@
+import gql from 'graphql-tag'
+
+export * from './marketplace-refund-order'
+export * from './marketplace-refund-order-list'
+
+export const MarketplaceRefundOrderResolver = gql`
+  extend type Mutation {
+    syncMarketplaceRefundOrders(storeId: String!, fromDate: String, toDate: String): Boolean @transaction
+    syncAllMarketplaceRefundOrders(
+      companyDomainId: String
+      fromDate: String
+      toDate: String
+      blackListStores: [String]
+    ): Boolean
+  }
+`

package/server/graphql/types/marketplace-refund-order/marketplace-refund-order-list.ts

@@ -0,0 +1,8 @@
+import gql from 'graphql-tag'
+
+export const MarketplaceRefundOrderList = gql`
+  type MarketplaceRefundOrderList {
+    items: [MarketplaceRefundOrder]
+    total: Int
+  }
+`