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

package/server/controllers/sellercraft-channel-integration/apis/ingest-channel-category-attributes.ts

@@ -0,0 +1,65 @@
+/* https://docs.sellercraft.co/docs/api-integrations/b3A6MjQzODUxMTE-ingest-channel-category-attributes */
+
+export function ingestChannelCategoryAttributes() {
+  return {
+    method: 'post',
+    path: '/channel/ingest/category/attribute',
+    denormalize(req) {
+      let { channelAttributeKeys, scAttributeKeys } = req
+
+      let channel_attribute_keys = channelAttributeKeys.map(e => {
+        const {
+          channelCode: channel_code,
+          channelCountry: channel_country,
+          nativeCategoryId: native_category_id,
+          attributeKey: attribute_key,
+          valueType: value_type,
+          valueOptions: value_options,
+          displayName: display_name,
+          isCore: is_core,
+          isSearchProp: is_search_prop,
+          isOptional: is_optional
+        } = e
+
+        return {
+          channel_code,
+          channel_country,
+          native_category_id,
+          attribute_key,
+          value_type,
+          value_options,
+          display_name,
+          is_core,
+          is_search_prop,
+          is_optional
+        }
+      })
+
+      let sc_attribute_keys = scAttributeKeys.map(e => {
+        const {
+          channelCode: channel_code,
+          channelCountry: channel_country,
+          attributeKey: attribute_key,
+          displayName: display_name
+        } = e
+
+        return {
+          channel_code,
+          channel_country,
+          attribute_key,
+          display_name
+        }
+      })
+
+      return {
+        payload: {
+          channel_attribute_keys,
+          sc_attribute_keys
+        }
+      }
+    },
+    normalize(res) {
+      return res
+    }
+  }
+}

package/server/controllers/sellercraft-channel-integration/apis/ingest-channel-order-package.ts

@@ -0,0 +1,62 @@
+/* https://docs.sellercraft.co/docs/api-integrations/b3A6MjQzODUxMTQ-ingest-channel-order-package */
+
+export function ingestChannelOrderPackage() {
+  return {
+    method: 'post',
+    path: '/channel/ingest/order/package',
+    denormalize(req) {
+      let {
+        channelShopId: channel_shop_id,
+        nativeOrderId: native_order_id,
+        nativePackageId: native_package_id,
+        shippingTrackingCode: shipping_tracking_code,
+        shippingTypeValue: shipping_type_value,
+        warehouseCode: warehouse_code,
+        shipper,
+        documents,
+        shipperLastMile: shipper_last_mile,
+        orderItemIds: order_item_ids
+      } = req
+
+      documents = documents.map(e => {
+        const { fileTypeValue: file_type_value, mimeType: mime_type, file } = e
+
+        return {
+          file_type_value,
+          mime_type,
+          file
+        }
+      })
+
+      shipper = {
+        is_cod_supported: shipper.isCodSupported,
+        name: shipper.name
+      }
+
+      shipper_last_mile = {
+        is_cod_supported: shipper_last_mile.isCodSupported,
+        name: shipper_last_mile.name
+      }
+
+      let newOrderPackage: any = {
+        channel_shop_id,
+        native_order_id,
+        native_package_id: native_package_id.toString(),
+        shipping_tracking_code,
+        shipping_type_value,
+        warehouse_code,
+        shipper,
+        documents,
+        shipper_last_mile,
+        order_item_ids
+      }
+
+      return {
+        payload: { ...newOrderPackage }
+      }
+    },
+    normalize(res) {
+      return res
+    }
+  }
+}

package/server/controllers/sellercraft-channel-integration/apis/ingest-channel-order.ts

