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

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

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

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

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

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

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

package/server/graphql/resolvers/marketplace-setting/delete-marketplace-settings.ts

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

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

@@ -0,0 +1,19 @@
+import { Query, MarketplaceSetting } from './marketplace-setting-query'
+
+import { updateMarketplaceSetting } from './update-marketplace-setting'
+import { updateMultipleMarketplaceSetting } from './update-multiple-marketplace-setting'
+import { createMarketplaceSetting } from './create-marketplace-setting'
+import { deleteMarketplaceSetting } from './delete-marketplace-setting'
+import { deleteMarketplaceSettings } from './delete-marketplace-settings'
+
+export const MarketplaceSettingResolver = {
+  MarketplaceSetting,
+  Query,
+  Mutation: {
+    ...updateMarketplaceSetting,
+    ...updateMultipleMarketplaceSetting,
+    ...createMarketplaceSetting,
+    ...deleteMarketplaceSetting,
+    ...deleteMarketplaceSettings
+  }
+} as any

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

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

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

@@ -0,0 +1,32 @@
+import { MarketplaceSetting, MarketplaceStore } from '../../../entities'
+
+export const updateMarketplaceSetting = {
+  async updateMarketplaceSetting(_: any, { marketplaceSettingPatch }, context: ResolverContext) {
+    const { domain, user, tx } = context.state
+    const marketplaceSettingRepo = tx.getRepository(MarketplaceSetting)
+    const marketplaceStoreRepo = tx.getRepository(MarketplaceStore)
+
+    await Promise.all(
+      marketplaceSettingPatch.map(async settingPatch => {
+        const marketplaceStore: MarketplaceStore = await marketplaceStoreRepo.findOneBy({
+          id: settingPatch?.marketplaceStore.id
+        })
+        const marketplaceSetting: MarketplaceSetting = await marketplaceSettingRepo.findOne({
+          where: {
+            domain: { id: domain.id },
+            marketplaceStore: { id: marketplaceStore.id },
+            category: settingPatch.category
+          }
+        })
+
+        await marketplaceSettingRepo.save({
+          ...marketplaceSetting,
+          ...settingPatch,
+          updater: user
+        })
+      })
+    )
+
+    return true
+  }
+}

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

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

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

