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

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

@@ -1,75 +0,0 @@
-import { autoInitialiseLogisticsByBatch } from './auto-initialise-logistics-by-batch'
-import { autoUpdateOrderReadyToShip } from './auto-update-order-ready-to-ship'
-import { cancelMarketplaceOrderResolver } from './cancel-marketplace-order'
-import { dashboardMarketplaceOrdersResolver } from './dashboard-marketplace-orders'
-import { dashboardMarketplaceSalesResolver } from './dashboard-marketplace-sales'
-import { dashboardMarketplaceSalesAverageResolver } from './dashboard-marketplace-sales-average'
-import { deleteMarketplaceOrders } from './delete-marketplace-orders'
-import { generateMarketplaceOrderResolver } from './generate-marketplace-order'
-import { getAddressList } from './get-address-list'
-import { getBranchList } from './get-branch-list'
-import { getETraxOrderDocumentFunction, getETraxOrderDocumentResolver } from './get-etrax-order-document'
-import { getLogisticsParam } from './get-logistics-param'
-import { getOrderDocumentResolver } from './get-order-document'
-import { getStoreLogistics } from './get-store-logistics'
-import { getTimeSlot } from './get-time-slot'
-import { initialiseLazadaLogisticsByBatch } from './initialise-lazada-logistics-by-batch'
-import { initialiseLogistics } from './initialise-logistics'
-import { initialiseLogisticsByBatch } from './initialise-logistics-by-batch'
-import { initialiseShopeeLogisticsByBatch } from './initialise-shopee-logistics-by-batch'
-import { marketplaceOrderResolver } from './marketplace-order'
-import { marketplaceOrdersResolver } from './marketplace-orders'
-import { marketplaceOrdersForBatchInitResolver } from './marketplace-orders-for-batch-init'
-import { marketplaceOrdersForExport } from './marketplace-orders-for-export'
-import { setMarketplaceOrderDelivered } from './set-marketplace-order-delivered'
-import { setMarketplaceOrderFailedDelivery } from './set-marketplace-order-failed-delivery'
-import { setOwnShippingProviderByOrdersResolver } from './set-own-shipping-provider-by-orders'
-import { splitOrdersByBatch } from './split-orders-by-batch'
-import { syncAllMarketplaceOrder } from './sync-all-marketplace-order'
-import { syncMarketplaceOrder } from './sync-marketplace-order'
-import { updateMarketplaceOrder } from './update-marketplace-order'
-import { updateOrderReadyToShip } from './update-order-ready-to-ship'
-import { syncShopeeAwb } from './sync-shopee-awb'
-import { syncMarketplaceOrdersByPlatform } from './sync-marketplace-orders-by-platform'
-
-export const MarketplaceOrderResolver = {
-  Query: {
-    ...marketplaceOrdersResolver,
-    ...marketplaceOrderResolver,
-    ...getOrderDocumentResolver,
-    ...getETraxOrderDocumentResolver,
-    ...getStoreLogistics,
-    ...getLogisticsParam,
-    ...getBranchList,
-    ...getAddressList,
-    ...getTimeSlot,
-    ...marketplaceOrdersForExport,
-    ...marketplaceOrdersForBatchInitResolver,
-    ...dashboardMarketplaceOrdersResolver,
-    ...dashboardMarketplaceSalesResolver,
-    ...dashboardMarketplaceSalesAverageResolver
-  },
-  Mutation: {
-    ...generateMarketplaceOrderResolver,
-    ...initialiseLogistics,
-    ...initialiseLogisticsByBatch,
-    ...setMarketplaceOrderDelivered,
-    ...setMarketplaceOrderFailedDelivery,
-    ...syncMarketplaceOrder,
-    ...syncAllMarketplaceOrder,
-    ...updateOrderReadyToShip,
-    ...deleteMarketplaceOrders,
-    ...initialiseShopeeLogisticsByBatch,
-    ...initialiseLazadaLogisticsByBatch,
-    ...cancelMarketplaceOrderResolver,
-    ...splitOrdersByBatch,
-    ...updateMarketplaceOrder,
-    ...setOwnShippingProviderByOrdersResolver,
-    ...autoInitialiseLogisticsByBatch,
-    ...autoUpdateOrderReadyToShip,
-    ...syncShopeeAwb,
-    ...syncMarketplaceOrdersByPlatform
-  }
-}
-
-export { getETraxOrderDocumentFunction }