@@ -0,0 +1,92 @@
+/* https://docs.sellercraft.co/docs/api-integrations/b3A6MjQzODQ4OTg-ingest-channel-order */
+
+import { ORDER_STATUS } from '../../../constants'
+
+export function ingestChannelOrder() {
+  return {
+    method: 'post',
+    path: '/channel/ingest/order',
+    denormalize(req) {
+      const { orders } = req
+
+      let newOrders = orders.map(order => {
+        return {
+          organisation_id: order.organisationId,
+          channel_shop_id: order.channelShopId,
+          native_order_id: order.id.toString(),
+          native_order_display_id: order?.sellercraftDisplayOrderNo,
+          ordered_at_date: new Date(order.createdAt).toISOString().slice(0, -5) + 'Z',
+          ordered_at_time: new Date(order.createdAt).toISOString().slice(0, -5) + 'Z',
+          updated_at_date: new Date(order.updatedAt).toISOString().slice(0, -5) + 'Z',
+          updated_at_time: new Date(order.updatedAt).toISOString().slice(0, -5) + 'Z',
+          customer_first_name: order.custFirstName,
+          customer_last_name: order.custLastName,
+          charges: order.charges.map(charge => {
+            return {
+              charge_type_value: charge.name,
+              amount_gross: parseFloat(charge.grossAmount) || 0,
+              amount_nett: parseFloat(charge.nettAmount) || 0
+            }
+          }),
+          address_shipping: order?.shipAddress1 ? {
+            first_name: order.shipFirstName,
+            last_name: order.shipLastName,
+            line_1: order.shipAddress1,
+            line_2: order.shipAddress2,
+            line_3: order.shipAddress3,
+            line_4: order.shipAddress4,
+            line_5: order.shipAddress5,
+            city: order.shipCity,
+            postal_code: order.shipPostalCode,
+            country: order.shipCountry,
+            phone_1: order.shipPhone1,
+            phone_2: order.shipPhone2
+          } : null,
+          address_billing: {
+            first_name: order.billFirstName,
+            last_name: order.billLastName,
+            line_1: order.billAddress1,
+            line_2: order.billAddress2,
+            line_3: order.billAddress3,
+            line_4: order.billAddress4,
+            line_5: order.billAddress5,
+            city: order.billCity,
+            postal_code: order.billPostalCode,
+            country: order.billCountry,
+            phone_1: order.billPhone1,
+            phone_2: order.billPhone2
+          },
+          order_items: order.mappedOrderItems.map(orderItem => {
+            return {
+              native_item_id: orderItem.id.toString(),
+              native_variant_id: orderItem.variationId.toString(),
+              currency_code: orderItem.currency,
+              ordered_at_date: new Date(order.createdAt).toISOString().slice(0, -5) + 'Z',
+              ordered_at_time: new Date(order.createdAt).toISOString().slice(0, -5) + 'Z',
+              updated_at_date: new Date(order.updatedAt).toISOString().slice(0, -5) + 'Z',
+              updated_at_time: new Date(order.updatedAt).toISOString().slice(0, -5) + 'Z',
+              sla_expires_at: orderItem?.slaExpiresAt ? new Date(orderItem.slaExpiresAt).toISOString() : null,
+              charges: orderItem.charges.map(charge => {
+                return {
+                  charge_type_value: charge.name,
+                  amount_gross: parseFloat(charge.grossAmount) || 0,
+                  amount_nett: parseFloat(charge.nettAmount) || 0
+                }
+              }),
+              order_status_value: ORDER_STATUS[`${order.status}`]
+            }
+          }),
+          seller_logistics: order?.isSOF,
+          shipping_type: order?.shipAddress1 ? 'DROP_SHIPPING' : 'SELF_PICKUP'
+        }
+      })
+
+      return {
+        payload: [...newOrders]
+      }
+    },
+    normalize(res) {
+      return res
+    }
+  }
+}

package/server/controllers/sellercraft-channel-integration/apis/ingest-channel-product.ts

