@things-factory/integration-powrup 4.3.238

package/server/controllers/powrup/apis/pack-order.ts

@@ -0,0 +1,32 @@
+export function packOrder() {
+  return {
+    method: 'post',
+    path: '/order-pack',
+    denormalize(req) {
+      const { refOrderId } = req
+
+      return {
+        payload: {
+          orderId: refOrderId
+        }
+      }
+    },
+    normalize(res) {
+      const { orderId, packages } = res.resultObject
+
+      const orderPackages: any[] = packages.map(pkg => {
+        return {
+          packageId: pkg.packageId,
+          items: pkg.items.map(item => {
+            return {
+              refCode: item.universalIdentifier,
+              qty: item.quantity
+            }
+          })
+        }
+      })
+
+      return { orderId, packages: orderPackages }
+    }
+  }
+}

package/server/controllers/powrup/apis/update-stock.ts

@@ -0,0 +1,30 @@
+export function updateStock() {
+  return {
+    method: 'post',
+    path: '/product/stock-update',
+    denormalize(req) {
+      const { warehouseDomainId, powrupInvs } = req
+
+      return {
+        payload: {
+          channelId: warehouseDomainId,
+          products: powrupInvs.map(pi => {
+            return {
+              universalIdentifier: pi.refCode,
+              stock: pi.stock.map(st => {
+                return {
+                  quantityTotal: st.quantityTotal,
+                  quantityReserved: st.quantityReserved,
+                  quantityBuffer: st.quantityBuffer
+                }
+              })
+            }
+          })
+        }
+      }
+    },
+    normalize(res) {
+      return res
+    }
+  }
+}

package/server/controllers/powrup/index.ts

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

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

@@ -0,0 +1,34 @@
+import { Powrup } from './powrup'
+
+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 ({ integration, method = 'get', path, request }) => {
+  const client = new Powrup({ apiKey: integration.accountId, staging: integration.staging })
+
+  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/powrup/powrup.ts

@@ -0,0 +1,74 @@
+import fetch from 'node-fetch'
+
+const debug = require('debug')('things-factory:integration-powrup:powrup')
+
+export type PowrupConfig = {
+  apiKey: string
+  staging?: boolean
+}
+
+export class Powrup {
+  private config: PowrupConfig
+
+  constructor(config: PowrupConfig) {
+    this.config = {
+      ...config
+    }
+  }
+
+  getBaseUrl() {
+    return `https://api${this.config.staging ? '-test' : ''}.powrup.asia`
+  }
+
+  async post(path: string, data: any = {}) {
+    const { apiKey } = this.config
+
+    debug('data', data)
+
+    const jsondata = JSON.stringify(data)
+    const fullPath: string = `${this.getBaseUrl()}${path}`
+
+    const response: any = await fetch(fullPath, {
+      method: 'post',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Authorization': apiKey
+      },
+      body: jsondata
+    })
+
+    if (response.ok) {
+      return await response.json()
+    } else {
+      const result = await response.text()
+      throw new Error(`(${response.status}) ${result}`)
+    }
+  }
+
+  async get(path: string, data: any = {}) {
+    const { apiKey } = this.config
+
+    const qs = Object.entries(data)
+      .map(([k, v]) => `${k}=${encodeURIComponent(String(v))}`)
+      .join('&')
+
+    const fullPath: string = `${this.getBaseUrl()}${path}`
+    const endpoint = `${fullPath}${qs ? '?' + qs : ''}`
+    debug('endpoint', endpoint)
+
+    const response: any = await fetch(endpoint, {
+      method: 'get',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Authorization': apiKey
+      }
+    })
+
+    if (response.ok) {
+      return await response.json()
+    } else {
+      const result = await response.text()
+      throw new Error(`(${response.status}) ${result}`)
+    }
+  }
+}

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

