@things-factory/integration-sftp 8.0.0-beta.0 → 8.0.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@things-factory/integration-sftp",
-  "version": "8.0.0-beta.0",
+  "version": "8.0.0-beta.2",
   "main": "dist-server/index.js",
   "browser": "client/index.js",
   "things-factory": true,
@@ -24,13 +24,13 @@
     "migration:create": "node ../../node_modules/typeorm/cli.js migration:create ./server/migrations/migration"
   },
   "dependencies": {
-    "@things-factory/auth-base": "^8.0.0-beta.0",
-    "@things-factory/biz-base": "^8.0.0-beta.0",
-    "@things-factory/env": "^8.0.0-beta.0",
-    "@things-factory/integration-fulfillment": "^8.0.0-beta.0",
-    "@things-factory/shell": "^8.0.0-beta.0",
+    "@things-factory/auth-base": "^8.0.0-beta.2",
+    "@things-factory/biz-base": "^8.0.0-beta.2",
+    "@things-factory/env": "^8.0.0-beta.2",
+    "@things-factory/integration-fulfillment": "^8.0.0-beta.2",
+    "@things-factory/shell": "^8.0.0-beta.2",
     "aws-sdk": "^2.960.0",
     "xml-js": "^1.6.11"
   },
-  "gitHead": "add6fb8224b2cb19cbea47bed6a5ecb0424c9a28"
+  "gitHead": "f03431a09435511b2595515658f9cb8f78ba4ebb"
 }

package/server/controllers/herbalife/apis/create-serial-number.ts

@@ -1,51 +0,0 @@
-import { BACKUPPATH, SNSUBMITDATAPATH } from '../../../sftp-const'
-
-export function createSerialNumber() {
-  return {
-    method: 'post',
-    path: '{folderPath}/{folderType}{snPath}',
-    denormalize(req) {
-      let { releaseGood, inventoryItems, sftp } = req
-      let { folderPath, platform } = sftp
-      const folderType: string = sftp.isDevelopment ? `dev` : `prd`
-      const snPath: string = SNSUBMITDATAPATH
-      const backupPath: string = `${BACKUPPATH}${platform}/${folderType}`
-
-      let responseFilePattern: any = JSON.parse(sftp.responseFilePattern)
-      const { snSuffix, fileExtension, snRunningNumberDigit, snSequence } = responseFilePattern
-      let newSeq: number = parseFloat(snSequence) + 1
-      let newSequence = newSeq.toString().padStart(snRunningNumberDigit, '0')
-      let newResponseFilePattern: string = JSON.stringify({
-        ...responseFilePattern,
-        snSequence: newSeq.toString()
-      })
-      sftp = { ...sftp, responseFilePattern: newResponseFilePattern }
-
-      const today = new Date()
-      const year = today.getFullYear().toString()
-      const month = (today.getMonth() + 1).toString().padStart(2, '0')
-      const day = today.getDate().toString().padStart(2, '0')
-      const newDate = day + month + year
-
-      let title: string = snSuffix ? snSuffix : ``
-      title += `_` + newDate
-      title += `_` + newSequence
-      title += fileExtension ? `.` + fileExtension : ``
-
-      let content: string = ''
-      const orderNo: string = releaseGood.refNo
-      for (let i = 0; i < inventoryItems.length; i++) {
-        let serialNumber: string = inventoryItems[i].serialNumber
-        content += orderNo + '|' + serialNumber + '\n'
-      }
-
-      return {
-        resource: { folderPath, folderType, snPath },
-        payload: { title, content, sftp, backupPath }
-      }
-    },
-    normalize(res) {
-      return res
-    }
-  }
-}

package/server/controllers/herbalife/apis/create-shipment.ts

