@things-factory/integration-accounting 8.0.0-beta.9 → 8.0.0

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

@@ -0,0 +1,53 @@
+import { config, logger } from '@things-factory/env'
+
+import { Xero } from './xero'
+
+const xeroConfig = config.get('accountingIntegrationXero', {})
+const { apiKey, apiSecret, callback } = xeroConfig
+
+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
+}
+
+async function _action({ accounting, method = 'get', path, request }) {
+  const client = new Xero({
+    apiKey,
+    apiSecret,
+    accessToken: accounting.accessToken,
+    tenantId: accounting.accountId,
+    callback
+  })
+
+  const { resource = {}, payload = {} } = request
+
+  path = substitute(path, resource)
+
+  return await client[method](path, payload)
+}
+
+export const action = async ({ accounting, method = 'get', path, request }) => {
+  try {
+    return await _action({ accounting, method, path, request })
+  } catch (ex) {
+    if (ex.status === 401) {
+      var refreshedAccounting = await Xero.refreshAccessToken(apiKey, apiSecret, accounting)
+      return await _action({ accounting: refreshedAccounting, method, path, request })
+    } else {
+      logger.error(`Xero: action: ${ex}`)
+    }
+  }
+}

package/server/controllers/xero/xero.ts

@@ -0,0 +1,215 @@
+import fetch from 'node-fetch'
+
+import { getRepository } from '@things-factory/shell'
+import { parseJwt } from '@things-factory/utils'
+
+import { Account } from '../../entities/account'
+
+const ENDPOINT = 'https://api.xero.com/api.xro/2.0'
+const debug = require('debug')('things-factory:integration-accounting:xero')
+
+export type XeroConfig = {
+  apiKey: string
+  apiSecret: string
+  accessToken?: string
+  tenantId?: string
+  callback?: string
+}
+
+export class Xero {
+  private config: XeroConfig
+
+  constructor(config: XeroConfig) {
+    this.config = {
+      ...config
+    }
+  }
+
+  buildAuthURL(nonce) {
+    const scopes = 'offline_access openid profile email accounting.transactions accounting.settings accounting.contacts'
+    const { apiKey, callback: redirectUrl } = this.config
+
+    return `https://login.xero.com/identity/connect/authorize?response_type=code&client_id=${apiKey}&scope=${scopes}&redirect_uri=${redirectUrl}&state=${nonce}`
+  }
+
+  async get(path: string, data: any) {
+    const { accessToken, tenantId } = this.config
+
+    const qs = Object.entries(data)
+      .map(([k, v]) => `${k}=${encodeURIComponent(String(v))}`)
+      .join('&')
+
+    const endpoint = `${ENDPOINT}${path}${qs ? '?' + qs : ''}`
+    debug('endpoint', endpoint)
+
+    const response = await fetch(endpoint, {
+      method: 'get',
+      headers: {
+        accept: 'application/json',
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${accessToken}`,
+        'xero-tenant-id': tenantId
+      }
+    })
+
+    if (!response.ok) {
+      throw response
+    }
+
+    let result = await response.json()
+    debug('response result', result)
+    result = this.convertStatusCode(result)
+
+    return result
+  }
+
+  async post(path: string, data: any = {}) {
+    const { accessToken, tenantId } = this.config
+
+    debug('data', data)
+
+    const jsondata = JSON.stringify(data)
+
+    const endpoint = `${ENDPOINT}${path}`
+    debug('endpoint', endpoint)
+
+    const response = await fetch(endpoint, {
+      method: 'post',
+      headers: {
+        accept: 'application/json',
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${accessToken}`,
+        'xero-tenant-id': tenantId
+      },
+      body: jsondata
+    })
+
+    if (!response.ok) {
+      throw response
+    }
+
+    let result = await response.json()
+    debug('response result', result)
+    result = this.convertStatusCode(result)
+
+    return result
+  }
+
+  async put(path: string, data: any = {}) {
+    const { accessToken, tenantId } = this.config
+
+    debug('data', data)
+
+    const jsondata = JSON.stringify(data)
+
+    const endpoint = `${ENDPOINT}${path}`
+    debug('endpoint', endpoint)
+
+    const response = await fetch(endpoint, {
+      method: 'put',
+      headers: {
+        accept: 'application/json',
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${accessToken}`,
+        'xero-tenant-id': tenantId
+      },
+      body: jsondata
+    })
+
+    if (!response.ok) {
+      throw response
+    }
+
+    let result = await response.json()
+    debug('response result', result)
+    result = this.convertStatusCode(result)
+
+    return result
+  }
+
+  async delete(path: string, data: any = {}) {
+    const { accessToken, tenantId } = this.config
+
+    debug('data', data)
+
+    const jsondata = JSON.stringify(data)
+
+    const endpoint = `${ENDPOINT}${path}`
+    debug('endpoint', endpoint)
+
+    const response = await fetch(endpoint, {
+      method: 'delete',
+      headers: {
+        accept: 'application/json',
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${accessToken}`,
+        'xero-tenant-id': tenantId
+      },
+      body: jsondata
+    })
+
+    if (!response.ok) {
+      throw response
+    }
+
+    let result = await response.json()
+    debug('response result', result)
+    result = this.convertStatusCode(result)
+
+    return result
+  }
+
+  private convertStatusCode(result: Record<string, any>): Record<string, any> {
+    result.ok = result.Status.toLowerCase() === 'ok'
+    return result
+  }
+
+  public static async refreshAccessToken(apiKey, apiSecret, account) {
+    const refreshRequestData = {
+      grant_type: 'refresh_token',
+      refresh_token: account.refreshToken
+    }
+
+    const refreshResponse = await fetch(`https://identity.xero.com/connect/token`, {
+      method: 'post',
+      headers: {
+        Authorization: `Basic ${Buffer.from(apiKey + ':' + apiSecret).toString('base64')}`,
+        'Content-Type': 'application/x-www-form-urlencoded'
+      },
+      body: Object.entries(refreshRequestData)
+        .map(([key, value]) => encodeURIComponent(key) + '=' + encodeURIComponent(value))
+        .join('&')
+    })
+
+    if (!refreshResponse.ok) {
+      throw new Error(`get account information failed: ${await refreshResponse.text()}`)
+    }
+
+    const body = await refreshResponse.json()
+    const {
+      access_token /* token used to call the API */,
+      id_token /* token containing user identity details (only returned if OpenID Connect scopes are requested) */,
+      expires_in /* amount of seconds until the access token expires */,
+      token_type: tokenType /* must be Bearer */,
+      refresh_token
+      /* token used to refresh the access token once it has expired (only returned if the offline_access scope is requested).
+       */
+    } = body
+
+    const { exp } = parseJwt(access_token)
+
+    var patch = {
+      accessToken: access_token,
+      refreshToken: refresh_token,
+      tokenType,
+      expiresIn: new Date(exp * 1000)
+    }
+
+    const repository = getRepository(Account)
+
+    return await repository.save({
+      ...account,
+      ...patch
+    })
+  }
+}