@@ -0,0 +1,97 @@
+/* https://docs.sellercraft.co/docs/api-integrations/b3A6MTY4NjQxODU-initiate-order-shipment */
+
+export function ingestChannelProduct() {
+  return {
+    method: 'post',
+    path: '/channel/ingest/product',
+    denormalize(req) {
+      const { products } = req
+
+      let newProducts = products.map(product => {
+        let productVariations: any[] = product.variations.map(variant => {
+          return {
+            seller_sku: variant.variationSku,
+            native_variant_id: variant.variationId.toString(),
+            label: variant.name,
+            is_enabled: variant.isEnabled || true,
+            is_sellable: variant.isSellable || true,
+            is_deleted: false, // default
+            variant_attributes: variant?.attributes
+              ? variant?.attributes.map(attribute => {
+                  return {
+                    ...attribute,
+                    native_attribute_id: attribute?.native_attribute_id?.toString()
+                  }
+                })
+              : [],
+            stock_locked: variant?.stockLocked ? variant.stockLocked : 0,
+            native_stock_reported: variant?.stockReported ? variant.stockReported : 0,
+            price_full: variant.fullPrice || 0,
+            price_discounted: variant.priceDiscounted || variant.fullPrice || 0,
+            inventory_products: variant?.inventoryProducts
+              ? variant.inventoryProducts.map(inventoryProduct => {
+                  return {
+                    quantity: inventoryProduct.qty || 0,
+                    name: inventoryProduct.name,
+                    inventory_sku: inventoryProduct.sku,
+                    product_versions: inventoryProduct?.productVersions
+                      ? inventoryProduct.productVersions.map(productVersion => {
+                          return {
+                            label: productVersion.label,
+                            package_content: productVersion.packageContent,
+                            package_length_mm: productVersion?.packageLengthMM ? productVersion.packageLengthMM : 0,
+                            package_width_mm: productVersion?.packageWidthMM ? productVersion.packageWidthMM : 0,
+                            package_height_mm: productVersion?.packageHeightMM ? productVersion.packageHeightMM : 0,
+                            package_weight_gram: productVersion?.packageWeightGram
+                              ? productVersion.packageWeightGram
+                              : 0,
+                            stock_available: productVersion.qty || 0
+                          }
+                        })
+                      : []
+                  }
+                })
+              : [],
+            extra_metadata: variant?.extraMetadata
+          }
+        })
+
+        return {
+          organisation_id: product.organisationId,
+          channel_shop_id: product.channelShopId,
+          channel_code: product.channelCode,
+          channel_country: product.channelCountry,
+          native_category_id: product.categoryId.toString(),
+          native_product_id: product.productId.toString(),
+          label: product.name,
+          brand: product.brand || '',
+          is_verified: product.isVerified || true,
+          flexible_attributes:
+            product.channelCode == 'WCM' || product.channelCode == 'MGT' || product.channelCode == 'SPF' ? true : false, // add channels that do not support category_attributes ingestion
+          images:
+            product?.images?.map(image => {
+              return {
+                file_url: image.url
+              }
+            }) || [],
+          product_attributes:
+            product?.attributes?.map(attribute => {
+              return {
+                ...attribute,
+                native_attribute_id: attribute.native_attribute_id.toString()
+              }
+            }) || [],
+          variants: productVariations,
+          has_all_variants: product.channelCode == 'MGT' ? false : true
+        }
+      })
+
+      return {
+        payload: [...newProducts]
+      }
+    },
+    normalize(res) {
+      return res
+    }
+  }
+}

package/server/controllers/sellercraft-channel-integration/index.ts

@@ -0,0 +1,7 @@
+import { SellercraftChannelIntegrationAPI } from '../sellercraft-channel-integration-api'
+import * as APIS from './apis'
+import { action } from './platform-action'
+
+export * from './sellercraft-channel-integration'
+
+SellercraftChannelIntegrationAPI.registerPlatform('sellercraftChannelIntegration', action, APIS)

package/server/controllers/sellercraft-channel-integration/platform-action.ts