@@ -1,88 +0,0 @@
-import { BACKUPPATH, COMPLETEDATAPATH } from '../../../sftp-const'
-
-export function createShipment() {
-  return {
-    method: 'post',
-    path: '{folderPath}/{folderType}{shipmentCompletePath}',
-    denormalize(req) {
-      let { releaseGoods, sftp } = req
-      let { folderPath, platform } = sftp
-      const folderType: string = sftp.isDevelopment ? `dev` : `prd`
-      const shipmentCompletePath: string = COMPLETEDATAPATH
-      const backupPath: string = `${BACKUPPATH}${platform}/${folderType}`
-
-      let responseFilePattern: any = JSON.parse(sftp.responseFilePattern)
-      const { suffix, fileExtension, runningNumberDigit, sequence } = responseFilePattern
-      let newSeq: number = parseFloat(sequence) + 1
-      let newSequence = newSeq.toString().padStart(runningNumberDigit, '0')
-      let newResponseFilePattern: string = JSON.stringify({
-        ...responseFilePattern,
-        sequence: newSeq.toString()
-      })
-      sftp = { ...sftp, responseFilePattern: newResponseFilePattern }
-
-      const warehouseNumber: string = releaseGoods[0].refNo2
-      let title: string = suffix ? suffix : ``
-      title += newSequence
-      title += warehouseNumber ? `_` + warehouseNumber : ``
-      title += fileExtension ? `.` + fileExtension : ``
-
-      let backupTitle: string = releaseGoods[0].refNo + '_' + title
-      const orderNoColumn: number = 15
-      const shipmentColumn: number = 27
-      const trackingNoColumn: number = 20
-      let bulkContent = ''
-      for (let releaseGood of releaseGoods) {
-        const refNoLength: number = releaseGood.refNo.length
-        let content: string = `1710` + releaseGood.refNo
-        let spaceNeeded: number = orderNoColumn - refNoLength
-        for (let i = 0; i < spaceNeeded; i++) {
-          content += ` `
-        }
-        content += warehouseNumber
-        content += `001000001`
-        for (let i = 0; i < shipmentColumn; i++) {
-          content += ` `
-        }
-        content += `000000 `
-        for (let i = 0; i < trackingNoColumn; i++) {
-          content += ` `
-        }
-        content += `000000000000 `
-        const today = new Date()
-        const year = today.getFullYear().toString()
-        const month = (today.getMonth() + 1).toString().padStart(2, '0')
-        const day = today.getDate().toString().padStart(2, '0')
-        const newDate = year + month + day
-        content += newDate + '\n'
-
-        for (let i = 0; i < releaseGood.orderInventories.length; i++) {
-          const orderInventory: any = releaseGood.orderInventories[i]
-          let sku: string = orderInventory.product.brandSku
-          content += `1810` + releaseGood.refNo
-          for (let i = 0; i < spaceNeeded; i++) {
-            content += ` `
-          }
-          const idx = (i + 1).toString().padStart(2, '0')
-          const productCode: string = sku.substring(0, 4)
-          content += idx + `000000` + productCode
-          let productCodeSpaceNeeded = 7 - productCode.length
-          for (let i = 0; i < productCodeSpaceNeeded; i++) {
-            content += ` `
-          }
-          const orderedQty = orderInventory.releaseQty.toString().padStart(4, '0')
-          const pickedQty = orderInventory.pickedQty.toString().padStart(4, '0')
-          content += orderedQty + pickedQty + '\n'
-        }
-        bulkContent += content
-      }
-      return {
-        resource: { folderPath, folderType, shipmentCompletePath },
-        payload: { title, backupTitle, content: bulkContent, sftp, backupPath }
-      }
-    },
-    normalize(res) {
-      return res
-    }
-  }
-}

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

@@ -1,14 +0,0 @@
-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