package/server/graphql/resolvers/marketplace-order/initialise-lazada-logistics-by-batch.ts

@@ -1,165 +0,0 @@
-import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
-
-import { MarketplaceOrder, MarketplaceOrderItem } from '../../../entities'
-
-export const initialiseLazadaLogisticsByBatch = {
-  async initialiseLazadaLogisticsByBatch(_: any, { patches }, context: ResolverContext) {
-    try {
-      const { domain, tx } = context.state
-      await Promise.all(
-        patches.map(async patch => {
-          const foundMarketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-            where: { id: patch.id },
-            relations: [
-              'marketplaceStore',
-              'marketplaceOrderItems',
-              'marketplaceOrderItems.marketplaceOrderShippingItems',
-              'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping',
-              'marketplaceOrderItems.marketplaceProductVariation'
-            ]
-          })
-          if (!foundMarketplaceOrder) throw new Error('No order is found')
-
-          const storeId = foundMarketplaceOrder.marketplaceStore.id
-          const marketplaceStore: MarketplaceStore = await StoreAPI.getMarketplaceStore(storeId)
-          const storeOrder = await StoreAPI.getStoreOrder(marketplaceStore, { orderId: patch.orderNo })
-
-          const arrItemIds = storeOrder.orderItems.reduce((newItemID, item) => {
-            return [...newItemID, ...item.name.split(',')]
-          }, [])
-
-          if (
-            storeOrder?.status == 'pending' &&
-            patch.deliveryType &&
-            arrItemIds.length > 0 &&
-            patch.shippingProvider
-          ) {
-            const storeOrderItemsPBM = await StoreAPI.setStoreOrderStatusPackedByMarketplace(marketplaceStore, {
-              deliveryType: patch.deliveryType,
-              orderItemId: arrItemIds,
-              shippingProvider: patch.shippingProvider
-            })
-
-            ////// mockup function to simulate pending order
-            // const storeOrderItemsPBM = await mock_setStoreOrderStatusPackedByMarketplace(marketplaceStore, {
-            //     deliveryType: patch.deliveryType,
-            //     orderItemId: arrItemIds,
-            //     shippingProvider: patch.shippingProvider
-            //   }, patch.orderNo)
-
-            foundMarketplaceOrder.trackingNo = storeOrderItemsPBM.trackingNumber[0] || '[]'
-            foundMarketplaceOrder.otherInfoJSON = JSON.stringify({
-              deliveryType: patch.deliveryType,
-              shippingProvider: patch.shippingProvider
-            })
-          }
-
-          let updatedOrder = await StoreAPI.getStoreOrder(marketplaceStore, { orderId: patch.orderNo })
-
-          await tx.getRepository(MarketplaceOrder).save({
-            ...foundMarketplaceOrder,
-            status: updatedOrder.status,
-            orderUpdatedAt: storeOrder.orderUpdatedAt
-          })
-
-          for (let idx = 0; idx < foundMarketplaceOrder.marketplaceOrderItems.length; idx++) {
-            let matchItem = updatedOrder.orderItems.find(
-              i =>
-                i.variationId ==
-                foundMarketplaceOrder.marketplaceOrderItems[idx].marketplaceProductVariation.variationId
-            )
-
-            if (matchItem) {
-              let targetMarketplaceOrderItem = {
-                ...foundMarketplaceOrder.marketplaceOrderItems[idx],
-                shippingProvider: matchItem.shippingProvider,
-                trackingCode: matchItem.trackingNo,
-                status: matchItem.status
-              }
-
-              await tx.getRepository(MarketplaceOrderItem).save(targetMarketplaceOrderItem)
-            }
-          }
-        })
-      )
-      return true
-    } catch (error) {
-      return false
-    }
-  }
-}
-
-async function mock_setStoreOrderStatusPackedByMarketplace(marketplaceStore, req, orderNo) {
-  let order = await StoreAPI.getStoreOrder(marketplaceStore, { orderId: orderNo })
-
-  // Sample Data from response
-  // order_item_id:284297913341490
-  // package_id:'FP053011087573484'
-  // shipment_provider:'LEX MY'
-  // tracking_number:'MYMPA024700347'
-  let data = {
-    order_items: order.orderItems.reduce((acc, itm) => {
-      return [
-        ...acc,
-        ...JSON.parse(itm.trackingNo).map(t => {
-          return {
-            order_item_id: t.order_item_id,
-            tracking_number: t.tracking_code,
-            package_id: 'RANDOMSTRING',
-            shipment_provider: req.shippingProvider
-          }
-        })
-      ]
-    }, [])
-  }
-
-  var internal = {
-    denormalize: req => {
-      var { deliveryType: delivery_type, orderItemId: order_item_ids, shippingProvider: shipment_provider } = req
-      var output = '[' + order_item_ids.join(',') + ']'
-
-      return {
-        delivery_type,
-        order_item_ids: output,
-        shipment_provider
-      }
-    },
-    normalize: res => {
-      let results = res.order_items
-      results = results.reduce(
-        (orderItem, item) => {
-          orderItem = {
-            ...orderItem,
-            items: [
-              ...orderItem.items,
-              {
-                order_item_id: item.order_item_id,
-                tracking_code: item.tracking_number
-              }
-            ]
-          }
-
-          const foundtrackingNumber = orderItem.trackingNumber.find(f => f == item.tracking_number)
-
-          if (!foundtrackingNumber) {
-            orderItem = {
-              ...orderItem,
-              trackingNumber: [...orderItem.trackingNumber, item.tracking_number]
-            }
-          }
-
-          return orderItem
-        },
-        { items: [], trackingNumber: [] }
-      )
-
-      return results
-    }
-  }
-
-  const request = internal.denormalize(req)
-
-  const respond = internal.normalize(data)
-
-  return respond
-}