package/server/engine/connector/accounting-connector.ts

@@ -0,0 +1,33 @@
+import { ConnectionManager, Connector } from '@things-factory/integration-base'
+
+export class AccountingConnector implements Connector {
+  async ready(connectionConfigs) {
+    await Promise.all(connectionConfigs.map(this.connect))
+
+    ConnectionManager.logger.info('accounting-connector connections are ready')
+  }
+
+  async connect(connection) {
+    const { domain, name, endpoint } = connection
+
+    ConnectionManager.addConnectionInstance(connection, { ...connection })
+
+    ConnectionManager.logger.info(`accounting-connector connection(${name}:${connection.endpoint}) is connected`)
+  }
+
+  async disconnect(connection) {
+    ConnectionManager.removeConnectionInstance(connection)
+
+    ConnectionManager.logger.info(`accounting-connector connection(${connection.name}) is disconnected`)
+  }
+
+  get parameterSpec() {
+    return []
+  }
+
+  get taskPrefixes() {
+    return ['accounting']
+  }
+}
+
+ConnectionManager.registerConnector('accounting-connector', new AccountingConnector())

package/server/engine/connector/index.ts

@@ -0,0 +1 @@
+import './accounting-connector'

package/server/engine/index.ts

@@ -0,0 +1,2 @@
+import './connector'
+import './task'

package/server/engine/task/accounting-api.ts