@@ -1,119 +0,0 @@
-export function getOutboundOrder() {
-  return {
-    method: 'get',
-    path: '{folderPath}/{folderType}/sob/data/{fileKey}',
-    denormalize(req) {
-      const { folderPath, folderType, fileKey } = req
-      return {
-        resource: { folderPath, folderType, fileKey }
-      }
-    },
-    normalize(res, { sftp }) {
-      const { Order } = res
-      let isAccept: boolean = false
-
-      const responseFilePattern = JSON.parse(sftp.responseFilePattern)
-      const acceptOrderTypes = responseFilePattern.acceptOrderTypes // ['RSO', 'MSO', 'MSBO']
-      const acceptNTSStatuses = responseFilePattern.acceptNTSStatuses //['', 'BACKORDER']
-      const acceptWarehouseNumber = responseFilePattern.acceptWarehouseNumber //['NK']
-      const acceptCommand = responseFilePattern.acceptCommand //['NTS', '']
-      const acceptFreightCode = responseFilePattern.acceptFreightCode // ['PU']
-
-      let orderHeader: any = Order.OrderHeader
-      let generalInfo: any = orderHeader.General
-      let distributorDetails: any = orderHeader.DistributorDetails
-      let shippingInstructions: any = Order.ShippingInstructions
-
-      let orderType: string = generalInfo.OrderType._text
-      let ntsStatus: string = generalInfo.NTSStatus._text || ''
-      let command: string = generalInfo.Command._text || ''
-      let warehouseNumber: string = generalInfo.WarehouseNumber._text
-      let freightCode: string = shippingInstructions.FreightCode._text
-
-      if (
-        acceptWarehouseNumber.includes(warehouseNumber) &&
-        acceptOrderTypes.includes(orderType) &&
-        acceptNTSStatuses.includes(ntsStatus) &&
-        acceptCommand.includes(command) &&
-        acceptFreightCode.includes(freightCode)
-      ) {
-        isAccept = true
-      }
-
-      let shippingInstruction: string = shippingInstructions.ShippingInstructions._text
-      let ntsDateParts = generalInfo.NTS_Date._text.split('/')
-      let releaseDate: string = ntsDateParts[2] + '-' + ntsDateParts[1] + '-' + ntsDateParts[0]
-      let orderInfo: any = {
-        refNo: generalInfo.OrderNumber._text,
-        refNo2: warehouseNumber,
-        type: 'b2b',
-        releaseDate,
-        collectionOrderNo: generalInfo.OrderNumber._text,
-        marketplaceOrderStatus: ntsStatus,
-        ownTransport: true,
-        exportOption: false,
-        packingOption: false,
-        remark: shippingInstruction,
-        billTo: {
-          billingAddress: distributorDetails.BillTo.BillToAddress._text
-        },
-        deliverTo: {
-          deliveryAddress1: distributorDetails.ShipTo.Address1._text,
-          deliveryAddress2: distributorDetails.ShipTo.Address2._text,
-          deliveryAddress3: distributorDetails.ShipTo.Address3._text,
-          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
-        }
-      }
-
-      let OrderLine = Order.PickList
-      let totalItems: number = parseFloat(Order.PickList.LinesInPickList._text)
-      let itemsToPick: any[] = []
-      let checkDuplicationValidation
-      if (totalItems == 1) {
-        if (parseFloat(OrderLine.Item.QuantityReleased._text) > 0) {
-          itemsToPick.push({
-            product: {
-              sku: OrderLine.Item.StockingSKU._text
-            },
-            releaseQty: parseFloat(OrderLine.Item.QuantityReleased._text)
-          })
-        }
-      } else {
-        OrderLine.Item.map(line => {
-          if (parseFloat(line.QuantityReleased._text) > 0) {
-            itemsToPick.push({
-              product: {
-                sku: line.StockingSKU._text
-              },
-              releaseQty: parseFloat(line.QuantityReleased._text)
-            })
-          }
-        })
-      }
-
-      if (ntsStatus == 'BACKORDER' && OrderLine.Item.some(itm => itm.QuantityReleased._text == 0)) {
-        checkDuplicationValidation = false
-      }
-
-      if (itemsToPick.length == 0) {
-        isAccept = false
-      }
-
-      let orderItems: any[] = itemsToPick
-
-      let result: any = {
-        ...orderInfo,
-        orderInventories: orderItems,
-        isAccept,
-        checkDuplicationValidation
-      }
-
-      return result
-    }
-  }
-}

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

@@ -1,4 +0,0 @@
-export * from './echo'
-export * from './get-outbound-order'
-export * from './create-shipment'
-export * from './create-serial-number'

package/server/controllers/herbalife/herbalife.ts

@@ -1,53 +0,0 @@
-import '../../sftp-s3'
-
-import { xml2js } from 'xml-js'
-
-import { Sftp } from '../../service'
-import { SFTPFILESTORAGE } from '../../sftp-const'
-import { generateFiles } from '../../util/generate-files'
-
-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
-  }
-
-  async post(path: string, data: any = {}) {
-    const {
-      title,
-      backupTitle,
-      content,
-      sftp,
-      backupPath
-    }: { title: string; backupTitle: string; content: string; sftp: Sftp; backupPath: string } = data
-
-    let params: any[] = [
-      {
-        title,
-        uploadPath: path,
-        content
-      }
-    ]
-
-    if (backupPath) {
-      params.push({
-        title: backupTitle,
-        uploadPath: backupPath,
-        content
-      })
-    }
-    await generateFiles(params)
-
-    return sftp
-  }
-}

