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

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

@@ -0,0 +1,106 @@
+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 { MarketplaceProductVariation, MarketplaceRefundOrder, MarketplaceRefundOrderItem } from '../../../entities'
+
+export const syncMarketplaceRefundOrders = {
+  async syncMarketplaceRefundOrders(_: any, { storeId, fromDate, toDate }, context: ResolverContext) {
+    const { domain, user, tx } = 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: { id: marketplaceStore.domain.id }, 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: { id: marketplaceStore.domain.id }, name: item.variationId }
+            })
+
+          if (marketplaceStore.platform === 'lazada') {
+            existingVariation = await tx.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 tx
+            .getRepository(MarketplaceRefundOrderItem)
+            .findOne({
+              where: { domain: { id: marketplaceStore.domain.id }, 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,143 @@
+import { SelectQueryBuilder } from 'typeorm'
+
+import { buildQuery, getRepository, ListParam } from '@things-factory/shell'
+
+import { MarketplaceOrderItem } from '../../../entities'
+
+export const marketplaceSalesReportsResolver = {
+  async marketplaceSalesReports(_: any, params: ListParam, context: ResolverContext) {
+    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.marketplaceOrderShippingItems', 'mosi')
+      .leftJoinAndSelect('mosi.marketplaceOrderShipping', 'mos')
+      .leftJoinAndSelect('moi.marketplaceOrder', 'mo')
+      .leftJoinAndSelect('mo.fulfillmentCenter', 'fc')
+      .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 {
+        fulfilmentCenter: item.fc_name,
+        orderNo: item.mo_name,
+        orderCreatedAt: item.mo_order_created_at,
+        buyerUsername: item.mo_buyer_username,
+        payoutDate: item.mo_payout_date,
+        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_sku,
+        qty: item.moi_qty,
+        variationId: item.mpv_variation_id,
+        variationName: item.mpv_name,
+        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,
+        voucherAmount: item.mo_voucher_amount,
+        shippingRebate: item.mo_shipping_rebate,
+        commissionFee: item.mo_commission_fee,
+        serviceFee: item.mo_service_fee,
+        transactionFee: item.mo_transaction_fee,
+        totalRealeasedAmount: item.mo_total_realeased_amount,
+        voucherCode: item.mo_voucher_code,
+        shippingMode: item.mo_shipping_mode,
+        status: item.mo_status,
+        shippingFeePaidByCustomer: item.moi_shipping_fee_paid_by_customer,
+        promotionalCharges: item.moi_promotional_charges,
+        ordersMarketplaceFeesTotal: item.moi_orders_marketplace_fees_total,
+        ordersMarketingFeesTotal: item.moi_orders_marketing_fees_total,
+        ordersSalesTotal: item.moi_orders_sales_total,
+        ordersLogisticsTotal: item.moi_orders_logistics_total,
+        itemPriceCredit: item.moi_item_price_credit,
+        marketplaceBonus: item.moi_marketplace_bonus + item.moi_marketplace_bonus_seller,
+        marketplaceBonusSeller: item.moi_marketplace_bonus_seller,
+        shippingFeeDiscountMarketplace: item.moi_shipping_fee_discount_marketplace,
+        shippingFeeDiscountSeller: item.moi_shipping_fee_discount_seller,
+        promotionalChargesFlexiCombo: item.moi_promotional_charges_flexi_combo,
+        autoShippingSubsidyMarketplace: item.moi_auto_shipping_subsidy_marketplace,
+        grandTotal:
+          item.moi_orders_marketplace_fees_total +
+          item.moi_orders_marketing_fees_total +
+          item.moi_orders_sales_total +
+          item.moi_orders_logistics_total,
+        originalShippingFee: item.moi_original_shipping_fee,
+        taxAmount: item.moi_tax_amount,
+        itemCommissionFee: item.moi_commission_fee,
+        variationSku: item.mpv_variation_sku,
+        address1: item.mos_address_1,
+        address2: item.mos_address_2,
+        address3: item.mos_address_3,
+        city: item.mos_city,
+        state: item.mos_state,
+        postcode: item.mos_post_code,
+        trackingNo: item.moi_tracking_code
+      }
+    })
+
+    return { items, total }
+  }
+}

package/server/graphql/resolvers/store-replenishment/create-store-replenishment.ts

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

package/server/graphql/resolvers/store-replenishment/delete-store-replenishment.ts

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

package/server/graphql/resolvers/store-replenishment/delete-store-replenishments.ts

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

package/server/graphql/resolvers/store-replenishment/index.ts

@@ -0,0 +1,19 @@
+import { Query, StoreReplenishment } from './store-replenishment-query'
+
+import { updateStoreReplenishment } from './update-store-replenishment'
+import { updateMultipleStoreReplenishment } from './update-multiple-store-replenishment'
+import { createStoreReplenishment } from './create-store-replenishment'
+import { deleteStoreReplenishment } from './delete-store-replenishment'
+import { deleteStoreReplenishments } from './delete-store-replenishments'
+
+export const StoreReplenishmentResolver = {
+  StoreReplenishment,
+  Query,
+  Mutation: {
+    ...updateStoreReplenishment,
+    ...updateMultipleStoreReplenishment,
+    ...createStoreReplenishment,
+    ...deleteStoreReplenishment,
+    ...deleteStoreReplenishments
+  }
+}

package/server/graphql/resolvers/store-replenishment/store-replenishment-query.ts

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

package/server/graphql/resolvers/store-replenishment/update-multiple-store-replenishment.ts

@@ -0,0 +1,49 @@
+import { getRepository } from '@things-factory/shell'
+
+import { StoreReplenishment } from '../../../entities'
+
+export const updateMultipleStoreReplenishment = {
+  async updateMultipleStoreReplenishment(_: 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 storeReplenishmentRepo = getRepository(StoreReplenishment)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await storeReplenishmentRepo.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 storeReplenishment = await storeReplenishmentRepo.findOneBy({
+          domain: { id: domain.id },
+          id: newRecord.id
+        })
+
+        const result = await storeReplenishmentRepo.save({
+          ...storeReplenishment,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+}

package/server/graphql/resolvers/store-replenishment/update-store-replenishment.ts

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

package/server/graphql/resolvers/store-replenishment-item/create-store-replenishment-item.ts

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

package/server/graphql/resolvers/store-replenishment-item/delete-store-replenishment-item.ts

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

package/server/graphql/resolvers/store-replenishment-item/delete-store-replenishment-items.ts

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

package/server/graphql/resolvers/store-replenishment-item/index.ts

@@ -0,0 +1,19 @@
+import { Query, StoreReplenishmentItem } from './store-replenishment-item-query'
+
+import { updateStoreReplenishmentItem } from './update-store-replenishment-item'
+import { updateMultipleStoreReplenishmentItem } from './update-multiple-store-replenishment-item'
+import { createStoreReplenishmentItem } from './create-store-replenishment-item'
+import { deleteStoreReplenishmentItem } from './delete-store-replenishment-item'
+import { deleteStoreReplenishmentItems } from './delete-store-replenishment-items'
+
+export const StoreReplenishmentItemResolver = {
+  StoreReplenishmentItem,
+  Query,
+  Mutation: {
+    ...updateStoreReplenishmentItem,
+    ...updateMultipleStoreReplenishmentItem,
+    ...createStoreReplenishmentItem,
+    ...deleteStoreReplenishmentItem,
+    ...deleteStoreReplenishmentItems
+  }
+}

package/server/graphql/resolvers/store-replenishment-item/store-replenishment-item-query.ts

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

package/server/graphql/resolvers/store-replenishment-item/update-multiple-store-replenishment-item.ts

@@ -0,0 +1,49 @@
+import { getRepository } from '@things-factory/shell'
+
+import { StoreReplenishmentItem } from '../../../entities'
+
+export const updateMultipleStoreReplenishmentItem = {
+  async updateMultipleStoreReplenishmentItem(_: 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 storeReplenishmentItemRepo = getRepository(StoreReplenishmentItem)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await storeReplenishmentItemRepo.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 storeReplenishmentItem = await storeReplenishmentItemRepo.findOneBy({
+          domain: { id: domain.id },
+          id: newRecord.id
+        })
+
+        const result = await storeReplenishmentItemRepo.save({
+          ...storeReplenishmentItem,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+}

package/server/graphql/resolvers/store-replenishment-item/update-store-replenishment-item.ts

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

package/server/graphql/types/index.ts

@@ -0,0 +1,13 @@
+export * from './marketplace-order'
+export * from './marketplace-order-item'
+export * from './marketplace-order-shipping'
+export * from './marketplace-product'
+export * from './marketplace-product-attribute'
+export * from './marketplace-product-category'
+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'
+export * from './marketplace-order-shipping-item'

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

@@ -0,0 +1,13 @@
+import gql from 'graphql-tag'
+
+export const DashboardOrder = gql`
+  type DashboardOrder {
+    date: String
+    cancelledCount: Int
+    nonCancelledCount: Int
+    salesAvg: Float
+    shopee: Float
+    lazada: Float
+    zalora: Float
+  }
+`