@@ -0,0 +1,20 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceStore } from '../../../entities'
+import { STORE_STATUS } from '../../constants'
+
+export const createMarketplaceStore = {
+  async createMarketplaceStore(_: any, { marketplaceStore }, context: ResolverContext) {
+    const { user, domain } = context.state
+    const randomString: string = Math.random().toString(36).substring(5)
+
+    return await getRepository(MarketplaceStore).save({
+      ...marketplaceStore,
+      name: randomString.toUpperCase(),
+      status: STORE_STATUS.INACTIVE,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+}

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

@@ -0,0 +1,21 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceStore } from '../../../entities'
+import { STORE_STATUS } from '../../constants'
+
+export const deleteMarketplaceStore = {
+  async deleteMarketplaceStore(_: any, { name }, context: ResolverContext) {
+    const { domain, user } = context.state
+    const foundMarketplaceStore: MarketplaceStore = await getRepository(MarketplaceStore).findOne({
+      where: { domain: { id: domain.id }, name }
+    })
+
+    await getRepository(MarketplaceStore).save({
+      ...foundMarketplaceStore,
+      status: STORE_STATUS.TERMINATED,
+      updater: user
+    })
+
+    return true
+  }
+}

package/server/graphql/resolvers/marketplace-store/delete-marketplace-stores.ts

@@ -0,0 +1,26 @@
+import { In } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceStore } from '../../../entities'
+import { STORE_STATUS } from '../../constants'
+
+export const deleteMarketplaceStores = {
+  async deleteMarketplaceStores(_: any, { names }, context: ResolverContext) {
+    const { domain, user } = context.state
+    const foundMarketplaceStores: MarketplaceStore[] = await getRepository(MarketplaceStore).find({
+      where: { domain: { id: domain.id }, name: In(names) }
+    })
+
+    const updatedMarketplaceStore = foundMarketplaceStores.map((store: MarketplaceStore) => {
+      return {
+        ...store,
+        status: STORE_STATUS.TERMINATED,
+        updater: user
+      }
+    })
+
+    await getRepository(MarketplaceStore).save(updatedMarketplaceStore)
+    return true
+  }
+}

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

@@ -0,0 +1,40 @@
+import { marketplaceStoreResolver } from './marketplace-store'
+import { marketplaceStoresResolver } from './marketplace-stores'
+import { updateMultipleMarketplaceStore } from './update-multiple-marketplace-store'
+import { updateMarketplaceStore } from './update-marketplace-store'
+import { createMarketplaceStore } from './create-marketplace-store'
+import { deleteMarketplaceStore } from './delete-marketplace-store'
+import { deleteMarketplaceStores } from './delete-marketplace-stores'
+
+import * as Lazada from './lazada'
+import * as Shopee from './shopee'
+import * as Shopify from './shopify'
+import * as Zalora from './zalora'
+import * as Woocommerce from './woocommerce'
+import * as Magento from './magento'
+
+export const MarketplaceStoreResolver = {
+  Query: {
+    ...marketplaceStoreResolver,
+    ...marketplaceStoresResolver,
+    ...Lazada.Query,
+    ...Shopee.Query,
+    ...Shopify.Query,
+    ...Zalora.Query,
+    ...Woocommerce.Query,
+    ...Magento.Query
+  },
+  Mutation: {
+    ...updateMarketplaceStore,
+    ...updateMultipleMarketplaceStore,
+    ...createMarketplaceStore,
+    ...deleteMarketplaceStore,
+    ...deleteMarketplaceStores,
+    ...Lazada.Mutation,
+    ...Shopee.Mutation,
+    ...Shopify.Mutation,
+    ...Zalora.Mutation,
+    ...Woocommerce.Mutation,
+    ...Magento.Mutation
+  }
+} as any

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

@@ -0,0 +1,28 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceStore } from '../../../../entities'
+import { STORE_STATUS } from '../../../constants'
+
+export const deactivateLazadaStore = {
+  async deactivateLazadaStore(_: 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/lazada/generate-lazada-access-token.ts

@@ -0,0 +1,61 @@
+import { v4 as uuidv4 } from 'uuid'
+
+import { config } from '@things-factory/env'
+
+import { Lazada } from '../../../../controllers/lazada'
+import { MarketplaceSetting, MarketplaceStore } from '../../../../entities'
+import { STORE_STATUS } from '../../../constants'
+
+const lazadaConfig = config.get('marketplaceIntegrationLazada', {})
+const { appKey, appSecret } = lazadaConfig
+
+export const generateLazadaAccessToken = {
+  async generateLazadaAccessToken(_: any, { id, code }, context: ResolverContext) {
+    const { domain, tx, user } = context.state
+    const repository = tx.getRepository(MarketplaceStore)
+    const marketplaceStore: any = await repository.findOne({
+      where: { domain: { id: domain.id }, id }
+    })
+
+    const client = new Lazada(marketplaceStore.countryCode, appKey, appSecret)
+    const generated = await client.generateAccessToken({ code })
+    const { country, access_token, refresh_token, country_user_info } = generated
+    client.accessToken = access_token
+
+    const store = country_user_info.find(info => info.country == country)
+
+    var patch = {
+      accessToken: access_token,
+      refreshToken: refresh_token,
+      accessInfo: JSON.stringify(generated, null, 2),
+      storeId: store?.seller_id,
+      countryCode: country,
+      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/lazada/get-lazada-auth-url.ts

@@ -0,0 +1,9 @@
+import { config } from '@things-factory/env'
+const lazadaConfig = config.get('marketplaceIntegrationLazada', {})
+const { appKey, appSecret } = lazadaConfig
+
+export const getLazadaAuthURL = {
+  async getLazadaAuthURL(_: any, { redirectUrl }, context: ResolverContext) {
+    return `https://auth.lazada.com/oauth/authorize?response_type=code&force_auth=true&redirect_uri=${redirectUrl}&client_id=${appKey}`
+  }
+}

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

@@ -0,0 +1,12 @@
+import { generateLazadaAccessToken } from './generate-lazada-access-token'
+import { deactivateLazadaStore } from './deactivate-lazada-store'
+import { getLazadaAuthURL } from './get-lazada-auth-url'
+
+export const Query = {
+  ...getLazadaAuthURL
+}
+
+export const Mutation = {
+  ...generateLazadaAccessToken,
+  ...deactivateLazadaStore
+}

package/server/graphql/resolvers/marketplace-store/magento/activate-magento-store.ts

@@ -0,0 +1,82 @@
+import fetch from 'node-fetch'
+import { v4 as uuidv4 } from 'uuid'
+
+import { MarketplaceSetting, MarketplaceStore } from '../../../../entities'
+import { STORE_STATUS } from '../../../constants'
+
+const debug = require('debug')('things-factory:integration-marketplace:activate-magento-store')
+
+export const activateMagentoStore = {
+  async activateMagentoStore(_: any, { marketplaceStoreId, username, password }, context: ResolverContext) {
+    const { user, domain, tx } = context.state
+    let marketplaceStore: MarketplaceStore = await tx
+      .getRepository(MarketplaceStore)
+      .findOneBy({ id: marketplaceStoreId })
+    let storeURL = marketplaceStore.storeURL
+    storeURL = storeURL.replace(/\/$/, '')
+
+    const adminTokenURL: string = `${storeURL}/rest/V1/integration/admin/token`
+
+    const requestBody: any = {
+      username: username,
+      password: password
+    }
+
+    const requestTokenResponse = await fetch(`${adminTokenURL}`, {
+      method: 'post',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      body: JSON.stringify(requestBody)
+    })
+
+    if (!requestTokenResponse.ok) {
+      const message = `failed to request token from magento : ${
+        requestTokenResponse.status
+      }, ${await requestTokenResponse.text()}`
+      debug(message)
+      throw new Error(message)
+    }
+
+    const responseBody: any = await requestTokenResponse.json()
+    if (!responseBody) {
+      const message = `failed to get admin token from magento : ${JSON.stringify(responseBody, null, 2)}`
+      debug(message)
+      throw new Error(message)
+    }
+
+    const patch = {
+      accessToken: responseBody,
+      refreshToken: '',
+      accessInfo: responseBody,
+      status: STORE_STATUS.ACTIVE,
+      updater: user
+    }
+
+    marketplaceStore = await tx.getRepository(MarketplaceStore).save({
+      ...marketplaceStore,
+      ...patch
+    })
+
+    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 marketplaceStore
+  }
+}

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

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

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

@@ -0,0 +1,12 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceStore } from '../../../../entities'
+
+export const getMagentoAuthURL = {
+  async getMagentoAuthURL(_: any, { marketplaceStoreId }, context: ResolverContext) {
+    let { storeURL }: MarketplaceStore = await getRepository(MarketplaceStore).findOneBy({ id: marketplaceStoreId })
+    storeURL = storeURL.replace(/\/$/, '')
+
+    return `${storeURL}/rest/V1/integration/admin/token`
+  }
+}

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

@@ -0,0 +1,12 @@
+import { getMagentoAuthURL } from './get-magento-auth-url'
+import { activateMagentoStore } from './activate-magento-store'
+import { deactivateMagentoStore } from './deactivate-magento-store'
+
+export const Query = {
+  ...getMagentoAuthURL
+}
+
+export const Mutation = {
+  ...activateMagentoStore,
+  ...deactivateMagentoStore
+}

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

@@ -0,0 +1,14 @@
+import { getRepository } from '@things-factory/shell'
+
+import { MarketplaceStore } from '../../../entities'
+
+export const marketplaceStoreResolver = {
+  async marketplaceStore(_: any, { id }, context: ResolverContext) {
+    const { domain } = context.state
+
+    return await getRepository(MarketplaceStore).findOne({
+      where: { domain: { id: domain.id }, id },
+      relations: ['domain', 'creator', 'updater']
+    })
+  }
+}

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

@@ -0,0 +1,18 @@
+import { buildQuery, getRepository, ListParam } from '@things-factory/shell'
+
+import { MarketplaceStore } from '../../../entities'
+
+export const marketplaceStoresResolver = {
+  async marketplaceStores(_: any, params: ListParam, context: ResolverContext) {
+    const queryBuilder = getRepository(MarketplaceStore).createQueryBuilder('MS')
+    buildQuery(queryBuilder, params, context)
+
+    const [items, total] = await queryBuilder
+      .leftJoinAndSelect('MS.domain', 'DOMAIN')
+      .leftJoinAndSelect('MS.creator', 'CREATOR')
+      .leftJoinAndSelect('MS.updater', 'UPDATER')
+      .getManyAndCount()
+
+    return { items, total }
+  }
+}