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

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

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

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

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

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

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

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

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

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

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

package/tsconfig.json

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