@things-factory/integration-sftp 8.0.6 → 9.0.0-beta.12

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"]
-}