@things-factory/integration-marketplace 8.0.0-beta.9 → 8.0.2

package/server/graphql/resolvers/marketplace-store/shopee/deactivate-shopee-store.ts

@@ -0,0 +1,28 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceStore } from '../../../../entities'
+import { STORE_STATUS } from '../../../constants'
+
+export const deactivateShopeeStore = {
+  async deactivateShopeeStore(_: any, { name }, context: ResolverContext) {
+    const repository = getRepository(MarketplaceStore)
+    const marketplaceStore: any = await repository.findOne({
+      where: { domain: { id: context.state.domain.id }, name }
+    })
+
+    var patch = {
+      storeId: '',
+      accessToken: '',
+      refreshToken: '',
+      accessInfo: '',
+      countryCode: '',
+      status: STORE_STATUS.INACTIVE
+    }
+
+    return await repository.save({
+      ...marketplaceStore,
+      ...patch,
+      updater: context.state.user
+    })
+  }
+}

package/server/graphql/resolvers/marketplace-store/shopee/generate-shopee-access-token.ts

@@ -0,0 +1,96 @@
+import crypto from 'crypto'
+import Debug from 'debug'
+import fetch from 'node-fetch'
+import { v4 as uuidv4 } from 'uuid'
+
+import { config } from '@things-factory/env'
+
+import { MarketplaceSetting, MarketplaceStore } from '../../../../entities'
+import { STORE_STATUS } from '../../../constants'
+
+const shopeeConfig = config.get('marketplaceIntegrationShopee', {})
+const { partnerId, partnerKey, isUAT } = shopeeConfig
+
+const debug = Debug('things-factory:integration-marketplace:generate-shopee-access-token')
+
+export const generateShopeeAccessToken = {
+  async generateShopeeAccessToken(_: any, { id, code, shopId }, context: ResolverContext): Promise<MarketplaceStore> {
+    const { domain, tx, user } = context.state
+    const repository = tx.getRepository(MarketplaceStore)
+    const marketplaceStore: MarketplaceStore = await repository.findOne({
+      where: { domain: { id: context.state.domain.id }, id }
+    })
+
+    const timestamp = Math.round(new Date().getTime() / 1000)
+
+    const host = `https://partner${isUAT ? '.test-stable' : ''}.shopeemobile.com`
+    const getTokenPath = '/api/v2/auth/token/get'
+    const signature = crypto
+      .createHmac('sha256', partnerKey)
+      .update(partnerId + getTokenPath + timestamp + shopId)
+      .digest('hex')
+
+    let authUrl = `${host}${getTokenPath}`
+    authUrl += `?partner_id=${Number(partnerId)}`
+    authUrl += `&shop_id=${shopId}`
+    authUrl += `&timestamp=${timestamp}`
+    authUrl += `&sign=${signature}`
+
+    const data: any = {
+      code,
+      shop_id: Number(shopId),
+      partner_id: Number(partnerId)
+    }
+
+    const jsondata = JSON.stringify(data)
+
+    const response = await fetch(`${authUrl}`, {
+      method: 'post',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: jsondata
+    })
+
+    if (!response.ok) {
+      debug('response result', await response.text())
+      throw new Error(`unexpected error with response code - ${response.status}`)
+    }
+
+    const result = await response.json()
+    debug('response result', result)
+
+    var patch = {
+      accessToken: result.access_token,
+      refreshToken: result.refresh_token,
+      accessInfo: JSON.stringify(result, null, 2),
+      storeId: String(shopId),
+      status: STORE_STATUS.ACTIVE
+    }
+
+    const marketplaceSettingCategories: any[] = ['stock_allocation', 'marketplace_order_max_weight']
+
+    marketplaceSettingCategories.forEach(async category => {
+      const foundMarketplaceSetting: MarketplaceSetting = await tx.getRepository(MarketplaceSetting).findOne({
+        where: { marketplaceStore: { id: marketplaceStore.id }, domain: { id: domain.id }, category }
+      })
+
+      if (!foundMarketplaceSetting) {
+        const marketplaceSetting = new MarketplaceSetting()
+        marketplaceSetting.name = uuidv4()
+        marketplaceSetting.marketplaceStore = marketplaceStore
+        marketplaceSetting.value = '100'
+        marketplaceSetting.category = category
+        marketplaceSetting.domain = domain
+        marketplaceSetting.creator = user
+        await tx.getRepository(MarketplaceSetting).save(marketplaceSetting)
+      }
+    })
+
+    return await repository.save({
+      ...marketplaceStore,
+      ...patch,
+      updater: context.state.user
+    })
+  }
+}

