@things-factory/integration-sftp 3.8.8

package/dist-server/util/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./get-permitted-directories"), exports);
+//# sourceMappingURL=index.js.map

package/dist-server/util/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../server/util/index.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,8DAA2C"}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@things-factory/integration-sftp",
+  "version": "3.8.8",
+  "main": "dist-server/index.js",
+  "browser": "client/index.js",
+  "things-factory": true,
+  "license": "MIT",
+  "author": "heartyoh",
+  "description": "Integration With SFTP",
+  "publishConfig": {
+    "access": "public",
+    "@things-factory:registry": "https://registry.npmjs.org"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/hatiolab/things-factory.git",
+    "directory": "packages/integration-sftp"
+  },
+  "scripts": {
+    "build": "tsc --p tsconfig.json",
+    "build:server": "npm run clean:server && tsc",
+    "clean:server": "rm -rf dist-server",
+    "clean": "npm run clean:server",
+    "migration:create": "node ../../node_modules/typeorm/cli.js migration:create -d ./server/migrations"
+  },
+  "dependencies": {
+    "@things-factory/auth-base": "^3.8.0",
+    "@things-factory/biz-base": "^3.8.0",
+    "@things-factory/env": "^3.7.5",
+    "@things-factory/integration-fulfillment": "^3.8.0",
+    "@things-factory/shell": "^3.8.0",
+    "aws-sdk": "^2.960.0",
+    "xml-js": "^1.6.11"
+  },
+  "gitHead": "3f0cf4cd9eba27f4b4a7688c462cc3183dd9df00"
+}

package/server/controllers/herbalife/apis/echo.ts

@@ -0,0 +1,14 @@
+export function echo() {
+  return {
+    path: '/echo',
+    denormalize(req) {
+      return { ...req }
+    },
+    normalize(res) {
+      return { ...res }
+    },
+    action({ store, method, path, request, platformAction }) {
+      return { ...request }
+    }
+  }
+}

package/server/controllers/herbalife/apis/get-outbound-order.ts

@@ -0,0 +1,76 @@
+export function getOutboundOrder() {
+  return {
+    method: 'get',
+    path: '{folderPath}/{folderType}/submit_outbound/data/{fileKey}',
+    denormalize(req) {
+      const { folderPath, folderType, fileKey } = req
+      return {
+        resource: { folderPath, folderType, fileKey }
+      }
+    },
+    normalize(res) {
+      const { Order } = res
+
+      let orderHeader: any = Order.OrderHeader
+      let generalInfo: any = orderHeader.General
+      let distributorDetails: any = orderHeader.DistributorDetails
+      let ntsDateParts = generalInfo.NTS_Date._text.split('/')
+      let releaseDate: string = ntsDateParts[2] + '-' + ntsDateParts[1] + '-' + ntsDateParts[0]
+      let orderInfo: any = {
+        refNo: generalInfo.OrderNumber._text,
+        type: 'b2c',
+        releaseDate,
+        collectionOrderNo: generalInfo.OrderNumber._text,
+        ownTransport: true,
+        exportOption: false,
+        packingOption: true,
+        billTo: {
+          billingAddress: distributorDetails.BillTo.BillToAddress._text
+        },
+        deliverTo: {
+          deliveryAddress1: distributorDetails.ShipTo.Address1._text,
+          deliveryAddress2: distributorDetails.ShipTo.Address2._text,
+          deliveryAddress3: distributorDetails.ShipTo.Address3._text,
+          deliveryAddress4: '-',
+          deliveryAddress5: '-',
+          attentionTo: distributorDetails.ShipTo.Name._text,
+          city: distributorDetails.ShipTo.City._text,
+          state: distributorDetails.ShipTo.ShipToState._text,
+          postalCode: distributorDetails.ShipTo.Zipcode._text,
+          country: distributorDetails.ShipTo.Country._text,
+          phone1: distributorDetails.ShipTo.Phone._text,
+          phone2: '-',
+          email: '-'
+        }
+      }
+
+      let OrderLine = Order.OrderLine
+      let totalItems: number = parseFloat(Order.OrderLine.NumberOfOrderLines._text)
+      let orderItems: any[] =
+        totalItems == 1
+          ? [
+              {
+                product: {
+                  sku: OrderLine.Item.StockingSKU._text
+                },
+                releaseQty: parseFloat(OrderLine.Item.QtyOrdered._text)
+              }
+            ]
+          : OrderLine.Item.map(line => {
+              return {
+                product: {
+                  sku: line.StockingSKU._text
+                },
+                releaseQty: parseFloat(line.QtyOrdered._text)
+              }
+            })
+
+      let result: any = {
+        ...orderInfo,
+        orderInventories: orderItems
+      }
+
+      return result
+    }
+  }
+}

