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

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

@@ -1,32 +0,0 @@
-import { MarketplaceOrderShipping as MarketplaceOrderShippingEntity } from '../../../entities'
-
-export const updateMarketplaceOrderShipping = {
-  async updateMarketplaceOrderShipping(_: any, { orderNo, patch }, context: ResolverContext) {
-    const { tx, user, marketplaceStore } = context.state
-    let marketplaceOrderShipping = await tx.getRepository(MarketplaceOrderShippingEntity).findOne({
-      where: { marketplaceStore: { id: marketplaceStore.id }, subOrderNoRef: orderNo },
-      relations: ['marketplaceStore']
-    })
-
-    if (!marketplaceOrderShipping) throw new Error(`Shipping not exist`)
-
-    marketplaceOrderShipping.ownTrackingNo = patch.trackingNo
-
-    if (marketplaceOrderShipping.marketplaceStore.platform == 'lazada') {
-      if (patch?.trackingNo) {
-        patch.trackingNo = marketplaceOrderShipping.trackingNo
-      }
-    }
-
-    marketplaceOrderShipping = await tx.getRepository(MarketplaceOrderShippingEntity).save({
-      ...marketplaceOrderShipping,
-      ...patch,
-      updater: user
-    })
-
-    return {
-      ...marketplaceOrderShipping,
-      shippingId: marketplaceOrderShipping.name
-    }
-  }
-}

package/server/graphql/resolvers/marketplace-order-shipping/update-multiple-marketplace-order-shipping.ts