@@ -0,0 +1,64 @@
+import { ConnectionManager, TaskRegistry } from '@things-factory/integration-base'
+import { getRepository } from '@things-factory/shell'
+import { access } from '@things-factory/utils'
+
+import { AccountingAPI as API } from '../../controllers/accounting-api'
+import { Account } from '../../entities'
+
+async function AccountingAPI(step, { logger, data, domain }) {
+  var {
+    connection,
+    params: { account: name, api, accessor }
+  } = step
+
+  var client = ConnectionManager.getConnectionInstanceByName(domain, connection) || {}
+  if (!client) {
+    throw new Error(`no connection : ${connection}`)
+  }
+
+  if (!api) {
+    throw new Error(`no api defined`)
+  }
+
+  const repository = getRepository(Account)
+  const account: Account = await repository.findOne({
+    where: { domain: { id: domain.id }, name }
+  })
+
+  if (!account) {
+    throw new Error(`no account defined`)
+  }
+
+  var result = await API[api](account, accessor ? access(accessor, data) : {})
+
+  return {
+    data: result
+  }
+}
+
+AccountingAPI.parameterSpec = [
+  {
+    type: 'entity-selector',
+    name: 'account',
+    label: 'account',
+    property: {
+      queryName: 'accounts',
+      valueKey: 'name'
+    }
+  },
+  {
+    type: 'select',
+    name: 'api',
+    label: 'api',
+    property: {
+      options: ['', 'getAccountingInvoices']
+    }
+  },
+  {
+    type: 'string',
+    name: 'accessor',
+    label: 'accessor'
+  }
+]
+
+TaskRegistry.registerTaskHandler('accounting-api', AccountingAPI)

package/server/engine/task/index.ts

@@ -0,0 +1 @@
+import './accounting-api'

package/server/entities/account.ts

@@ -0,0 +1,86 @@
+import { User } from '@things-factory/auth-base'
+import { Domain } from '@things-factory/shell'
+import { Column, CreateDateColumn, Entity, Index, ManyToOne, PrimaryGeneratedColumn, UpdateDateColumn } from 'typeorm'
+
+@Entity()
+@Index('ix_account_0', (account: Account) => [account.domain, account.name], { unique: true })
+export class Account {
+  @PrimaryGeneratedColumn('uuid')
+  id: string
+
+  @ManyToOne(type => Domain)
+  domain: Domain
+
+  @Column()
+  platform: string
+
+  @Column({
+    nullable: true
+  })
+  accountId: string
+
+  @Column()
+  countryCode: string
+
+  @Column({
+    nullable: true
+  })
+  status: string
+
+  @Column()
+  name: string
+
+  @Column({
+    nullable: true
+  })
+  accessInfo: string
+
+  @Column({
+    nullable: true
+  })
+  accessToken: string
+
+  @Column({ default: false, nullable: true })
+  trackedInventory: Boolean
+
+  @Column({
+    nullable: true
+  })
+  refreshToken: string
+
+  @Column({
+    nullable: true
+  })
+  expiresIn: Date
+
+  @Column({
+    nullable: true
+  })
+  tokenType: string
+
+  @Column({
+    nullable: true
+  })
+  accountInfo: string
+
+  @Column({
+    nullable: true
+  })
+  description: string
+
+  @CreateDateColumn()
+  createdAt: Date
+
+  @UpdateDateColumn()
+  updatedAt: Date
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  creator: User
+
+  @ManyToOne(type => User, {
+    nullable: true
+  })
+  updater: User
+}

package/server/entities/index.ts

@@ -0,0 +1,5 @@
+import { Account } from './account'
+
+export const entities = [Account]
+
+export { Account }

package/server/graphql/index.ts

@@ -0,0 +1,7 @@
+import * as typeDefs from './types'
+import * as resolvers from './resolvers'
+
+export const schema = {
+  typeDefs,
+  resolvers
+}

package/server/graphql/resolvers/accounting/account.ts

@@ -0,0 +1,14 @@
+import { getRepository } from '@things-factory/shell'
+
+import { Account } from '../../../entities'
+
+export const accountResolver = {
+  async account(_: any, { id }, context: ResolverContext) {
+    const repository = getRepository(Account)
+
+    return await getRepository(Account).findOne({
+      where: { domain: { id: context.state.domain.id }, id },
+      relations: ['domain', 'creator', 'updater']
+    })
+  }
+}

package/server/graphql/resolvers/accounting/accounts.ts

@@ -0,0 +1,15 @@
+import { convertListParams, getRepository, ListParam } from '@things-factory/shell'
+
+import { Account } from '../../../entities'
+
+export const accountsResolver = {
+  async accounts(_: any, params: ListParam, context: ResolverContext) {
+    const { domain } = context.state
+    const convertedParams = convertListParams(params, { domain })
+    const [items, total] = await getRepository(Account).findAndCount({
+      ...convertedParams,
+      relations: ['domain', 'creator', 'updater']
+    })
+    return { items, total }
+  }
+}

package/server/graphql/resolvers/accounting/create-account.ts

@@ -0,0 +1,18 @@
+import { getRepository } from '@things-factory/shell'
+
+import { ACCOUNTING_STATUS } from '../../../controllers'
+import { Account } from '../../../entities'
+
+export const createAccount = {
+  async createAccount(_: any, { account }, context: ResolverContext) {
+    const { domain, user } = context.state
+
+    return await getRepository(Account).save({
+      status: ACCOUNTING_STATUS.INACTIVE,
+      ...account,
+      domain,
+      creator: user,
+      updater: user
+    })
+  }
+}