package/server/graphql/resolvers/marketplace-order/initialise-logistics-by-batch.ts

@@ -1,41 +0,0 @@
-import { EntityManager } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-
-import { MarketplaceOrder, MarketplaceOrderShipping } from '../../../entities'
-
-export const initialiseLogisticsByBatch = {
-  async initialiseLogisticsByBatch(_: any, { patches }, context: ResolverContext) {
-    const { user, tx } = context.state
-
-    await Promise.all(
-      patches.map(async patch => {
-        let marketplaceOrderShipping: MarketplaceOrderShipping = await tx.getRepository(MarketplaceOrderShipping).findOne({
-          where: { id: patch.id },
-          relations: ['marketplaceStore']
-        })
-
-        let marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-          where: { orderNo: marketplaceOrderShipping.orderNoRef },
-          relations: ['marketplaceStore']
-        })
-
-        if (!marketplaceOrder) throw new Error('No order is found')
-
-        marketplaceOrderShipping.trackingNo = patch?.trackingNo
-        marketplaceOrderShipping.transporter = patch?.shippingProvider
-        marketplaceOrderShipping.ownTransporter = patch?.shippingProvider
-        marketplaceOrderShipping.ownTrackingNo = patch.ownTrackingNo || patch?.trackingNo
-        marketplaceOrderShipping.trackingUrl = patch?.trackingUrl
-        await tx.getRepository(MarketplaceOrderShipping).save(marketplaceOrderShipping)
-
-        marketplaceOrder.shippingProvider = patch?.shippingProvider
-        marketplaceOrder.ownShippingProvider = patch?.shippingProvider
-        marketplaceOrder.trackingNo = patch?.trackingNo
-
-        await tx.getRepository(MarketplaceOrder).save(marketplaceOrder)
-      })
-    )
-    return true
-  }
-}