package/server/controllers/herbalife/index.ts

@@ -1,7 +0,0 @@
-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

@@ -1,34 +0,0 @@
-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

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

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

@@ -1,43 +0,0 @@
-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

@@ -1,39 +0,0 @@
-import { getRepository } from '@things-factory/shell'
-
-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 {}
-
-  @api
-  static createShipment(sftp, req): any {}
-
-  @api
-  static createSerialNumber(sftp, req): any {}
-}

package/server/index.ts

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

package/server/middlewares/index.ts

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

package/server/routes.ts

@@ -1,28 +0,0 @@
-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

@@ -1,18 +0,0 @@
-/* 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

@@ -1,6 +0,0 @@
-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

@@ -1,241 +0,0 @@
-import '../../sftp-s3'
-
-import { Arg, Ctx, Directive, Mutation, Resolver } from 'type-graphql'
-import { EntityManager, getConnection, 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, SftpStatus } 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: ResolverContext): 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: ResolverContext
-  ): Promise<Sftp> {
-    const { domain, user, tx } = context.state
-
-    const repository = tx.getRepository(Sftp)
-    const sftp = await repository.findOne({
-      where: { domain: { id: domain.id }, 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: ResolverContext
-  ): 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.findOneBy({ id: 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: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Sftp).delete({ domain: { id: domain.id }, id })
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'To delete multiple sftps' })
-  async deleteSftps(@Arg('ids', type => [String]) ids: string[], @Ctx() context: ResolverContext): Promise<boolean> {
-    const { domain, tx } = context.state
-
-    await tx.getRepository(Sftp).delete({
-      domain: { id: domain.id },
-      id: In(ids)
-    })
-
-    return true
-  }
-
-  @Mutation(returns => Boolean, { description: 'To sync all orders from sftp' })
-  async syncSftpOrders(
-    @Arg('customerDomainId', type => String) customerDomainId: string,
-    @Ctx() context: ResolverContext
-  ): Promise<boolean> {
-    await getConnection().transaction(async (tx: EntityManager) => {
-      const customerDomain: Domain = await tx.getRepository(Domain).findOneBy({ id: customerDomainId })
-
-      const customerBizplace: Bizplace = await getCustomerBizplace(customerDomainId, tx)
-
-      const sftpUsers: Sftp[] = await tx.getRepository(Sftp).find({
-        where: { domain: { id: customerDomainId }, status: SftpStatus.ACTIVE },
-        relations: ['fulfillmentCenter']
-      })
-
-      for (var i = 0; i < sftpUsers.length; i++) {
-        const sftpUser: Sftp = sftpUsers[i]
-        processSftp(sftpUser, context, customerBizplace.id)
-      }
-    })
-
-    return true
-  }
-
-  @Directive('@transaction')
-  @Mutation(returns => Boolean, { description: 'Calls syncSftpOrders for all domain Ids' })
-  async syncAllSftpOrders(@Ctx() context: ResolverContext): Promise<Boolean> {
-    try {
-      await getConnection().transaction(async tx => {
-        const sftps = await tx
-          .getRepository(Sftp)
-          .createQueryBuilder('s')
-          .where('s.status = :status', { status: 'ACTIVE' })
-          .getMany()
-
-        if (sftps.length === 0) return
-        for (const sftp of sftps) {
-          const customerBizplace = await getCustomerBizplace(sftp.domainId, tx)
-          await processSftp(sftp, context, customerBizplace.id)
-        }
-      })
-    } catch (e) {
-      console.log(e)
-    }
-    return true
-  }
-}
-
-export async function processSftp(sftpUser, context, customerBizplaceId) {
-  const fulfilmentCenter: FulfillmentCenter = sftpUser.fulfillmentCenter
-  const isDevelopment: boolean = sftpUser.isDevelopment
-  const folderPath: string = sftpUser.folderPath
-  const folderType: string = isDevelopment ? 'dev' : 'prd'
-  let initialDataPath: string = `${sftpUser.folderPath}/${folderType}${SUBMITDATAPATH}/`
-  const results: any[] = await getPermittedDirectories({ path: initialDataPath }, context)
-  const filesDirectories: any[] = results.filter(result => result.Size > 0)
-
-  for await (let fileDirectory of filesDirectories) {
-    let dataPath: string = `${sftpUser.folderPath}/${folderType}${SUBMITDATAPATH}/`
-    let successPath: string = `${sftpUser.folderPath}/${folderType}${SUCCESSDATAPATH}/`
-    let failedPath: string = `${sftpUser.folderPath}/${folderType}${FAILEDDATAPATH}/`
-    const fileKey: string = fileDirectory.Key
-    const lastSlashIdx = fileKey.lastIndexOf('/')
-    const fileString: string = fileKey.substring(lastSlashIdx + 1, fileKey.length)
-    try {
-      const sftp: any = sftpUser
-      let result: any = await SftpAPI.getOutboundOrder(sftp, { folderPath, folderType, fileKey: fileString })
-      let isAccept: boolean = result.isAccept
-
-      if (isAccept) {
-        delete result.isAccept
-        if (result) {
-          let { items: releaseOrders }: any = await FulfillmentAPI.getOutboundOrders(fulfilmentCenter, {
-            customerBizplaceId,
-            refNo: result.refNo
-          })
-
-          if (releaseOrders) {
-            result.collectionOrderNo = result.collectionOrderNo + ' - ' + (releaseOrders.length + 1)
-          }
-
-          result.requiredDraft = false
-
-          const releaseOrder: any = await FulfillmentAPI.createOutboundOrder(fulfilmentCenter, {
-            customerBizplaceId,
-            releaseOrder: result
-          })
-
-          if (releaseOrder) {
-            let movePaths = {
-              source: (dataPath += fileString),
-              destination: (successPath += fileString)
-            }
-            await SFTPFILESTORAGE.moveFile(movePaths)
-          }
-        }
-      } else {
-        let movePaths = {
-          source: (dataPath += fileString),
-          destination: (failedPath += fileString)
-        }
-        await SFTPFILESTORAGE.moveFile(movePaths)
-      }
-    } catch (e) {
-      let movePaths = {
-        source: (dataPath += fileString),
-        destination: (failedPath += fileString)
-      }
-      await SFTPFILESTORAGE.moveFile(movePaths)
-    }
-  }
-}
-
-export async function getCustomerBizplace(customerDomainId, tx): Promise<Bizplace> {
-  const customerDomain: Domain = await tx.getRepository(Domain).findOneBy({ id: customerDomainId })
-
-  const customerBizplace: Bizplace = await tx.getRepository(Bizplace).findOne({
-    where: { domain: { id: customerDomain.id } }
-  })
-
-  return customerBizplace
-}

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

@@ -1,44 +0,0 @@
-import { Arg, Args, Ctx, FieldResolver, Query, Resolver, Root } from 'type-graphql'
-
-import { User } from '@things-factory/auth-base'
-import { convertListParams, Domain, getRepository, 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: ResolverContext): Promise<Sftp> {
-    const { domain } = context.state
-
-    return await getRepository(Sftp).findOne({
-      where: { domain: { id: domain.id }, id }
-    })
-  }
-
-  @Query(returns => SftpList, { description: 'To fetch multiple Sftps' })
-  async sftps(@Args(type => ListParam) params: ListParam, @Ctx() context: ResolverContext): Promise<SftpList> {
-    const { domain } = context.state
-
-    const convertedParams = convertListParams(params, { domain })
-    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).findOneBy({ id: sftp.domainId })
-  }
-
-  @FieldResolver(type => User)
-  async updater(@Root() sftp: Sftp): Promise<User> {
-    return await getRepository(User).findOneBy({ id: sftp.updaterId })
-  }
-
-  @FieldResolver(type => User)
-  async creator(@Root() sftp: Sftp): Promise<User> {
-    return await getRepository(User).findOneBy({ id: sftp.creatorId })
-  }
-}

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

@@ -1,78 +0,0 @@
-import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
-
-import { Sftp, SftpStatus } from './sftp'
-
-@InputType()
-export class NewSftp {
-  @Field()
-  name: string
-
-  @Field({ nullable: true })
-  description?: string
-
-  @Field(type => SftpStatus, { nullable: true })
-  status?: SftpStatus
-
-  @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(type => SftpStatus, { nullable: true })
-  status?: SftpStatus
-
-  @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
-}

package/server/service/sftp/sftp.ts

@@ -1,143 +0,0 @@
-import { Field, ID, ObjectType, registerEnumType } from 'type-graphql'
-import {
-  Column,
-  CreateDateColumn,
-  Entity,
-  Index,
-  ManyToOne,
-  PrimaryGeneratedColumn,
-  RelationId,
-  UpdateDateColumn
-} from 'typeorm'
-
-import { User } from '@things-factory/auth-base'
-import { FulfillmentCenter } from '@things-factory/integration-fulfillment'
-import { Domain } from '@things-factory/shell'
-
-export enum SftpStatus {
-  ACTIVE = 'ACTIVE',
-  INACTIVE = 'INACTIVE',
-  TERMINATED = 'TERMINATED'
-}
-
-registerEnumType(SftpStatus, {
-  name: 'SftpStatus',
-  description: 'state enumeration of a sftp'
-})
-
-@Entity()
-@Index('ix_sftp_0', (sftp: Sftp) => [sftp.domain, sftp.name], { unique: true })
-@ObjectType({ description: 'Entity for Sftp' })
-export class Sftp {
-  @PrimaryGeneratedColumn('uuid')
-  @Field(type => ID)
-  readonly id: string
-
-  @ManyToOne(type => Domain)
-  @Field(type => Domain)
-  domain?: Domain
-
-  @RelationId((sftp: Sftp) => sftp.domain)
-  domainId?: string
-
-  @Column()
-  @Field()
-  name: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  description?: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  status?: SftpStatus
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  username?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  publicKey?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  privateKey?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  folderPath?: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  isDevelopment?: boolean
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  platform?: string
-
-  @ManyToOne(type => FulfillmentCenter, { nullable: true })
-  fulfillmentCenter: FulfillmentCenter
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  responseType: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  responseFilePattern: string
-
-  @Column({
-    nullable: true
-  })
-  @Field({ nullable: true })
-  responseFileTypes: string
-
-  @Column({ nullable: true })
-  @Field({ nullable: true })
-  lastTimeSync?: Date
-
-  @CreateDateColumn()
-  @Field({ nullable: true })
-  createdAt?: Date
-
-  @UpdateDateColumn()
-  @Field({ nullable: true })
-  updatedAt?: Date
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field(type => User, { nullable: true })
-  creator?: User
-
-  @RelationId((sftp: Sftp) => sftp.creator)
-  creatorId?: string
-
-  @ManyToOne(type => User, {
-    nullable: true
-  })
-  @Field(type => User, { nullable: true })
-  updater?: User
-
-  @RelationId((sftp: Sftp) => sftp.updater)
-  updaterId?: string
-}

package/server/sftp-const.ts

@@ -1,13 +0,0 @@
-import { config } from '@things-factory/env'
-
-export var SFTPFILESTORAGE: any = config.get('sftpFileStorage')
-export var SUBMITDATAPATH: string = '/sob/data'
-export var SUCCESSDATAPATH: string = '/sob/success'
-export var FAILEDDATAPATH: string = '/sob/failed'
-export var COMPLETEDATAPATH: string = '/oc/data01'
-export var COMPLETESUCCESSDATAPATH: string = '/oc/success'
-export var COMPLETEFAILEDDATAPATH: string = '/oc/failed'
-export var SNSUBMITDATAPATH: string = '/sn/data'
-export var SNSUCCESSDATAPATH: string = '/sn/success'
-export var SNFAILEDDATAPATH: string = '/sn/failed'
-export var BACKUPPATH: string = 'hatiosea/'

package/server/sftp-s3.ts

@@ -1,92 +0,0 @@
-import AWS from 'aws-sdk'
-
-import { logger } from '@things-factory/env'
-
-import { SFTPFILESTORAGE } from './sftp-const'
-
-const crypto = require('crypto')
-
-const { PassThrough } = require('stream')
-
-if (SFTPFILESTORAGE && SFTPFILESTORAGE.type == 's3') {
-  const S3 = new AWS.S3({
-    accessKeyId: SFTPFILESTORAGE.accessKeyId,
-    secretAccessKey: SFTPFILESTORAGE.secretAccessKey
-  })
-
-  SFTPFILESTORAGE.readFolders = async (params, encoding) => {
-    let S3params = {
-      Bucket: SFTPFILESTORAGE.bucketName,
-      Delimiter: '/',
-      Prefix: params.path
-    }
-
-    const result = await S3.listObjects(S3params).promise()
-
-    let body = result.Contents
-
-    return body
-  }
-
-  SFTPFILESTORAGE.readFile = async (path, encoding) => {
-    const result = await S3.getObject({
-      Bucket: SFTPFILESTORAGE.bucketName,
-      Key: path
-    }).promise()
-
-    var body = result.Body
-
-    if (encoding) {
-      return body.toString(encoding)
-    }
-
-    return body
-  }
-
-  SFTPFILESTORAGE.moveFile = async (path, encoding) => {
-    const copyResult = await S3.copyObject({
-      Bucket: SFTPFILESTORAGE.bucketName,
-      CopySource: SFTPFILESTORAGE.bucketName + '/' + path.source,
-      Key: path.destination
-    }).promise()
-
-    const copyBody = copyResult.CopyObjectResult
-
-    const deleteResult = await S3.deleteObject({
-      Bucket: SFTPFILESTORAGE.bucketName,
-      Key: path.source
-    }).promise()
-
-    return true
-  }
-
-  /* upload file */
-  SFTPFILESTORAGE.uploadFile = ({ stream, filename, uploadPath }) => {
-    const id = crypto.randomUUID()
-    let size: number = 0
-
-    return new Promise<{ id: string; path: string; size: number }>((resolve, reject) =>
-      stream
-        .pipe(
-          (() => {
-            var pass = new PassThrough()
-
-            S3.upload(
-              {
-                Bucket: SFTPFILESTORAGE.bucketName,
-                Key: uploadPath + '/' + filename,
-                Body: pass
-              },
-              (err, data) => (err ? reject(err) : resolve({ id, path: uploadPath, size }))
-            )
-
-            return pass
-          })()
-        )
-        .on('error', error => reject(error))
-        .on('data', chunk => (size += chunk.length))
-    )
-  }
-
-  logger.info('S3 Bucket Storage is Ready.')
-}