package/server/graphql/resolvers/marketplace-store/shopee/get-shopee-auth-url.ts

@@ -0,0 +1,18 @@
+import { Shopee } from '../../../../controllers/shopee/shopee'
+
+import { config } from '@things-factory/env'
+const shopeeConfig = config.get('marketplaceIntegrationShopee', {})
+const { partnerId, partnerKey, isUAT } = shopeeConfig
+
+export const getShopeeAuthURL = {
+  async getShopeeAuthURL(_: any, { redirectUrl, cancel = false }, context: ResolverContext) {
+    const client = new Shopee({
+      isUAT,
+      partner_id: partnerId,
+      partner_key: partnerKey,
+      redirect_uri: redirectUrl
+    })
+
+    return client.buildAuthURL(cancel)
+  }
+}

package/server/graphql/resolvers/marketplace-store/shopee/index.ts

@@ -0,0 +1,13 @@
+import { getShopeeAuthURL } from './get-shopee-auth-url'
+
+import { deactivateShopeeStore } from './deactivate-shopee-store'
+import { generateShopeeAccessToken } from './generate-shopee-access-token'
+
+export const Query = {
+  ...getShopeeAuthURL
+}
+
+export const Mutation = {
+  ...generateShopeeAccessToken,
+  ...deactivateShopeeStore
+} as any

package/server/graphql/resolvers/marketplace-store/shopify/deactivate-shopify-store.ts

@@ -0,0 +1,29 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceStore } from '../../../../entities'
+import { STORE_STATUS } from '../../../constants'
+
+export const deactivateShopifyStore = {
+  async deactivateShopifyStore(_: any, { name }, context: ResolverContext) {
+    const { domain, user } = context.state
+
+    const repository = getRepository(MarketplaceStore)
+    const marketplaceStore: any = await repository.findOne({
+      where: { domain: { id: domain.id }, name }
+    })
+
+    var patch = {
+      accessToken: '',
+      refreshToken: '',
+      accessInfo: '',
+      countryCode: '',
+      status: STORE_STATUS.INACTIVE
+    }
+
+    return await repository.save({
+      ...marketplaceStore,
+      ...patch,
+      updater: user
+    })
+  }
+}

package/server/graphql/resolvers/marketplace-store/shopify/get-shopify-auth-url.ts

@@ -0,0 +1,26 @@
+import { VerificationToken, VerificationTokenType } from '@things-factory/auth-base'
+import { config } from '@things-factory/env'
+import { getRepository } from '@things-factory/shell'
+
+import { Shopify } from '../../../../controllers/shopify'
+
+const shopifyConfig = config.get('marketplaceIntegrationShopify', {})
+const { apiKey, apiSecret } = shopifyConfig
+
+export const getShopifyAuthURL = {
+  async getShopifyAuthURL(_: any, { marketplaceStoreId, storeId, redirectUrl }, context: ResolverContext) {
+    const { user } = context.state
+    const shopify = new Shopify({ apiKey, apiSecret, shop: storeId })
+
+    /* generate verification-token as a nonce */
+    const nonce = shopify.makeVerificationTokenForNonce()
+    await getRepository(VerificationToken).save({
+      userId: user.id,
+      token: nonce,
+      type: VerificationTokenType.REQUEST_ACCESS_TOKEN,
+      suppliment: marketplaceStoreId
+    })
+
+    return shopify.buildAuthURL(redirectUrl, nonce)
+  }
+}

