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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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