package/server/graphql/resolvers/marketplace-order/initialise-logistics.ts

@@ -1,29 +0,0 @@
-import { EntityManager } from 'typeorm'
-
-import { config } from '@things-factory/env'
-import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
-
-import { MarketplaceOrder } from '../../../entities'
-
-const shopeeConfig = config.get('marketplaceIntegrationShopee', {})
-const { v2 } = shopeeConfig
-
-export const initialiseLogistics = {
-  async initialiseLogistics(_: any, { deliveryType, orderNo }, context: ResolverContext) {
-    const { tx } = context.state
-    const foundMarketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-      where: { name: orderNo },
-      relations: ['marketplaceStore', 'marketplaceOrderItems']
-    })
-    if (!foundMarketplaceOrder) throw new Error('No order is found')
-
-    const storeId = foundMarketplaceOrder.marketplaceStore.id
-    const marketplaceStore: MarketplaceStore = await StoreAPI.getMarketplaceStore(storeId)
-
-    await StoreAPI.initLogistics(marketplaceStore, { deliveryType, orderNo })
-    if (marketplaceStore.platform == 'shopee' && v2) {
-      await StoreAPI.createShippingDocument(marketplaceStore, { orderNo })
-    }
-    return true
-  }
-}

package/server/graphql/resolvers/marketplace-order/initialise-shopee-logistics-by-batch.ts

@@ -1,97 +0,0 @@
-import { config } from '@things-factory/env'
-import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
-import { getRepository } from '@things-factory/shell'
-
-import { MarketplaceOrder, MarketplaceOrderShipping } from '../../../entities'
-
-const shopeeConfig = config.get('marketplaceIntegrationShopee', {})
-const { v2 } = shopeeConfig
-
-export const initialiseShopeeLogisticsByBatch = {
-  async initialiseShopeeLogisticsByBatch(_: any, { patches }, context: ResolverContext) {
-    await Promise.all(
-      patches.map(async patch => {
-        if (patch?.ownTrackingNo) {
-          patch.trackingNo = patch.ownTrackingNo
-        }
-        let foundMarketplaceOrder: MarketplaceOrder = await getRepository(MarketplaceOrder).findOne({
-          where: { id: patch.id },
-          relations: ['marketplaceStore', 'marketplaceOrderItems']
-        })
-        if (!foundMarketplaceOrder) throw new Error('No order is found')
-
-        const storeId = foundMarketplaceOrder.marketplaceStore.id
-        const marketplaceStore: MarketplaceStore = await StoreAPI.getMarketplaceStore(storeId)
-        let storeOrder = await StoreAPI.getStoreOrder(marketplaceStore, { orderNo: patch.orderNo })
-
-        if (storeOrder?.status == 'ready_to_ship' && patch.deliveryType) {
-          let deliveryType = {}
-          if (patch.deliveryType == 'pickup' && patch?.addressId && patch?.pickupTimeId) {
-            deliveryType = {
-              [patch.deliveryType]: {
-                addressId: patch.addressId,
-                pickupTimeId: patch.pickupTimeId
-              }
-            }
-          } else if (patch.deliveryType == 'dropoff') {
-            deliveryType = {
-              [patch.deliveryType]: {}
-            }
-
-            if (patch.branchId)
-              deliveryType[patch.deliveryType] = { ...deliveryType[patch.deliveryType], branchId: patch.branchId }
-            if (patch.senderRealName)
-              deliveryType[patch.deliveryType] = {
-                ...deliveryType[patch.deliveryType],
-                senderRealName: patch.senderRealName
-              }
-            if (patch.trackingNo)
-              deliveryType[patch.deliveryType] = { ...deliveryType[patch.deliveryType], trackingNo: patch.trackingNo }
-          } else if (patch.deliveryType == 'non_integrated') {
-            deliveryType = {
-              [patch.deliveryType]: {}
-            }
-
-            if (patch.trackingNo)
-              deliveryType[patch.deliveryType] = {
-                ...deliveryType[patch.deliveryType],
-                trackingNo: patch.trackingNo ? patch.trackingNo : patch.ownTrackingNo
-              }
-          } else {
-            return false
-          }
-
-          await StoreAPI.initLogistics(marketplaceStore, { deliveryType, orderNo: patch.orderNo })
-        }
-
-        storeOrder = await StoreAPI.getStoreOrder(marketplaceStore, { orderNo: patch.orderNo })
-
-        let marketplaceOrderShippings: MarketplaceOrderShipping[] = await getRepository(MarketplaceOrderShipping).find({
-          where: { orderNoRef: foundMarketplaceOrder.name }
-        })
-        for (let i = 0; i < marketplaceOrderShippings.length; i++) {
-          let marketplaceOrderShipping = marketplaceOrderShippings[i]
-
-          marketplaceOrderShipping.trackingNo = storeOrder?.trackingNo
-          marketplaceOrderShipping.transporter = patch?.shippingProvider || storeOrder?.orderShipping?.transporter
-          marketplaceOrderShipping.ownTransporter = patch?.shippingProvider || null
-          marketplaceOrderShipping.ownTrackingNo = patch.ownTrackingNo || null
-
-          await getRepository(MarketplaceOrderShipping).save(marketplaceOrderShipping)
-        }
-
-        foundMarketplaceOrder.shippingProvider = patch?.shippingProvider || storeOrder?.orderShipping?.transporter
-        foundMarketplaceOrder.ownShippingProvider = patch?.shippingProvider || null
-        foundMarketplaceOrder.trackingNo = storeOrder?.trackingNo
-        foundMarketplaceOrder.status = storeOrder.status
-
-        await getRepository(MarketplaceOrder).save(foundMarketplaceOrder)
-
-        // if (v2) {
-        //   await StoreAPI.createShippingDocument(marketplaceStore, { orderNo: patch.orderNo })
-        // }
-      })
-    )
-    return true
-  }
-}

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