package/server/graphql/resolvers/marketplace-store/shopify/index.ts

@@ -0,0 +1,11 @@
+import { getShopifyAuthURL } from './get-shopify-auth-url'
+
+import { deactivateShopifyStore } from './deactivate-shopify-store'
+
+export const Query = {
+  ...getShopifyAuthURL
+}
+
+export const Mutation = {
+  ...deactivateShopifyStore
+}

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

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

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

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

package/server/graphql/resolvers/marketplace-store/woocommerce/deactivate-woocommerce-store.ts

@@ -0,0 +1,20 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceStore } from '../../../../entities'
+import { STORE_STATUS } from '../../../constants'
+
+export const deactivateWoocommerceStore = {
+  async deactivateWoocommerceStore(_: any, { name }, context: ResolverContext): Promise<MarketplaceStore> {
+    const { domain } = context.state
+    let marketplaceStore: MarketplaceStore = await getRepository(MarketplaceStore).findOne({
+      where: { domain: { id: domain.id }, name }
+    })
+
+    marketplaceStore.storeId = ''
+    marketplaceStore.accessKey = ''
+    marketplaceStore.accessSecret = ''
+    marketplaceStore.accessInfo = ''
+    marketplaceStore.status = STORE_STATUS.INACTIVE
+    return await getRepository(MarketplaceStore).save(marketplaceStore)
+  }
+}

package/server/graphql/resolvers/marketplace-store/woocommerce/get-woocommerce-auth-url.ts

@@ -0,0 +1,14 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceStore } from '../../../../entities'
+
+export const getWoocommerceAuthURL = {
+  async getWoocommerceAuthURL(_: any, { marketplaceStoreId, redirectUrl }, context: ResolverContext) {
+    const appName: string = context.request.header.origin
+    const returnURL: string = context.request.header.referer
+    let { storeURL }: MarketplaceStore = await getRepository(MarketplaceStore).findOneBy({ id: marketplaceStoreId })
+    storeURL = storeURL.replace(/\/$/, '')
+
+    return `${storeURL}/wc-auth/v1/authorize?app_name=${appName}&user_id=${marketplaceStoreId}&return_url=${returnURL}&callback_url=${redirectUrl}&scope=read_write`
+  }
+}

package/server/graphql/resolvers/marketplace-store/woocommerce/index.ts

@@ -0,0 +1,10 @@
+import { deactivateWoocommerceStore } from './deactivate-woocommerce-store'
+import { getWoocommerceAuthURL } from './get-woocommerce-auth-url'
+
+export const Query = {
+  ...getWoocommerceAuthURL
+}
+
+export const Mutation = {
+  ...deactivateWoocommerceStore
+}

package/server/graphql/resolvers/marketplace-store/zalora/deactivate-zalora-store.ts

@@ -0,0 +1,28 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceStore } from '../../../../entities'
+import { STORE_STATUS } from '../../../constants'
+
+export const deactivateZaloraStore = {
+  async deactivateZaloraStore(_: any, { name }, context: ResolverContext) {
+    const repository = getRepository(MarketplaceStore)
+    const marketplaceStore: any = await repository.findOne({
+      where: { domain: { id: context.state.domain.id }, name }
+    })
+
+    var patch = {
+      storeId: '',
+      accessToken: '',
+      refreshToken: '',
+      accessInfo: '',
+      countryCode: '',
+      status: STORE_STATUS.INACTIVE
+    }
+
+    return await repository.save({
+      ...marketplaceStore,
+      ...patch,
+      updater: context.state.user
+    })
+  }
+}

package/server/graphql/resolvers/marketplace-store/zalora/generate-zalora-access-token.ts

