@things-factory/integration-sellercraft 8.0.0-beta.8 → 8.0.0

package/server/routers/sellercraft-router.ts

@@ -0,0 +1,326 @@
+import Router from 'koa-router'
+import { v4 as uuidv4 } from 'uuid'
+
+import { StoreAPI } from '@things-factory/integration-marketplace'
+import { createPayloadLog, PayloadType } from '@things-factory/integration-base'
+import { sleep } from '@things-factory/utils'
+
+import { SHIPPING_TYPE } from '../constants'
+import { getShop } from '../utils/tokencraft-util'
+
+const debug = require('debug')('things-factory:integration-sellercraft:sellercraft-router')
+
+export const sellercraftRouter = new Router()
+
+sellercraftRouter.post('/sellercraft/store/update-product-price', async (context, next) => {
+  const requestBody = context.request.body
+
+  for (var i = 0; i < requestBody.length; i++) {
+    let mappedStore: any = await getShop(context, requestBody[i].channel_id, requestBody[i].shop_id)
+    var result
+
+    try {
+      if (requestBody[i].variant.native_variant_id != requestBody[i].native_product_id) {
+        const req = {
+          costPrice: requestBody[i].variant.full_price,
+          sellPrice: requestBody[i].variant.sale_price,
+          productId: requestBody[i].native_product_id,
+          variationId: requestBody[i].variant.native_variant_id,
+          variationSku: requestBody[i].variant.sku,
+          context: { state: { domain: null } }
+        }
+        result = await StoreAPI.updateStoreProductVariationPrice(mappedStore, req)
+      } else {
+        const req = {
+          costPrice: requestBody[i].variant.full_price,
+          sellPrice: requestBody[i].variant.sale_price,
+          productId: requestBody[i].native_product_id,
+          variationSku: requestBody[i].variant.sku,
+          context: { state: { domain: null } }
+        }
+        result = await StoreAPI.updateStoreProductPrice(mappedStore, req)
+      }
+
+      debug(result)
+
+      context.type = 'application/json'
+      context.status = 200
+      context.body = 'Succeeded'
+    } catch (e) {
+      context.type = 'application/json'
+      context.status = 500
+      context.body = e.message
+    }
+  }
+})
+
+sellercraftRouter.post('/sellercraft/store/update-product-stock', async (context, next) => {
+  const requestBody = context.request.body
+  for (var i = 0; i < requestBody.length; i++) {
+    let mappedStore: any = await getShop(context, requestBody[i].channel_id, requestBody[i].shop_id)
+    var result
+
+    try {
+      if (requestBody[i].variant.native_variant_id != requestBody[i].native_product_id) {
+        const req = {
+          qty: requestBody[i].variant.stock,
+          itemId: requestBody[i].native_product_id,
+          variationId: requestBody[i].variant.native_variant_id,
+          distributors: requestBody[i].distributors || [], // for Magento
+          variationSku: requestBody[i].variant.sku,
+          locationId: requestBody[i]?.variant?.extra_metadata?.locationId, // for Shopify
+          inventoryItemId: requestBody[i]?.variant?.extra_metadata?.inventoryItemId, // for Shopify
+          context: { state: { domain: null } }
+        }
+        if (req.locationId) {
+          let location = JSON.parse(req.locationId)
+          req.qty -= await StoreAPI.getStoreProductVariationStock(mappedStore, { variantId: req.variationId })
+          req.locationId = location[0].location_id
+        }
+        result = await StoreAPI.updateStoreProductVariationStock(mappedStore, req)
+      } else {
+        const req = {
+          qty: requestBody[i].variant.stock,
+          itemId: requestBody[i].native_product_id,
+          distributors: requestBody[i].distributors || [], // for Magento
+          variationSku: requestBody[i].variant.sku,
+          context: { state: { domain: null } }
+        }
+        result = await StoreAPI.updateStoreProductStock(mappedStore, req)
+      }
+
+      debug(result)
+
+      context.type = 'application/json'
+      context.status = 200
+      context.body = 'Succeeded'
+    } catch (e) {
+      context.type = 'application/json'
+      context.status = 500
+      context.body = e.message
+    }
+  }
+})
+
+sellercraftRouter.post('/sellercraft/store/update-order-status', async (context, next) => {
+  try {
+    const requestBody = context.request.body
+    var result: any = {}
+    let mappedStore: any = await getShop(context, requestBody.channel_id, requestBody.shop_id)
+    let packageIds: any =
+      mappedStore.platform == 'tiktok'
+        ? requestBody?.order_items.map(oi => {
+            return oi.package_id
+          })
+        : []
+
+    const reqBody = {
+      orderId: requestBody.native_order_id,
+      status: requestBody.order_status,
+      carrier: requestBody?.shipper_last_mile,
+      trackingNo: requestBody?.tracking_number,
+      orderItems: unmapOrderItems(
+        requestBody?.order_items.map(oi => {
+          return oi.native_order_item_id
+        }) || []
+      ),
+      isSOF: requestBody?.seller_logistics,
+      packageIds: [...new Set(packageIds)],
+      locations:
+        mappedStore.platform == 'shopify'
+          ? requestBody?.order_items.map(oi => {
+              let jsonLocation = oi.extra_metadata.locationId
+              return JSON.parse(jsonLocation)[0].location_id
+            })
+          : null,
+      context: { state: { domain: null } }
+    }
+
+    let responseBody: any = { operation_id: uuidv4() }
+    try {
+      try {
+        if (mappedStore.platform == 'tiktok') {
+          for (let packageId of reqBody.packageIds) {
+            result = (await StoreAPI.updateOrderStatus(mappedStore, { packageId, status: reqBody.status })) || {}
+          }
+        } else {
+          result = (await StoreAPI.updateOrderStatus(mappedStore, reqBody)) || {}
+        }
+
+        debug(result)
+      } catch (e) {
+        if (e?.requiredDocument) result.requiredDocument = e.requiredDocument
+      }
+
+      if (result?.requiredDocument) {
+        // call document api and ingest channel order package
+        const order: any = await StoreAPI.getStoreOrder(mappedStore, { orderId: reqBody.orderId })
+        let orderPackage: any = order ? (order[0]?.orderPackage ? order[0].orderPackage : {}) : {}
+        if (orderPackage) {
+          const packageId: string = orderPackage.packageId
+
+          let orderDocument: any = orderPackage.orderDocument
+          if (orderDocument?.length == 0) {
+            let hasDocument: boolean = false
+            let retries = 0
+            while (!hasDocument && retries < 10) {
+              orderDocument = await StoreAPI.getStoreOrderDocument(mappedStore, { packageId, documentType: 1 })
+              if (orderDocument?.length > 0) {
+                hasDocument = true
+                break
+              }
+              await sleep(1000)
+              retries++
+            }
+          }
+
+          // Order Package Payload
+          let newOrderPackage: any = {
+            channel_shop_id: mappedStore.channelShopId,
+            native_order_id: reqBody.orderId,
+            native_package_id: orderPackage.packageId.toString(),
+            shipping_tracking_code: orderPackage.trackingNumber,
+            shipping_type_value: orderPackage?.shippingType ? orderPackage.shippingType : SHIPPING_TYPE.DROP_SHIPPING,
+            warehouse_code: SHIPPING_TYPE.DROP_SHIPPING,
+            shipper: {
+              name: orderPackage.shippingProvider,
+              is_cod_supported: orderPackage?.isCodSupport ? orderPackage.isCodSupport : false
+            },
+            documents:
+              orderDocument?.map(doc => {
+                return {
+                  file: doc.file,
+                  file_type_value: doc.fileTypeValue,
+                  mime_type: doc.mimeType
+                }
+              }) || [],
+            shipper_last_mile: {
+              name: orderPackage.shippingProvider,
+              is_cod_supported: orderPackage?.isCodSupport ? orderPackage.isCodSupport : false
+            },
+            order_item_ids: orderPackage?.orderListIdList
+              ? orderPackage.orderListIdList
+              : reqBody.orderItems.map(oi => {
+                  return oi.order_item_id
+                })
+          }
+
+          responseBody.package = newOrderPackage
+        }
+        responseBody.response_code = 'E0'
+        responseBody.message = 'Success'
+      }
+
+      responseBody.time = Math.floor(new Date(new Date().toUTCString()).getTime() / 1000)
+
+      try {
+        createPayloadLog(
+          mappedStore.channelShopId,
+          '/sellercraft/store/update-order-status',
+          requestBody,
+          responseBody,
+          null,
+          PayloadType.INGESTION,
+          'hub-api'
+        )
+      } catch (e) {}
+
+      context.type = 'application/json'
+      context.status = 200
+      context.body = responseBody
+
+      await next()
+    } catch (e) {
+      responseBody.response_code = 'E1'
+      responseBody.message = e.message
+
+      context.type = 'application/json'
+      context.status = 500
+      context.body = responseBody
+      try {
+        createPayloadLog(
+          mappedStore?.channelShopId,
+          '/sellercraft/store/update-order-status',
+          requestBody,
+          responseBody,
+          null,
+          PayloadType.INGESTION,
+          'hub-api'
+        )
+      } catch (e) {}
+    }
+  } catch (e) {}
+})
+
+sellercraftRouter.post('/sellercraft/store/update-product-attribute', async (context, next) => {
+  const requestBody = context.request.body
+  let mappedStore: any = await getShop(context, requestBody.channel_id, requestBody.shop_id)
+
+  let { product_sku: productSku, native_product_id: itemId, variants } = requestBody
+
+  variants.map(variant => {
+    let { variant_sku: variantSku, native_variant_id: variantId, attributes } = variant
+
+    attributes.map(attribute => {
+      let { native_attribute_id: id, attribute_key: name, attribute_value: value } = attribute
+
+      return {
+        id,
+        name,
+        value
+      }
+    })
+
+    return {
+      variantSku,
+      variantId,
+      attributes
+    }
+  })
+
+  for (var i = 0; i < variants.length; i++) {
+    try {
+      let variant = variants[i]
+      await StoreAPI.updateProductAttribute(mappedStore, {
+        productSku,
+        itemId,
+        variant,
+        context: { state: { domain: null } }
+      })
+      context.type = 'application/json'
+      context.status = 200
+      context.body = 'Succeeded'
+    } catch (e) {
+      context.type = 'application/json'
+      context.status = 500
+      context.body = e.message
+    }
+  }
+})
+
+function unmapOrderItems(orderItems) {
+  let itemsList = []
+  let res = orderItems.map(e => {
+    return e.split('-')[0]
+  })
+
+  for (let item of res) {
+    let count = 0
+
+    res.forEach(element => {
+      if (element === item) {
+        count += 1
+      }
+    })
+
+    itemsList.push({
+      order_item_id: item,
+      qty: count
+    })
+  }
+
+  itemsList = itemsList.filter(
+    (value, index, self) => index === self.findIndex(t => t.order_item_id === value.order_item_id)
+  )
+  return itemsList
+}