@@ -1,12 +0,0 @@
-import { getRepository } from '@things-factory/shell'
-
-import { MarketplaceOrder } from '../../../entities'
-
-export const marketplaceOrderResolver = {
-  async marketplaceOrder(_: any, { name }, context: ResolverContext) {
-    return await getRepository(MarketplaceOrder).findOne({
-      where: { name },
-      relations: ['domain', 'marketplaceStore', 'marketplaceOrderItems', 'creator', 'updater']
-    })
-  }
-}

package/server/graphql/resolvers/marketplace-order/marketplace-orders-for-batch-init.ts

@@ -1,52 +0,0 @@
-import { convertListParams, getRepository, ListParam } from '@things-factory/shell'
-
-import { MarketplaceOrder } from '../../../entities'
-import { getLogisticsParam } from '../marketplace-order/get-logistics-param'
-
-export const marketplaceOrdersForBatchInitResolver = {
-  async marketplaceOrdersForBatchInit(_: any, params: ListParam, context: ResolverContext) {
-    const convertedParams = convertListParams({
-      ...params,
-      filters: params.filters.filter(param => param.name != 'logisticsType')
-    })
-    let [items, total] = await getRepository(MarketplaceOrder).findAndCount({
-      ...convertedParams,
-      relations: [
-        'domain',
-        'marketplaceStore',
-        'marketplaceOrderItems',
-        'marketplaceOrderItems.marketplaceOrderShippingItems',
-        'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping',
-        'marketplaceOrderItems.marketplaceProductVariation',
-        'creator',
-        'updater'
-      ]
-    })
-
-    items = await Promise.all(
-      items.map(async (itm: any) => {
-        try {
-          if (itm.marketplaceStore.platform == 'shopee' && itm.status === 'ready_to_ship') {
-            let fullLogisticsDetail = await getLogisticsParam.getLogisticsParam(
-              _,
-              { storeId: itm.marketplaceStore.id, orderNo: itm.orderNo },
-              context
-            )
-
-            return { ...itm, fullLogisticsDetail }
-          } else {
-            return itm
-          }
-        } catch (e) {
-          /**
-           * To handle the case when any order was cancelled in marketplace
-           * but not synced, it will cause an error which blocks process
-           */
-          return null
-        }
-      })
-    )
-
-    return { items: items.filter(itm => itm && itm != null), total }
-  }
-}

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