@@ -0,0 +1,55 @@
+import { v4 as uuidv4 } from 'uuid'
+
+import { MarketplaceSetting, MarketplaceStore } from '../../../../entities'
+import { STORE_STATUS } from '../../../constants'
+
+export const generateZaloraAccessToken = {
+  async generateZaloraAccessToken(_: any, { id, apiKey, userId, countryCode }, context: ResolverContext) {
+    const { domain, user, tx } = context.state
+    const repository = tx.getRepository(MarketplaceStore)
+    const marketplaceStore: any = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    var patch = {
+      accessToken: apiKey,
+      refreshToken: '',
+      accessInfo: JSON.stringify(
+        {
+          userId: userId,
+          apiKey: apiKey
+        },
+        null,
+        2
+      ),
+      storeId: userId,
+      countryCode,
+      status: STORE_STATUS.ACTIVE
+    }
+
+    const marketplaceSettingCategories: any[] = ['stock_allocation', 'marketplace_order_max_weight']
+
+    marketplaceSettingCategories.forEach(async category => {
+      const foundMarketplaceSetting: MarketplaceSetting = await tx.getRepository(MarketplaceSetting).findOne({
+        where: { marketplaceStore: { id: marketplaceStore.id }, domain: { id: domain.id }, category }
+      })
+
+      if (!foundMarketplaceSetting) {
+        const marketplaceSetting = new MarketplaceSetting()
+        marketplaceSetting.name = uuidv4()
+        marketplaceSetting.marketplaceStore = marketplaceStore
+        marketplaceSetting.value = '100'
+        marketplaceSetting.category = category
+        marketplaceSetting.domain = domain
+        marketplaceSetting.creator = user
+        await tx.getRepository(MarketplaceSetting).save(marketplaceSetting)
+      }
+    })
+
+    return await repository.save({
+      ...marketplaceStore,
+      ...patch,
+      updater: user
+    })
+  }
+}

package/server/graphql/resolvers/marketplace-store/zalora/index.ts

@@ -0,0 +1,9 @@
+import { deactivateZaloraStore } from './deactivate-zalora-store'
+import { generateZaloraAccessToken } from './generate-zalora-access-token'
+
+export const Query = {}
+
+export const Mutation = {
+  ...generateZaloraAccessToken,
+  ...deactivateZaloraStore
+}

package/server/graphql/resolvers/marketplace-transporter/create-marketplace-transporter.ts