@@ -0,0 +1,39 @@
+import { config } from '@things-factory/env'
+
+import { SellercraftChannelIntegration } from './sellercraft-channel-integration'
+
+const sellercraftConfig = config.get('sellercraftChannelIntegrationConfig', {})
+const { apiKey } = sellercraftConfig
+
+function substitute(path, obj) {
+  var props = []
+  var re = /{([^}]+)}/g
+  var text
+
+  while ((text = re.exec(path))) {
+    props.push(text[1])
+  }
+
+  var result = path
+  props.forEach(prop => {
+    let value = obj[prop.trim()]
+    result = result.replace(`{${prop}}`, value === undefined ? '' : value)
+  })
+
+  return result
+}
+
+export const action = async ({ method = 'get', path, request }) => {
+  const client = new SellercraftChannelIntegration({ apiKey })
+
+  const { resource = {}, payload = {} } = request
+
+  path = substitute(path, resource)
+
+  var response = await client[method](path, payload)
+  if (response.errors) {
+    throw response
+  }
+
+  return response
+}

package/server/controllers/sellercraft-channel-integration/sellercraft-channel-integration.ts

@@ -0,0 +1,115 @@
+import fetch from 'node-fetch'
+import { v4 as uuidv4 } from 'uuid'
+import { createPayloadLog } from '@things-factory/integration-base'
+
+const debug = require('debug')('things-factory:integration-sellercraft:sellercraft')
+
+export type SellercraftConfig = {
+  apiKey: string
+}
+
+export class SellercraftChannelIntegration {
+  private config: SellercraftConfig
+
+  constructor(config: SellercraftConfig) {
+    this.config = {
+      ...config
+    }
+  }
+
+  getBaseUrl() {
+    return `https://open.sellercraft.co/v1`
+  }
+
+  generateRequestId() {
+    return uuidv4()
+  }
+
+  async post(path: string, data: any = {}) {
+    const { apiKey } = this.config
+
+    debug('data', data)
+
+    const jsondata = JSON.stringify(data)
+    const requestId: string = this.generateRequestId()
+    const fullPath: string = `${this.getBaseUrl()}${path}`
+
+    const response: any = await fetch(fullPath, {
+      method: 'post',
+      headers: {
+        'Content-Type': 'application/json',
+        request_id: requestId,
+        'X-Api-Key': apiKey
+      },
+      body: jsondata
+    })
+
+    const result = await response.json()
+    try {
+      createPayloadLog(JSON.parse(jsondata)[0]?.channel_shop_id || requestId, fullPath, jsondata, result, {
+        state: { domain: null }
+      })
+    } catch (e) {}
+    if (response.ok) {
+      return result
+    } else {
+      throw new Error(`(${response.status}) ${result.detail}`)
+    }
+  }
+
+  async put(path: string, data: any = {}) {
+    const { apiKey } = this.config
+
+    const jsondata = JSON.stringify(data)
+    const requestId: string = this.generateRequestId()
+    const fullPath: string = `${this.getBaseUrl()}${path}`
+    debug('data', data)
+
+    const response: any = await fetch(fullPath, {
+      method: 'put',
+      headers: {
+        'Content-Type': 'application/json',
+        request_id: requestId,
+        'x-api-key': apiKey
+      },
+      body: jsondata
+    })
+
+    if (response.ok) {
+      return await response.json()
+    } else {
+      const result = await response.json()
+      throw new Error(`(${response.status}) ${result.message}`)
+    }
+  }
+
+  async get(path: string, data: any = {}) {
+    const { apiKey } = this.config
+
+    const qs = Object.entries(data)
+      .map(([k, v]) => `${k}=${encodeURIComponent(String(v))}`)
+      .join('&')
+
+    const fullPath: string = `${this.getBaseUrl()}${path}`
+    const endpoint = `${fullPath}${qs ? '?' + qs : ''}`
+    debug('endpoint', endpoint)
+
+    const requestId: string = this.generateRequestId()
+
+    const response: any = await fetch(endpoint, {
+      method: 'get',
+      headers: {
+        'Content-Type': 'application/json',
+        request_id: requestId,
+        'x-api-key': apiKey
+      }
+    })
+
+    if (response.ok) {
+      return await response.json()
+    } else {
+      const result = await response.json()
+      throw new Error(`(${response.status}) ${result.message}`)
+    }
+  }
+}