@@ -1,63 +0,0 @@
-import { In } from 'typeorm'
-
-import { getRepository } from '@things-factory/shell'
-
-import { MarketplaceOrder, MarketplaceOrderItem, MarketplaceOrderShippingItem } from '../../../entities'
-
-export const marketplaceOrdersForExport = {
-  async marketplaceOrdersForExport(_: any, { orderNos }, context: ResolverContext) {
-    const { domain } = context.state
-    const foundMarketplaceOrders: MarketplaceOrder[] = await getRepository(MarketplaceOrder).find({
-      where: { name: In(orderNos), domain: { id: domain.id } },
-      relations: [
-        'marketplaceStore',
-        'marketplaceOrderItems',
-        'marketplaceOrderItems.marketplaceOrderShippingItems',
-        'marketplaceOrderItems.marketplaceOrderShippingItems.marketplaceOrderShipping',
-        'marketplaceOrderItems.marketplaceProductVariation'
-      ]
-    })
-
-    let mergedOrder = []
-    let exportOrder = []
-    await Promise.all(
-      foundMarketplaceOrders.map((order: MarketplaceOrder) => {
-        const marketplaceOrderItems: MarketplaceOrderItem[] = order.marketplaceOrderItems
-        const orderNo = order.name
-        const shippingProvider: string = order.shippingProvider
-        const marketplaceStoreName = order.marketplaceStore.storeName
-        const marketplaceStorePlatform = order.marketplaceStore.platform
-        const status = order.status
-        const createdAt = order.orderCreatedAt
-        const updatedAt = order.orderUpdatedAt
-
-        mergedOrder = marketplaceOrderItems.map(orderItem => {
-          const marketplaceOrderShippingItems: MarketplaceOrderShippingItem[] = orderItem.marketplaceOrderShippingItems
-
-          const variationName: string = orderItem.marketplaceProductVariation.name
-          const marketplaceOrderShipping = marketplaceOrderShippingItems[0].marketplaceOrderShipping
-          const sku: string = orderItem.marketplaceProductVariation.sku
-          const itemQty: number = orderItem.qty
-          const trackingNo: string = marketplaceOrderShipping?.trackingNo
-
-          const mergedOrder: any = {
-            orderNo,
-            marketplaceStoreName,
-            marketplaceStorePlatform,
-            sku,
-            variationName,
-            trackingNo,
-            shippingProvider,
-            itemQty,
-            status,
-            createdAt,
-            updatedAt
-          }
-          exportOrder.push(mergedOrder)
-        })
-      })
-    )
-
-    return exportOrder
-  }
-}

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