package/server/controllers/herbalife/apis/index.ts

@@ -0,0 +1,2 @@
+export * from './echo'
+export * from './get-outbound-order'

package/server/controllers/herbalife/herbalife.ts

@@ -0,0 +1,22 @@
+import '../../sftp-s3'
+
+import { xml2js } from 'xml-js'
+
+import { SFTPFILESTORAGE } from '../../sftp-const'
+
+const debug = require('debug')('things-factory:integration-sftp:herbalife')
+
+export type HerbalifeConfig = {}
+
+export class Herbalife {
+  constructor() {}
+
+  async get(path: string, data: any = {}) {
+    const fileResult: any = await SFTPFILESTORAGE.readFile(path, 'utf-8')
+    const item: any = xml2js(fileResult, {
+      compact: true
+    })
+    const result: any = { ...item }
+    return result
+  }
+}

package/server/controllers/herbalife/index.ts

@@ -0,0 +1,7 @@
+import { SftpAPI } from '../sftp-api'
+import * as APIS from './apis'
+import { action } from './platform-action'
+
+export * from './herbalife'
+
+SftpAPI.registerPlatform('herbalife', action, APIS)

package/server/controllers/herbalife/platform-action.ts

@@ -0,0 +1,34 @@
+import { Herbalife } from './herbalife'
+
+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 Herbalife()
+
+  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/index.ts

@@ -0,0 +1,3 @@
+import './herbalife'
+
+export * from './sftp-api'

package/server/controllers/sftp-api/decorators.ts