@@ -0,0 +1,21 @@
+import { v4 as uuidv4 } from 'uuid'
+
+import { CourierService } from '@things-factory/integration-lmd'
+
+import { MarketplaceStore, MarketplaceTransporter } from '../../../entities'
+
+export const createMarketplaceTransporter = {
+  async createMarketplaceTransporter(_: any, { marketplaceStoreId, deliveryTransporter }, context: ResolverContext) {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(MarketplaceTransporter).save({
+      name: uuidv4().toString(),
+      marketplaceStore: await tx.getRepository(MarketplaceStore).findOneBy({ id: marketplaceStoreId }),
+      deliveryTransporter: await tx.getRepository(CourierService).findOneBy({ id: deliveryTransporter }),
+      pickupTransporter: await tx.getRepository(CourierService).findOneBy({ id: deliveryTransporter }),
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+} as any

package/server/graphql/resolvers/marketplace-transporter/delete-marketplace-transporter.ts

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

package/server/graphql/resolvers/marketplace-transporter/delete-marketplace-transporters.ts

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

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

@@ -0,0 +1,19 @@
+import { Query, MarketplaceTransporter } from './marketplace-transporter-query'
+
+import { updateMarketplaceTransporter } from './update-marketplace-transporter'
+import { updateMultipleMarketplaceTransporter } from './update-multiple-marketplace-transporter'
+import { createMarketplaceTransporter } from './create-marketplace-transporter'
+import { deleteMarketplaceTransporter } from './delete-marketplace-transporter'
+import { deleteMarketplaceTransporters } from './delete-marketplace-transporters'
+
+export const MarketplaceTransporterResolver = {
+  MarketplaceTransporter,
+  Query,
+  Mutation: {
+    ...updateMarketplaceTransporter,
+    ...updateMultipleMarketplaceTransporter,
+    ...createMarketplaceTransporter,
+    ...deleteMarketplaceTransporter,
+    ...deleteMarketplaceTransporters
+  }
+} as any

package/server/graphql/resolvers/marketplace-transporter/marketplace-transporter-query.ts

@@ -0,0 +1,60 @@
+import { convertListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { MarketplaceStore, MarketplaceTransporter as MarketplaceTransporterEntity } from '../../../entities'
+
+export const Query = {
+  async marketplaceTransporter(_: any, { marketplaceStoreId }, context: ResolverContext) {
+    const { domain, tx } = context.state
+    const marketplaceStore: MarketplaceStore = await tx
+      .getRepository(MarketplaceStore)
+      .findOneBy({ id: marketplaceStoreId })
+
+    const marketplaceTransporter = await tx.getRepository(MarketplaceTransporterEntity).findOne({
+      where: { domain: { id: domain.id }, marketplaceStore: { id: marketplaceStore.id } },
+      relations: ['marketplaceStore', 'deliveryTransporter', 'pickupTransporter']
+    })
+
+    return marketplaceTransporter
+  },
+
+  async marketplaceTransporters(_: any, params: ListParam, context: ResolverContext) {
+    const { tx } = context.state
+
+    const convertedParams = convertListParams(params)
+    const [items, total] = await tx.getRepository(MarketplaceTransporterEntity).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'marketplaceStore', 'pickupTransporter', 'deliveryTransporter']
+    })
+
+    return { items, total }
+  }
+}
+
+export const MarketplaceTransporter = {
+  async domain(marketplaceTransporter) {
+    return (
+      await getRepository(MarketplaceTransporterEntity).findOne({
+        where: { id: marketplaceTransporter.id },
+        relations: ['domain']
+      })
+    )?.domain
+  },
+
+  async creator(marketplaceTransporter) {
+    return (
+      await getRepository(MarketplaceTransporterEntity).findOne({
+        where: { id: marketplaceTransporter.id },
+        relations: ['creator']
+      })
+    )?.creator
+  },
+
+  async updater(marketplaceTransporter) {
+    return (
+      await getRepository(MarketplaceTransporterEntity).findOne({
+        where: { id: marketplaceTransporter.id },
+        relations: ['updater']
+      })
+    )?.updater
+  }
+}

package/server/graphql/resolvers/marketplace-transporter/update-marketplace-transporter.ts

@@ -0,0 +1,25 @@
+import { CourierService } from '@things-factory/integration-lmd'
+
+import { MarketplaceTransporter } from '../../../entities'
+
+export const updateMarketplaceTransporter = {
+  async updateMarketplaceTransporter(_: any, { marketplaceStoreId, deliveryTransporter }, context: ResolverContext) {
+    const { domain, user, tx } = context.state
+    const marketplaceTransporterRepo = tx.getRepository(MarketplaceTransporter)
+
+    const marketplaceTransporter: MarketplaceTransporter = await marketplaceTransporterRepo.findOne({
+      where: {
+        domain: { id: domain.id },
+        marketplaceStore: { id: marketplaceStoreId }
+      },
+      relations: ['deliveryTransporter', 'pickupTransporter']
+    })
+
+    return await marketplaceTransporterRepo.save({
+      ...marketplaceTransporter,
+      deliveryTransporter: await tx.getRepository(CourierService).findOneBy({ id: deliveryTransporter }),
+      pickupTransporter: await tx.getRepository(CourierService).findOneBy({ id: deliveryTransporter }),
+      updater: user
+    })
+  }
+} as any

package/server/graphql/resolvers/marketplace-transporter/update-multiple-marketplace-transporter.ts

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

package/server/graphql/resolvers/store-order/accept-store-order-cancellation.ts

@@ -0,0 +1,9 @@
+import { StoreAPI } from '../../../controllers/store-api'
+
+export const acceptStoreOrderCancellation = {
+  async acceptStoreOrderCancellation(_: any, { storeId, orderId }, context: ResolverContext) {
+    // only in Shopee, to accept buyer order cancellation
+    var store = await StoreAPI.getMarketplaceStore(storeId)
+    return await StoreAPI.acceptStoreOrderCancellation(store, orderId)
+  }
+}