package/server/graphql/resolvers/accounting/delete-account.ts

@@ -0,0 +1,20 @@
+import { getRepository } from '@things-factory/shell'
+
+import { ACCOUNTING_STATUS } from '../../../controllers'
+import { Account } from '../../../entities'
+
+export const deleteAccount = {
+  async deleteAccount(_: any, { id }, context: ResolverContext) {
+    const foundAccount: Account = await getRepository(Account).findOne({
+      where: { domain: { id: context.state.domain.id }, id }
+    })
+
+    await getRepository(Account).save({
+      ...foundAccount,
+      status: ACCOUNTING_STATUS.TERMINATED,
+      updater: context.state.user
+    })
+
+    return true
+  }
+}

package/server/graphql/resolvers/accounting/delete-accounts.ts

@@ -0,0 +1,25 @@
+import { In } from 'typeorm'
+
+import { getRepository } from '@things-factory/shell'
+
+import { ACCOUNTING_STATUS } from '../../../controllers'
+import { Account } from '../../../entities'
+
+export const deleteAccounts = {
+  async deleteAccounts(_: any, { ids }, context: ResolverContext) {
+    let foundAccounts: Account[] = await getRepository(Account).find({
+      where: { domain: { id: context.state.domain.id }, id: In(ids) }
+    })
+
+    const updatedAccount = foundAccounts.map((account: Account) => {
+      return {
+        ...account,
+        status: ACCOUNTING_STATUS.TERMINATED,
+        updater: context.state.user
+      }
+    })
+
+    await getRepository(Account).save(updatedAccount)
+    return true
+  }
+}

package/server/graphql/resolvers/accounting/index.ts

@@ -0,0 +1,25 @@
+import { accountResolver } from './account'
+import { accountsResolver } from './accounts'
+
+import { updateMultipleAccount } from './update-multiple-accounts'
+import { updateAccount } from './update-account'
+import { createAccount } from './create-account'
+import { deleteAccount } from './delete-account'
+import { deleteAccounts } from './delete-accounts'
+
+import * as Xero from './xero'
+
+export const Query = {
+  ...accountsResolver,
+  ...accountResolver,
+  ...Xero.Query
+} as any
+
+export const Mutation = {
+  ...updateAccount,
+  ...updateMultipleAccount,
+  ...createAccount,
+  ...deleteAccount,
+  ...deleteAccounts,
+  ...Xero.Mutation
+}

package/server/graphql/resolvers/accounting/update-account.ts

@@ -0,0 +1,18 @@
+import { getRepository } from '@things-factory/shell'
+
+import { Account } from '../../../entities'
+
+export const updateAccount = {
+  async updateAccount(_: any, { name, patch }, context: ResolverContext) {
+    const repository = getRepository(Account)
+    const account: any = await repository.findOne({
+      where: { domain: { id: context.state.domain.id }, name }
+    })
+
+    return await repository.save({
+      ...account,
+      ...patch,
+      updater: context.state.user
+    })
+  }
+}

package/server/graphql/resolvers/accounting/update-multiple-accounts.ts

@@ -0,0 +1,44 @@
+import { getRepository } from '@things-factory/shell'
+
+import { Account } from '../../../entities'
+
+export const updateMultipleAccount = {
+  async updateMultipleAccount(_: any, { patches }, context: ResolverContext) {
+    let results = []
+    const _createRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === '+')
+    const _updateRecords = patches.filter((patch: any) => patch.cuFlag.toUpperCase() === 'M')
+    const accountRepo = getRepository(Account)
+
+    if (_createRecords.length > 0) {
+      for (let i = 0; i < _createRecords.length; i++) {
+        const newRecord = _createRecords[i]
+
+        const result = await accountRepo.save({
+          ...newRecord,
+          domain: context.state.domain,
+          creator: context.state.user,
+          updater: context.state.user
+        })
+
+        results.push({ ...result, cuFlag: '+' })
+      }
+    }
+
+    if (_updateRecords.length > 0) {
+      for (let i = 0; i < _updateRecords.length; i++) {
+        const newRecord = _updateRecords[i]
+        const account: Account = await accountRepo.findOneBy({ id: newRecord.id })
+
+        const result = await accountRepo.save({
+          ...account,
+          ...newRecord,
+          updater: context.state.user
+        })
+
+        results.push({ ...result, cuFlag: 'M' })
+      }
+    }
+
+    return results
+  }
+}