@@ -0,0 +1,43 @@
+import Debug from 'debug'
+
+import { Sftp } from '../../service'
+
+const debug = Debug('things-factory:integration-sftp:sftp-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 (sftp: Sftp, request) {
+    const SftpAPI = this
+
+    var { platform } = sftp
+
+    var { action: platformAction, apis } = SftpAPI.getPlatform(platform)
+
+    var m = apis[method.name]
+    if (!m) {
+      throw Error(`SFTP 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 || {}, { sftp })
+    debug('request', denormalized)
+
+    var response = await action.apply(this, [{ sftp, method: httpMethod, path, request: denormalized, platformAction }])
+
+    debug('response', response)
+
+    return await normalize(response, { sftp })
+  }
+
+  return descriptor
+}

package/server/controllers/sftp-api/index.ts

@@ -0,0 +1,33 @@
+import { getRepository } from 'typeorm'
+
+import { Sftp } from '../../service'
+import { api } from './decorators'
+
+export class SftpAPI {
+  static platforms = {}
+
+  static registerPlatform(name, action, apis) {
+    SftpAPI.platforms[name] = {
+      action,
+      apis
+    }
+  }
+
+  static getPlatform(name) {
+    return SftpAPI.platforms[name]
+  }
+
+  static async getSftp(id) {
+    const repository = getRepository(Sftp)
+    return await repository.findOne({
+      where: { id },
+      relations: ['domain']
+    })
+  }
+
+  @api
+  static echo(sftp, req): any {}
+
+  @api
+  static getOutboundOrder(sftp, req): any {}
+}

package/server/index.ts

@@ -0,0 +1,6 @@
+import './routes'
+
+export * from './middlewares'
+export * from './service'
+export * from './sftp-const'
+export * from './util'

package/server/middlewares/index.ts

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

package/server/routes.ts

@@ -0,0 +1,28 @@
+const debug = require('debug')('things-factory:integration-sftp: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) => {})
+   */
+})
+
+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,18 @@
+/* EXPORT ENTITY TYPES */
+export * from './sftp/sftp'
+
+/* IMPORT ENTITIES AND RESOLVERS */
+import { entities as SftpEntities, resolvers as SftpResolvers } from './sftp'
+
+export const entities = [  
+  /* ENTITIES */
+	...SftpEntities,
+] 
+
+
+export const schema = {
+  resolverClasses: [
+    /* RESOLVER CLASSES */
+		...SftpResolvers,
+  ] 
+}

package/server/service/sftp/index.ts

@@ -0,0 +1,6 @@
+import { Sftp } from './sftp'
+import { SftpQuery } from './sftp-query'
+import { SftpMutation } from './sftp-mutation'
+
+export const entities = [Sftp]
+export const resolvers = [SftpQuery, SftpMutation]

package/server/service/sftp/sftp-mutation.ts

@@ -0,0 +1,185 @@
+import '../../sftp-s3'
+
+import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
+import { In } from 'typeorm'
+
+import { Bizplace } from '@things-factory/biz-base'
+import { FulfillmentAPI, FulFillmentCenter } from '@things-factory/integration-fulfillment'
+import { Domain } from '@things-factory/shell'
+
+import { SftpAPI } from '../../controllers'
+import { FAILEDDATAPATH, SFTPFILESTORAGE, SUBMITDATAPATH, SUCCESSDATAPATH } from '../../sftp-const'
+import { getPermittedDirectories } from '../../util'
+import { Sftp } from './sftp'
+import { NewSftp, SftpPatch } from './sftp-type'
+
+@Resolver(Sftp)
+export class SftpMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Sftp, { description: 'To create new Sftp' })
+  async createSftp(@Arg('sftp') sftp: NewSftp, @Ctx() context: any): Promise<Sftp> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(Sftp).save({
+      ...sftp,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Sftp, { description: 'To modify Sftp information' })
+  async updateSftp(@Arg('id') id: string, @Arg('patch') patch: SftpPatch, @Ctx() context: any): Promise<Sftp> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(Sftp)
+    const sftp = await repository.findOne({
+      where: { domain, id }
+    })
+
+    return await repository.save({
+      ...sftp,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [Sftp], { description: "To modify multiple Sftps' information" })
+  async updateMultipleSftp(
+    @Arg('patches', type => [SftpPatch]) patches: SftpPatch[],
+    @Ctx() context: any
+  ): Promise<Sftp[]> {
+    const { domain, user, tx } = context.state
+
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const sftpRepo = tx.getRepository(Sftp)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await sftpRepo.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 sftp = await sftpRepo.findOne(newRecord.id)
+
+        const result = await sftpRepo.save({
+          ...sftp,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete Sftp' })
+  async deleteSftp(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Sftp).delete({ domain, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple sftps' })
+  async deleteSftps(@Arg('ids', type => [String]) ids: string[], @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Sftp).delete({
+      domain,
+      id: In(ids)
+    })
+
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To sync all orders from sftp' })
+  async syncSftpOrders(
+    @Arg('customerDomainId', type => String) customerDomainId: string,
+    @Ctx() context: any
+  ): Promise<boolean> {
+    const { tx } = context.state
+
+    const customerDomain: Domain = await tx.getRepository(Domain).findOne(customerDomainId)
+
+    const customerBizplace: Bizplace = await tx.getRepository(Bizplace).findOne({
+      where: { domain: customerDomain }
+    })
+
+    const customerBizplaceId: string = customerBizplace.id
+
+    const sftpUsers: Sftp[] = await tx.getRepository(Sftp).find({
+      where: { domain: customerDomain },
+      relations: ['fulfillmentCenter']
+    })
+
+    for (var i = 0; i < sftpUsers.length; i++) {
+      const sftpUser: Sftp = sftpUsers[i]
+
+      const fulfilmentCenter: FulFillmentCenter = sftpUser.fulfillmentCenter
+      const isDevelopment: boolean = sftpUser.isDevelopment
+      const folderPath: string = sftpUser.folderPath
+      const folderType: string = isDevelopment ? 'development' : 'production'
+      let dataPath: string = `${sftpUser.folderPath}/${folderType}${SUBMITDATAPATH}/`
+      let successPath: string = `${sftpUser.folderPath}/${folderType}${SUCCESSDATAPATH}/`
+      let failedPath: string = `${sftpUser.folderPath}/${folderType}${FAILEDDATAPATH}/`
+      const results: any[] = await getPermittedDirectories({ path: dataPath }, context)
+      const filesDirectories: any[] = results.filter(result => result.Size > 0)
+
+      for (var j = 0; j < filesDirectories.length; j++) {
+        const fileDirectory: any = filesDirectories[j]
+        const fileKey: string = fileDirectory.Key
+        const lastSlashIdx = fileKey.lastIndexOf('/')
+        const fileString: string = fileKey.substring(lastSlashIdx + 1, fileKey.length)
+        try {
+          const sftp: any = { platform: sftpUser.platform }
+          const result: any = await SftpAPI.getOutboundOrder(sftp, { folderPath, folderType, fileKey: fileString })
+
+          if (result) {
+            var releaseOrder: any = await FulfillmentAPI.createOutboundOrder(fulfilmentCenter, {
+              customerBizplaceId,
+              releaseOrder: result
+            })
+
+            if (releaseOrder) {
+              let movePaths = {
+                source: dataPath += fileString,
+                destination: successPath += fileString
+              }
+              await SFTPFILESTORAGE.moveFile(movePaths)
+            }
+          }
+        } catch (e) {
+          let movePaths = {
+            source: dataPath += fileString,
+            destination: failedPath += fileString
+          }
+          await SFTPFILESTORAGE.moveFile(movePaths)
+        }
+      }
+    }
+
+    return true
+  }
+}

package/server/service/sftp/sftp-query.ts

@@ -0,0 +1,45 @@
+import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
+import { getRepository } from 'typeorm'
+
+import { User } from '@things-factory/auth-base'
+import { convertListParams, Domain, ListParam } from '@things-factory/shell'
+
+import { Sftp } from './sftp'
+import { SftpList } from './sftp-type'
+
+@Resolver(Sftp)
+export class SftpQuery {
+  @Query(returns => Sftp, { description: 'To fetch a Sftp' })
+  async sftp(@Arg('id') id: string, @Ctx() context: any): Promise<Sftp> {
+    const { domain } = context.state
+
+    return await getRepository(Sftp).findOne({
+      where: { domain, id }
+    })
+  }
+
+  @Query(returns => SftpList, { description: 'To fetch multiple Sftps' })
+  async sftps(@Args() params: ListParam, @Ctx() context: any): Promise<SftpList> {
+    const { domain } = context.state
+
+    const convertedParams = convertListParams(params, domain.id)
+    const [items, total] = await getRepository(Sftp).findAndCount(convertedParams)
+
+    return { items, total }
+  }
+
+  @FieldResolver(type => Domain)
+  async domain(@Root() sftp: Sftp): Promise<Domain> {
+    return await getRepository(Domain).findOne(sftp.domainId)
+  }
+
+  @FieldResolver(type => User)
+  async updater(@Root() sftp: Sftp): Promise<User> {
+    return await getRepository(User).findOne(sftp.updaterId)
+  }
+
+  @FieldResolver(type => User)
+  async creator(@Root() sftp: Sftp): Promise<User> {
+    return await getRepository(User).findOne(sftp.creatorId)
+  }
+}

package/server/service/sftp/sftp-type.ts

@@ -0,0 +1,72 @@
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { Sftp } from './sftp'
+
+@InputType()
+export class NewSftp {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  username?: string
+
+  @Field({ nullable: true })
+  publicKey?: string
+
+  @Field({ nullable: true })
+  privateKey?: string
+
+  @Field({ nullable: true })
+  folderPath?: string
+
+  @Field({ nullable: true })
+  isDevelopment?: boolean
+
+  @Field({ nullable: true })
+  platform?: string
+}
+
+@InputType()
+export class SftpPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field({ nullable: true })
+  username?: string
+
+  @Field({ nullable: true })
+  publicKey?: string
+
+  @Field({ nullable: true })
+  privateKey?: string
+
+  @Field({ nullable: true })
+  folderPath?: string
+
+  @Field({ nullable: true })
+  isDevelopment?: boolean
+
+  @Field({ nullable: true })
+  platform?: string
+
+  @Field()
+  cuFlag: string
+}
+
+@ObjectType()
+export class SftpList {
+  @Field(type => [Sftp])
+  items: Sftp[]
+
+  @Field(type => Int)
+  total: number
+}