@@ -1,44 +0,0 @@
-import { getRepository } from '@things-factory/shell'
-
-import { MarketplaceOrderShipping } from '../../../entities'
-
-export const updateMultipleMarketplaceOrderShipping = {
-  async updateMultipleMarketplaceOrderShipping(_: any, { patches }, context: ResolverContext) {
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const marketplaceOrderShippingRepo = getRepository(MarketplaceOrderShipping)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await marketplaceOrderShippingRepo.save({
-          ...newRecord,
-          domain: context.state.domain,
-          creator: context.state.user,
-          updater: context.state.user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const marketplaceOrderShipping = await marketplaceOrderShippingRepo.findOneBy({ id: newRecord.id })
-
-        const result = await marketplaceOrderShippingRepo.save({
-          ...marketplaceOrderShipping,
-          ...newRecord,
-          updater: context.state.user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-}

package/server/graphql/resolvers/marketplace-order-shipping-item/create-marketplace-order-shipping-item.ts

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

package/server/graphql/resolvers/marketplace-order-shipping-item/delete-marketplace-order-shipping-item.ts

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

package/server/graphql/resolvers/marketplace-order-shipping-item/delete-marketplace-order-shipping-items.ts

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

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

@@ -1,20 +0,0 @@
-import { createMarketplaceOrderShippingItem } from './create-marketplace-order-shipping-item'
-import { deleteMarketplaceOrderShippingItem } from './delete-marketplace-order-shipping-item'
-import { deleteMarketplaceOrderShippingItems } from './delete-marketplace-order-shipping-items'
-import { marketplaceOrderShippingItemResolver } from './marketplace-order-shipping-item'
-import { updateMarketplaceOrderShippingItem } from './update-marketplace-order-shipping-item'
-import { updateMultipleMarketplaceOrderShippingItem } from './update-multiple-marketplace-order-shipping-item'
-
-export const MarketplaceOrderShippingItemResolver = {
-  Query: {
-    ...marketplaceOrderShippingItemResolver,
-    ...marketplaceOrderShippingItemResolver
-  },
-  Mutation: {
-    ...updateMarketplaceOrderShippingItem,
-    ...updateMultipleMarketplaceOrderShippingItem,
-    ...createMarketplaceOrderShippingItem,
-    ...deleteMarketplaceOrderShippingItem,
-    ...deleteMarketplaceOrderShippingItems
-  }
-}

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

@@ -1,21 +0,0 @@
-import { getRepository } from '@things-factory/shell'
-
-import { MarketplaceOrderShippingItem } from '../../../entities'
-
-export const marketplaceOrderShippingItemResolver = {
-  async marketplaceOrderShippingItem(_: any, { name }, context: ResolverContext) {
-    const repository = getRepository(MarketplaceOrderShippingItem)
-
-    return await getRepository(MarketplaceOrderShippingItem).findOne({
-      where: { domain: { id: context.state.domain.id }, name },
-      relations: [
-        'domain',
-        'creator',
-        'updater',
-        'marketplaceOrderItem',
-        'marketplaceOrderItem.marketplaceProductVariation',
-        'marketplaceOrderItem.marketplaceProductVariation.marketplaceProduct'
-      ]
-    })
-  }
-}

package/server/graphql/resolvers/marketplace-order-shipping-item/marketplace-order-shipping-items.ts

@@ -1,14 +0,0 @@
-import { convertListParams, getRepository, ListParam } from '@things-factory/shell'
-
-import { MarketplaceOrderShippingItem } from '../../../entities'
-
-export const marketplaceOrderShippingItemsResolver = {
-  async marketplaceOrderShippingItems(_: any, params: ListParam, context: ResolverContext) {
-    const convertedParams = convertListParams(params)
-    const [items, total] = await getRepository(MarketplaceOrderShippingItem).findAndCount({
-      ...convertedParams,
-      relations: ['domain', 'creator', 'updater']
-    })
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/marketplace-order-shipping-item/update-marketplace-order-shipping-item.ts

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

package/server/graphql/resolvers/marketplace-order-shipping-item/update-multiple-marketplace-order-shipping-item.ts

@@ -1,44 +0,0 @@
-import { getRepository } from '@things-factory/shell'
-
-import { MarketplaceOrderShippingItem } from '../../../entities'
-
-export const updateMultipleMarketplaceOrderShippingItem = {
-  async updateMultipleMarketplaceOrderShippingItem(_: any, { patches }, context: ResolverContext) {
-    let results = []
-    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
-    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
-    const marketplaceOrderShippingItemRepo = getRepository(MarketplaceOrderShippingItem)
-
-    if (_createRecords.length > 0) {
-      for (let i = 0; i < _createRecords.length; i++) {
-        const newRecord = _createRecords[i]
-
-        const result = await marketplaceOrderShippingItemRepo.save({
-          ...newRecord,
-          domain: context.state.domain,
-          creator: context.state.user,
-          updater: context.state.user
-        })
-
-        results.push({ ...result, cuFlag: '+' })
-      }
-    }
-
-    if (_updateRecords.length > 0) {
-      for (let i = 0; i < _updateRecords.length; i++) {
-        const newRecord = _updateRecords[i]
-        const marketplaceOrderShippingItem = await marketplaceOrderShippingItemRepo.findOneBy({ id: newRecord.id })
-
-        const result = await marketplaceOrderShippingItemRepo.save({
-          ...marketplaceOrderShippingItem,
-          ...newRecord,
-          updater: context.state.user
-        })
-
-        results.push({ ...result, cuFlag: 'M' })
-      }
-    }
-
-    return results
-  }
-}

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

@@ -1,35 +0,0 @@
-import { EntityManager, Repository } from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { Domain, getRepository } from '@things-factory/shell'
-
-import { PRODUCT_STATUS } from '../../../constants'
-import { MarketplaceProduct } from '../../../entities'
-
-export const createMarketplaceProductResolver = {
-  async createMarketplaceProduct(_: any, { marketplaceProduct }, context: ResolverContext) {
-    const { domain, user, tx } = context.state
-    return await createMarketplaceProduct(domain, marketplaceProduct, user, tx)
-  }
-}
-
-export async function createMarketplaceProduct(
-  domain: Domain,
-  marketplaceProduct: any,
-  user: User,
-  tx?: EntityManager
-): Promise<any> {
-  const marketplaceProdRepo: Repository<MarketplaceProduct> =
-    tx?.getRepository(MarketplaceProduct) || getRepository(MarketplaceProduct)
-
-  const createdProd: MarketplaceProduct = await marketplaceProdRepo.save({
-    ...marketplaceProduct,
-    domain,
-    status: PRODUCT_STATUS.DRAFT,
-    type: marketplaceProduct.storageType,
-    creator: user,
-    updater: user
-  })
-
-  return createdProd
-}

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

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

package/server/graphql/resolvers/marketplace-product/delete-marketplace-products.ts

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

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

@@ -1,27 +0,0 @@
-import { createMarketplaceProductResolver } from './create-marketplace-product'
-import { deleteMarketplaceProduct } from './delete-marketplace-product'
-import { deleteMarketplaceProducts } from './delete-marketplace-products'
-import { marketplaceProductResolver } from './marketplace-product'
-import { marketplaceProductsResolver } from './marketplace-products'
-import { syncAllMarketplaceStoreProductsResolver } from './sync-all-marketplace-store-products'
-import { syncMarketplaceStoreProducts, syncMarketplaceStoreProductsResolver } from './sync-marketplace-store-products'
-import { updateMarketplaceProductResolver } from './update-marketplace-product'
-import { upsertMarketplaceProduct } from './upsert-marketplace-product'
-
-export const MarketplaceProductResolver = {
-  Query: {
-    ...marketplaceProductsResolver,
-    ...marketplaceProductResolver
-  },
-  Mutation: {
-    ...updateMarketplaceProductResolver,
-    ...upsertMarketplaceProduct,
-    ...createMarketplaceProductResolver,
-    ...deleteMarketplaceProduct,
-    ...deleteMarketplaceProducts,
-    ...syncMarketplaceStoreProductsResolver,
-    ...syncAllMarketplaceStoreProductsResolver
-  }
-}
-
-export { syncMarketplaceStoreProducts }

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

@@ -1,24 +0,0 @@
-import { Attachment } from '@things-factory/attachment-base'
-import { getRepository } from '@things-factory/shell'
-
-import { ATTACHMENT_TYPE } from '../../../constants'
-import { MarketplaceProduct } from '../../../entities'
-
-export const marketplaceProductResolver = {
-  async marketplaceProduct(_: any, { name, isku }, context: ResolverContext) {
-    const foundProd: MarketplaceProduct = await getRepository(MarketplaceProduct).findOne({
-      where: { domain: { id: context.state.domain.id }, name, isku }
-    })
-    const foundAttachments: Attachment[] = await getRepository(Attachment).find({
-      where: {
-        domain: context.state.domain,
-        refBy: foundProd.id,
-        category: ATTACHMENT_TYPE.MARKETPLACE_PRODUCT
-      }
-    })
-    return {
-      ...foundProd,
-      attachment: foundAttachments
-    }
-  }
-}

package/server/graphql/resolvers/marketplace-product/marketplace-products.ts

@@ -1,23 +0,0 @@
-import { convertListParams, getRepository, ListParam } from '@things-factory/shell'
-
-import { MarketplaceProduct } from '../../../entities'
-
-export const marketplaceProductsResolver = {
-  async marketplaceProducts(_: any, params: ListParam, context: ResolverContext) {
-    const { domain } = context.state
-    const convertedParams = convertListParams(params, { domain })
-    const [items, total] = await getRepository(MarketplaceProduct).findAndCount({
-      ...convertedParams,
-      relations: [
-        'marketplaceStore',
-        'marketplaceProductVariations',
-        'marketplaceProductAttributes',
-        'domain',
-        'creator',
-        'updater'
-      ]
-    })
-
-    return { items, total }
-  }
-}

package/server/graphql/resolvers/marketplace-product/sync-all-marketplace-store-products.ts

@@ -1,225 +0,0 @@
-import { getConnection, In } from 'typeorm'
-
-import { MarketplaceStore, StoreAPI } from '@things-factory/integration-marketplace'
-import { getRepository, ListParam, publishProgress } from '@things-factory/shell'
-
-import { MarketplaceProduct, MarketplaceProductAttribute, MarketplaceProductVariation } from '../../../entities'
-
-const debug = require('debug')('things-factory:marketplace-base:sync-all-marketplace-store-product')
-
-async function syncAllMarketplaceStoreProducts({ user, tag, marketplaceStores }) {
-  try {
-    for (var i = 0; i < marketplaceStores?.length; i++) {
-      const marketplaceStore: MarketplaceStore = marketplaceStores[i]
-
-      let totalPages: number = 1
-      let processedData: number = 0
-      let pageInfo: string
-      var limit: number = 50
-
-      for (let page = 0; page < totalPages; page++) {
-        const {
-          results: marketplaceProducts,
-          total,
-          page_info
-        } = await StoreAPI.getStoreProducts(marketplaceStore, {
-          pagination: { page, limit },
-          pageInfo
-        })
-
-        if (marketplaceProducts?.length == 0) throw new Error('There is no product available to sync')
-
-        if (page_info) pageInfo = page_info
-        totalPages = Math.ceil(total / limit)
-
-        // search for existing product
-        const existingMarketplaceProducts: MarketplaceProduct[] = await getRepository(MarketplaceProduct).find({
-          where: {
-            domain: { id: marketplaceStore.domain.id },
-            marketplaceStore: { id: marketplaceStore.id },
-            itemId: In(marketplaceProducts.map(product => product.itemId.toString()))
-          },
-          relations: ['marketplaceProductVariations', 'marketplaceProductAttributes']
-        })
-
-        const existingItemIds: any[] = existingMarketplaceProducts.map(product => product.itemId)
-
-        const newMarketplaceProducts: MarketplaceProduct[] = marketplaceProducts.filter(
-          product => !existingItemIds.includes(product.itemId.toString())
-        )
-
-        let marketplaceProductVariations: MarketplaceProductVariation[] = []
-        let marketplaceProductAttributes: MarketplaceProductAttribute[] = []
-
-        if (existingMarketplaceProducts?.length > 0) {
-          for (var i = 0; i < existingMarketplaceProducts.length; i++) {
-            await getConnection().transaction(async tx => {
-              var existingProduct: MarketplaceProduct = existingMarketplaceProducts[i]
-
-              const matchedItem = marketplaceProducts.filter(
-                product => product.itemId.toString() === existingProduct.itemId
-              )[0]
-
-              // prep marketplace product data for saving
-              await tx.getRepository(MarketplaceProduct).save({
-                ...existingProduct,
-                ...matchedItem,
-                updater: user
-              })
-
-              // pre-load all existing marketplace product variation status = 'INACTIVE'
-              marketplaceProductVariations = existingProduct?.marketplaceProductVariations.map(variation => {
-                return {
-                  ...variation,
-                  status: 'INACTIVE'
-                }
-              })
-
-              // pre-load all existing marketplace product attributes status = 'INACTIVE'
-              marketplaceProductAttributes = existingProduct?.marketplaceProductAttributes.map(attribute => {
-                return {
-                  ...attribute,
-                  status: 'INACTIVE'
-                }
-              })
-
-              matchedItem.variations.map(variation => {
-                let matchedVariationIndex = marketplaceProductVariations.findIndex(
-                  itm => itm.variationId == variation.variationId
-                )
-
-                if (matchedVariationIndex >= 0) {
-                  marketplaceProductVariations[matchedVariationIndex] = {
-                    ...marketplaceProductVariations[matchedVariationIndex],
-                    ...variation,
-                    status: 'ACTIVE',
-                    updater: user
-                  }
-                } else {
-                  marketplaceProductVariations.push({ ...variation, status: 'ACTIVE', creator: user, updater: user })
-                }
-              })
-
-              await tx.getRepository(MarketplaceProductVariation).save(marketplaceProductVariations)
-
-              // update status = 'ACTIVE' for matching existing with latest marketplace product attribute
-              matchedItem.attributes.map(attribute => {
-                let matchedAttributeIndex = marketplaceProductAttributes.findIndex(
-                  itm => itm.attributeId == attribute.attributeId
-                )
-
-                if (matchedAttributeIndex >= 0) {
-                  marketplaceProductAttributes[matchedAttributeIndex] = {
-                    ...marketplaceProductAttributes[matchedAttributeIndex],
-                    ...attribute,
-                    status: 'ACTIVE',
-                    updater: user
-                  }
-                } else {
-                  marketplaceProductAttributes.push({ ...attribute, status: 'ACTIVE', creator: user, updater: user })
-                }
-              })
-
-              await tx.getRepository(MarketplaceProductAttribute).save(marketplaceProductAttributes)
-
-              processedData++
-              debug('processed data', processedData)
-
-              publishProgress({
-                domain: marketplaceStore.domain,
-                tag,
-                progress: Math.floor((processedData / total) * 100),
-                message: `${processedData} / ${total}`
-              })
-            })
-          }
-        }
-
-        if (newMarketplaceProducts?.length > 0) {
-          for (var i = 0; i < newMarketplaceProducts.length; i++) {
-            await getConnection().transaction(async tx => {
-              var product: any = newMarketplaceProducts[i]
-
-              // prep marketplace product data for saving
-              let marketplaceProduct: MarketplaceProduct = new MarketplaceProduct(product)
-              marketplaceProduct.marketplaceStore = marketplaceStore
-              marketplaceProduct.domain = marketplaceStore.domain
-              marketplaceProduct.creator = user
-              marketplaceProduct.updater = user
-              await tx.getRepository(MarketplaceProduct).save(marketplaceProduct)
-
-              marketplaceProductVariations = product.variations.map(variation => {
-                return {
-                  ...variation,
-                  status: 'ACTIVE',
-                  marketplaceProduct,
-                  domain: marketplaceStore.domain,
-                  creator: user,
-                  updater: user
-                }
-              })
-              await tx.getRepository(MarketplaceProductVariation).save(marketplaceProductVariations)
-
-              // pre-load all existing marketplace product attributes status = 'ACTIVE'
-              marketplaceProductAttributes = product.attributes.map(attribute => {
-                return {
-                  ...attribute,
-                  status: 'ACTIVE',
-                  marketplaceProduct,
-                  domain: marketplaceStore.domain,
-                  creator: user,
-                  updater: user
-                }
-              })
-              await tx.getRepository(MarketplaceProductAttribute).save(marketplaceProductAttributes)
-
-              processedData++
-              debug('processed data', processedData)
-
-              publishProgress({
-                domain: marketplaceStore.domain,
-                tag,
-                progress: Math.floor((processedData / total) * 100),
-                message: `${processedData} / ${total}`
-              })
-            })
-          }
-        }
-      }
-    }
-    return true
-  } catch (ex) {
-    publishProgress({
-      domain: marketplaceStores[i].domain,
-      tag,
-      progress: -1,
-      message: 'failed'
-    })
-
-    throw ex
-  }
-}
-
-export const syncAllMarketplaceStoreProductsResolver = {
-  async syncAllMarketplaceStoreProducts(_: any, params: ListParam, context: ResolverContext) {
-    let marketplaceStores: MarketplaceStore[]
-    const tag = `progress-sync-all-product`
-    if (context) {
-      var { domain, user } = context.state
-      marketplaceStores = await StoreAPI.getMarketplaceStores(domain)
-    } else {
-      marketplaceStores = await getRepository(MarketplaceStore).find({
-        where: { status: 'ACTIVE' }
-      })
-    }
-
-    // don't make following line synchronous (await)
-    syncAllMarketplaceStoreProducts({
-      user,
-      tag,
-      marketplaceStores
-    })
-
-    return true
-  }
-}