package/server/util/generate-files.ts

@@ -1,33 +0,0 @@
-import '../sftp-s3'
-
-import { SFTPFILESTORAGE } from '../sftp-const'
-
-const fs = require('fs')
-
-export async function generateFiles(params: any[]) {
-  const fileDirectory = './uploaded-files'
-  for (let i = 0; i < params.length; i++) {
-    let param: any = params[i]
-    const { uploadPath, content, title } = param
-
-    if (!fs.existsSync(fileDirectory)) {
-      fs.mkdirSync(fileDirectory)
-    }
-
-    const filePath = fileDirectory + '/' + title
-
-    fs.writeFile(filePath, content, function (err) {
-      if (err) throw err
-      console.log('File is created successfully.')
-    })
-
-    if (uploadPath) {
-      const stream = fs.createReadStream(filePath)
-      await SFTPFILESTORAGE.uploadFile({ stream, filename: title, uploadPath })
-    }
-  }
-
-  fs.rm(fileDirectory, { recursive: true })
-
-  return true
-}

package/server/util/get-permitted-directories.ts

@@ -1,15 +0,0 @@
-import '../sftp-s3'
-
-import { SFTPFILESTORAGE } from '../sftp-const'
-
-export async function getPermittedDirectories(params: any, context: ResolverContext) {
-  const sftpDirectories: any[] = await SFTPFILESTORAGE.readFolders(params)
-
-  return sftpDirectories
-}
-
-export async function readFile(fileKey: any) {
-  const file: any = await SFTPFILESTORAGE.readFile(fileKey, 'utf-8')
-
-  return file
-}

package/server/util/index.ts

@@ -1,2 +0,0 @@
-export * from './get-permitted-directories'
-export * from './generate-files'

package/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../tsconfig-base.json",
-  "compilerOptions": {
-    "outDir": "./dist-server",
-    "baseUrl": "./"
-  },
-  "include": ["./server/**/*"],
-  "exclude": ["**/*.spec.ts"]
-}