@@ -0,0 +1,54 @@
+import Debug from 'debug'
+
+import { createPayloadLog } from '@things-factory/integration-base'
+
+import { Powrup } from '../../service'
+
+const debug = Debug('things-factory:integration-powrup:powrup-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 (powrup: Powrup, request) {
+    const PowrupAPI = this
+
+    var { platform } = powrup
+
+    var { action: platformAction, apis } = PowrupAPI.getPlatform(platform)
+
+    var m = apis[method.name]
+    if (!m) {
+      throw Error(`${platform} 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 || {}, { powrup })
+    debug('request', denormalized)
+
+    try {
+      var response = await action.apply(this, [
+        { powrup, method: httpMethod, path, request: denormalized, platformAction }
+      ])
+
+      createPayloadLog(powrup.id, path, denormalized, response, request?.context)
+
+      debug('response', response)
+
+      return await normalize(response, { powrup })
+    } catch (error) {
+      createPayloadLog(powrup.id, path, denormalized, error?.message, request?.context)
+      throw error
+    }
+  }
+
+  return descriptor
+}

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

@@ -0,0 +1,42 @@
+import { getRepository } from 'typeorm'
+
+import { Powrup } from '../../service'
+import { api } from './decorators'
+
+export class PowrupAPI {
+  static platforms = {}
+
+  static registerPlatform(name, action, apis) {
+    PowrupAPI.platforms[name] = {
+      action,
+      apis
+    }
+  }
+
+  static getPlatform(name) {
+    return PowrupAPI.platforms[name]
+  }
+
+  static async getPowrup(id) {
+    const repository = getRepository(Powrup)
+    return await repository.findOne({
+      where: { id },
+      relations: ['domain']
+    })
+  }
+
+  @api
+  static echo(powrup, req): any {}
+
+  @api
+  static fetchDocument(powrup, req): any {}
+
+  @api
+  static initiateShipment(powrup, req): any {}
+
+  @api
+  static packOrder(powrup, req): any {}
+
+  @api
+  static updateStock(powrup, req): any {}
+}

package/server/index.ts

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

package/server/middlewares/index.ts

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

package/server/migrations/index.ts

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

package/server/routes.ts

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

package/server/service/powrup/index.ts

@@ -0,0 +1,6 @@
+import { Powrup } from './powrup'
+import { PowrupQuery } from './powrup-query'
+import { PowrupMutation } from './powrup-mutation'
+
+export const entities = [Powrup]
+export const resolvers = [PowrupQuery, PowrupMutation]

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

@@ -0,0 +1,112 @@
+import { Resolver, Mutation, Arg, Ctx, Directive } from 'type-graphql'
+import { getRepository, In } from 'typeorm'
+import { Powrup } from './powrup'
+import { NewPowrup, PowrupPatch } from './powrup-type'
+
+@Resolver(Powrup)
+export class PowrupMutation {
+  @Directive('@transaction')
+  @Mutation(returns => Powrup, { description: 'To create new Powrup' })
+  async createPowrup(@Arg('powrup') powrup: NewPowrup, @Ctx() context: any): Promise<Powrup> {
+    const { domain, user, tx } = context.state
+
+    return await tx.getRepository(Powrup).save({
+      ...powrup,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Powrup, { description: 'To modify Powrup information' })
+  async updatePowrup(
+    @Arg('id') id: string,
+    @Arg('patch') patch: PowrupPatch,
+    @Ctx() context: any
+  ): Promise<Powrup> {
+    const { domain, user, tx } = context.state
+
+    const repository = tx.getRepository(Powrup)
+    const powrup = await repository.findOne({
+      where: { domain, id }
+    })
+
+    return await repository.save({
+      ...powrup,
+      ...patch,
+      updater: user
+    })
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => [Powrup], { description: "To modify multiple Powrups' information" })
+  async updateMultiplePowrup(
+    @Arg('patches', type => [PowrupPatch]) patches: PowrupPatch[],
+    @Ctx() context: any
+  ): Promise<Powrup[]> {
+    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 powrupRepo = tx.getRepository(Powrup)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await powrupRepo.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 powrup = await powrupRepo.findOne(newRecord.id)
+
+        const result = await powrupRepo.save({
+          ...powrup,
+          ...newRecord,
+          updater: user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete Powrup' })
+  async deletePowrup(@Arg('id') id: string, @Ctx() context: any): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Powrup).delete({ domain, id })
+    return true
+  }
+
+  @Directive('@transaction')
+  @Mutation(returns => Boolean, { description: 'To delete multiple powrups' })
+  async deletePowrups(
+    @Arg('ids', type => [String]) ids: string[],
+    @Ctx() context: any
+  ): Promise<boolean> {
+    const { domain, tx } = context.state
+
+    await tx.getRepository(Powrup).delete({
+      domain,
+      id: In(ids)
+    })
+
+    return true
+  }
+}

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

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

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

@@ -0,0 +1,60 @@
+import { Field, ID, InputType, Int, ObjectType } from 'type-graphql'
+
+import { Platform, Powrup } from './powrup'
+
+@InputType()
+export class NewPowrup {
+  @Field()
+  name: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => Platform, { nullable: true })
+  platform?: Platform
+
+  @Field({ nullable: true })
+  apiKey?: string
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  staging?: boolean
+}
+
+@InputType()
+export class PowrupPatch {
+  @Field(type => ID, { nullable: true })
+  id?: string
+
+  @Field({ nullable: true })
+  name?: string
+
+  @Field({ nullable: true })
+  description?: string
+
+  @Field(type => Platform, { nullable: true })
+  platform?: Platform
+
+  @Field({ nullable: true })
+  apiKey?: string
+
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Field({ nullable: true })
+  staging?: boolean
+
+  @Field()
+  cuFlag: string
+}
+
+@ObjectType()
+export class PowrupList {
+  @Field(type => [Powrup])
+  items: Powrup[]
+
+  @Field(type => Int)
+  total: number
+}

package/server/service/powrup/powrup.ts

@@ -0,0 +1,113 @@
+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 { config } from '@things-factory/env'
+import { Domain } from '@things-factory/shell'
+
+const ORMCONFIG = config.get('ormconfig', {})
+const DATABASE_TYPE = ORMCONFIG.type
+
+export enum Platform {
+  POWRUP = 'POWRUP',
+  POWRUP_INTERNAL = 'POWRUP_INTERNAL'
+}
+
+registerEnumType(Platform, {
+  name: 'Platform',
+  description: 'platform enumeration of a integration'
+})
+
+@Entity()
+@Index('ix_powrup_0', (powrup: Powrup) => [powrup.domain, powrup.name], { unique: true })
+@ObjectType({ description: 'Entity for Powrup' })
+export class Powrup {
+  @PrimaryGeneratedColumn('uuid')
+  @Field(type => ID)
+  readonly id: string
+
+  @ManyToOne(type => Domain)
+  @Field({ nullable: true })
+  domain?: Domain
+
+  @RelationId((powrup: Powrup) => powrup.domain)
+  domainId?: string
+
+  @Column()
+  @Field()
+  name: string
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  description?: string
+
+  @Column({
+    nullable: true,
+    default: false
+  })
+  @Field({ nullable: true })
+  active?: boolean
+
+  @Column({
+    type:
+      DATABASE_TYPE == 'postgres' || DATABASE_TYPE == 'mysql' || DATABASE_TYPE == 'mariadb'
+        ? 'enum'
+        : DATABASE_TYPE == 'oracle'
+        ? 'varchar2'
+        : 'smallint',
+    enum: Platform,
+    default: Platform.POWRUP
+  })
+  @Field()
+  platform: Platform
+
+  @Column({
+    nullable: true
+  })
+  @Field({ nullable: true })
+  apiKey?: string
+
+  @Column({
+    nullable: true,
+    default: false
+  })
+  @Field({ nullable: true })
+  staging?: boolean
+
+  @CreateDateColumn()
+  @Field({ nullable: true })
+  createdAt?: Date
+
+  @UpdateDateColumn()
+  @Field({ nullable: true })
+  updatedAt?: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  creator?: User
+
+  @RelationId((powrup: Powrup) => powrup.creator)
+  creatorId?: string
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  @Field({ nullable: true })
+  updater?: User
+
+  @RelationId((powrup: Powrup) => powrup.creator)
+  updaterId?: string
+}