package/server/routes.ts

@@ -0,0 +1,32 @@
+import { sellercraftRouter } from './routers/sellercraft-router'
+
+const debug = require('debug')('things-factory:integration-sellercraft:routes')
+
+process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRouter) => {
+  /*
+   * can add global public routes to application (auth not required, tenancy not required)
+   *
+   * ex) routes.get('/path', async(context, next) => {})
+   * ex) routes.post('/path', async(context, next) => {})
+   */
+
+  globalPublicRouter.use(sellercraftRouter.routes(), sellercraftRouter.allowedMethods())
+})
+
+process.on('bootstrap-module-global-private-route' as any, (app, globalPrivateRouter) => {
+  /*
+   * can add global private routes to application (auth required, tenancy not required)
+   */
+})
+
+process.on('bootstrap-module-domain-public-route' as any, (app, domainPublicRouter) => {
+  /*
+   * can add domain public routes to application (auth not required, tenancy required)
+   */
+})
+
+process.on('bootstrap-module-domain-private-route' as any, (app, domainPrivateRouter) => {
+  /*
+   * can add domain private routes to application (auth required, tenancy required)
+   */
+})

package/server/service/index.ts

@@ -0,0 +1,23 @@
+/* EXPORT ENTITY TYPES */
+export * from './sellercraft/sellercraft'
+
+/* IMPORT ENTITIES AND RESOLVERS */
+import { entities as SellercraftEntities, resolvers as SellercraftResolvers } from './sellercraft'
+import { entities as MarketplaceChannelEntities, resolvers as MarketplaceSellercraftResolvers } from './marketplace-channel'
+
+export const entities = [  
+  /* ENTITIES */
+	...SellercraftEntities,
+  ...MarketplaceChannelEntities
+] 
+
+
+export const schema = {
+  resolverClasses: [
+    /* RESOLVER CLASSES */
+		...SellercraftResolvers,
+    ...MarketplaceSellercraftResolvers
+  ]
+}
+
+export { MarketplaceSellercraftResolvers }

package/server/service/marketplace-channel/index.ts

@@ -0,0 +1,6 @@
+import { MarketplaceChannel } from './marketplace-channel'
+import { MarketplaceChannelOrderMutation } from './marketplace-channel-order-mutation'
+import { MarketplaceChannelProductMutation } from './marketplace-channel-product-mutation'
+
+export const entities = [MarketplaceChannel]
+export const resolvers = [MarketplaceChannelOrderMutation, MarketplaceChannelProductMutation]