package/server/controllers/sellercraft-channel-integration-api/decorators.ts

@@ -0,0 +1,45 @@
+import Debug from 'debug'
+
+import { Sellercraft } from '../../service'
+
+const debug = Debug('things-factory:integration-marketplace:store-api-decorator')
+
+const NOOP = v => v
+
+export const api = (target: Object, property: string, descriptor: TypedPropertyDescriptor<any>): any => {
+  const method = descriptor.value
+
+  descriptor.value = async function (store: Sellercraft, request) {
+    const SellercraftChannelIntegrationAPI = this
+
+    var { platform } = store
+
+    var { action: platformAction, apis } = SellercraftChannelIntegrationAPI.getPlatform(platform)
+
+    var m = apis[method.name]
+    if (!m) {
+      throw Error(`Sellercraft doesn't have API ${method.name}`)
+    }
+
+    var {
+      path,
+      method: httpMethod = 'post',
+      denormalize = NOOP,
+      normalize = NOOP,
+      action = platformAction
+    } = m.apply(this, [request])
+
+    var denormalized = await denormalize(request || {}, { store })
+    debug('request', denormalized)
+
+    var response = await action.apply(this, [
+      { store, method: httpMethod, path, request: denormalized, platformAction }
+    ])
+
+    debug('response', response)
+
+    return await normalize(response, { store })
+  }
+
+  return descriptor
+}

package/server/controllers/sellercraft-channel-integration-api/index.ts

@@ -0,0 +1,45 @@
+import { getRepository } from '@things-factory/shell'
+
+import { Sellercraft } from '../../service'
+import { api } from './decorators'
+
+export class SellercraftChannelIntegrationAPI {
+  static platforms = {}
+
+  static registerPlatform(name, action, apis) {
+    SellercraftChannelIntegrationAPI.platforms[name] = {
+      action,
+      apis
+    }
+  }
+
+  static getPlatform(name) {
+    return SellercraftChannelIntegrationAPI.platforms[name]
+  }
+
+  static async getSellercraft(id) {
+    const repository = getRepository(Sellercraft)
+    return await repository.findOne({
+      where: { id },
+      relations: ['domain']
+    })
+  }
+
+  @api
+  static echo(sellercraft, req): any {}
+
+  @api
+  static ingestChannelCategories(sellercraft, req): any {}
+
+  @api
+  static ingestChannelCategoryAttributes(sellercraft, req): any {}
+
+  @api
+  static ingestChannelOrderPackage(sellercraft, req): any {}
+
+  @api
+  static ingestChannelOrder(sellercraft, req): any {}
+
+  @api
+  static ingestChannelProduct(sellercraft, req): any {}
+}

package/server/index.ts

@@ -0,0 +1,7 @@
+import './routes'
+
+export * from './migrations'
+export * from './middlewares'
+export * from './controllers'
+export * from './service'
+export * from './constants'

package/server/middlewares/index.ts

@@ -0,0 +1,3 @@
+export function initMiddlewares(app) {
+  /* can add middlewares into app */
+}

package/server/migrations/index.ts

@@ -0,0 +1,9 @@
+const glob = require('glob')
+const path = require('path')
+
+export var migrations = []
+
+glob.sync(path.resolve(__dirname, '.', '**', '*.js')).forEach(function(file) {
+  if (file.indexOf('index.js') !== -1) return
+  migrations = migrations.concat(Object.values(require(path.resolve(file))) || [])
+})