@@ -1,56 +0,0 @@
-import { SelectQueryBuilder } from 'typeorm'
-
-import { buildQuery, getRepository, ListParam } from '@things-factory/shell'
-
-import { MarketplaceOrder } from '../../../entities'
-
-export const marketplaceOrdersResolver = {
-  async marketplaceOrders(_: any, params: ListParam, context: ResolverContext) {
-    let postCodeSorter = params.sortings.find(sort => sort.name === 'postCode')
-    const noOfItemsFilter = params.filters.find(param => param.name === 'itemCount')
-    const skuFilter = params.filters.find(param => param.name === 'sku')
-
-    params.sortings = params.sortings.filter(sort => sort.name !== 'postCode')
-
-    if (noOfItemsFilter && noOfItemsFilter.value == 1) {
-      params.filters.find(param => param.name === 'itemCount').operator = 'eq'
-    }
-
-    if (skuFilter) {
-      params.filters = params.filters.filter(param => param.name !== 'sku')
-    }
-
-    let qb: SelectQueryBuilder<MarketplaceOrder> = getRepository(MarketplaceOrder).createQueryBuilder('mo')
-    buildQuery(qb, params, context)
-    qb.leftJoinAndSelect('mo.domain', 'domain')
-      .leftJoinAndSelect('mo.marketplaceStore', 'ms')
-      .leftJoinAndSelect('mo.marketplaceOrderItems', 'mi')
-      .leftJoinAndSelect('mi.marketplaceOrderShippingItems', 'mosi')
-      .leftJoinAndSelect('mi.marketplaceProductVariation', 'mpv')
-      .leftJoinAndSelect('mpv.marketplaceProduct', 'mp')
-      .leftJoinAndSelect('mosi.marketplaceOrderShipping', 'mos')
-      .leftJoinAndSelect('mo.creator', 'creator')
-      .leftJoinAndSelect('mo.updater', 'updater')
-
-    if (postCodeSorter) {
-      qb.addOrderBy('mos.postCode', postCodeSorter?.desc ? 'DESC' : 'ASC')
-    }
-
-    if (skuFilter) {
-      qb.andWhere(
-        `
-        exists (select * from marketplace_order_items moi
-        inner join marketplace_product_variations mpv
-        on moi.marketplace_product_variation_id = mpv.id
-        where moi.marketplace_order_id = mo.id
-        and lower(mpv.sku) like :sku)
-      `,
-        { sku: skuFilter.value.toLowerCase() }
-      )
-    }
-
-    let [items, total] = await qb.getManyAndCount()
-
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/marketplace-order/set-marketplace-order-delivered.ts

@@ -1,25 +0,0 @@
-import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
-
-import { MarketplaceOrder } from '../../../entities'
-
-export const setMarketplaceOrderDelivered = {
-  async setMarketplaceOrderDelivered(_: any, { orderNo }, context: ResolverContext) {
-    const { tx } = context.state
-    const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-      where: { name: orderNo },
-      relations: ['marketplaceStore', 'marketplaceOrderItems']
-    })
-    if (!marketplaceOrder) throw new Error('No order is found')
-
-    const storeId = marketplaceOrder.marketplaceStore.id
-    const marketplaceStore: MarketplaceStore = await StoreAPI.getMarketplaceStore(storeId)
-
-    const storeOrder = await StoreAPI.getStoreOrder(marketplaceStore, { orderId: marketplaceOrder.orderNo })
-    const arrItemIds: string[] = storeOrder.orderItems.reduce((newItemID, item) => {
-      return [...newItemID, ...item.name.split(',')]
-    }, [])
-
-    await StoreAPI.setStoreOrderStatusDelivered(marketplaceStore, { orderItemId: arrItemIds })
-    return true
-  }
-}

package/server/graphql/resolvers/marketplace-order/set-marketplace-order-failed-delivery.ts

@@ -1,25 +0,0 @@
-import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
-
-import { MarketplaceOrder } from '../../../entities'
-
-export const setMarketplaceOrderFailedDelivery = {
-  async setMarketplaceOrderFailedDelivery(_: any, { orderNo }, context: ResolverContext) {
-    const { tx } = context.state
-    const marketplaceOrder: MarketplaceOrder = await tx.getRepository(MarketplaceOrder).findOne({
-      where: { name: orderNo },
-      relations: ['marketplaceStore', 'marketplaceOrderItems']
-    })
-    if (!marketplaceOrder) throw new Error('No order is found')
-
-    const storeId = marketplaceOrder.marketplaceStore.id
-    const marketplaceStore: MarketplaceStore = await StoreAPI.getMarketplaceStore(storeId)
-
-    const storeOrder = await StoreAPI.getStoreOrder(marketplaceStore, { orderId: marketplaceOrder.orderNo })
-    const arrItemIds: string[] = storeOrder.orderItems.reduce((newItemID, item) => {
-      return [...newItemID, ...item.name.split(',')]
-    }, [])
-
-    await StoreAPI.setStoreOrderStatusFailedDelivery(marketplaceStore, { orderItemId: arrItemIds })
-    return true
-  }
-}