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

package/server/graphql/resolvers/accounting/xero/deactivate-xero-account.ts

@@ -0,0 +1,57 @@
+import fetch from 'node-fetch'
+
+import { getRepository } from '@things-factory/shell'
+
+import { ACCOUNTING_STATUS } from '../../../../controllers'
+import { Account } from '../../../../entities'
+
+const debug = require('debug')('things-factory:integration-accounting:deactivate-xero-account')
+
+export const deactivateXeroAccount = {
+  async deactivateXeroAccount(_: any, { id }, context: ResolverContext) {
+    const repository = getRepository(Account)
+    const account: any = await repository.findOne({
+      where: { domain: { id: context.state.domain.id }, id }
+    })
+
+    try {
+      const connection = JSON.parse(account.accountInfo)
+
+      if (connection) {
+        /* delete connection request to xero */
+        const response = await fetch(`https://api.xero.com/connections/${connection.id}`, {
+          method: 'delete',
+          headers: {
+            Authorization: `Bearer ${account.accessToken}`
+          }
+        })
+
+        if (!response.ok) {
+          debug('delete connection failed', response.status, await response.text())
+        }
+      } else {
+        debug(`connection info from accountInfo is empty`)
+      }
+    } catch (err) {
+      debug(`get connection info failed from accountInfo`)
+    }
+
+    var patch = {
+      accountId: '',
+      accessToken: '',
+      refreshToken: '',
+      accessInfo: '',
+      expiresIn: null,
+      tokenType: '',
+      accountInfo: '',
+      countryCode: '',
+      status: ACCOUNTING_STATUS.INACTIVE
+    }
+
+    return await repository.save({
+      ...account,
+      ...patch,
+      updater: context.state.user
+    })
+  }
+}

package/server/graphql/resolvers/accounting/xero/get-xero-auth-url.ts

@@ -0,0 +1,32 @@
+import crypto from 'crypto'
+
+import { VerificationToken, VerificationTokenType } from '@things-factory/auth-base'
+import { config } from '@things-factory/env'
+import { getRepository } from '@things-factory/shell'
+
+import { Xero } from '../../../../controllers/xero'
+
+const xeroConfig = config.get('accountingIntegrationXero', {})
+const { apiKey, apiSecret, callback } = xeroConfig
+
+export function makeVerificationTokenForNonce() {
+  return crypto.randomBytes(16).toString('hex')
+}
+
+export const getXeroAuthURL = {
+  async getXeroAuthURL(_: any, { accounting }, context: ResolverContext) {
+    const { user } = context.state
+    const xero = new Xero({ apiKey, apiSecret, callback })
+
+    /* generate verification-token as a nonce */
+    const nonce = makeVerificationTokenForNonce()
+    await getRepository(VerificationToken).save({
+      userId: user.id,
+      token: nonce,
+      type: VerificationTokenType.REQUEST_ACCESS_TOKEN,
+      suppliment: accounting
+    })
+
+    return xero.buildAuthURL(nonce)
+  }
+}

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

@@ -0,0 +1,13 @@
+import { getXeroAuthURL } from './get-xero-auth-url'
+
+import { deactivateXeroAccount } from './deactivate-xero-account'
+import { refreshXeroAccessToken } from './refresh-xero-access-token'
+
+export const Query = {
+  ...getXeroAuthURL
+}
+
+export const Mutation = {
+  ...refreshXeroAccessToken,
+  ...deactivateXeroAccount
+}

package/server/graphql/resolvers/accounting/xero/refresh-xero-access-token.ts

@@ -0,0 +1,67 @@
+import fetch from 'node-fetch'
+
+import { config } from '@things-factory/env'
+import { getRepository } from '@things-factory/shell'
+import { parseJwt } from '@things-factory/utils'
+
+import { Account } from '../../../../entities'
+
+const xeroConfig = config.get('accountingIntegrationXero', {})
+const { apiKey, apiSecret } = xeroConfig
+
+const debug = require('debug')('things-factory:integration-accounting:refresh-xero-access-token')
+
+export const refreshXeroAccessToken = {
+  async refreshXeroAccessToken(_: any, { id }, context: ResolverContext) {
+    const repository = getRepository(Account)
+    const account: any = await repository.findOne({
+      where: { domain: { id: context.state.domain.id }, id }
+    })
+
+    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)
+    }
+
+    return await repository.save({
+      ...account,
+      ...patch,
+      updater: context.state.user
+    })
+  }
+}

package/server/graphql/resolvers/accounting-api/accounting-invoice.ts

@@ -0,0 +1,36 @@
+import { AccountingAPI } from '../../../controllers/accounting-api'
+
+export const queryAccountingInvoice = {
+  async getAccountingInvoices(_: any, { accountingId, params: ListParam }, context: ResolverContext) {
+    var accounting = await AccountingAPI.getAccounting(accountingId)
+
+    return await AccountingAPI.getInvoices(accounting, {
+      pagination: {
+        page: 0,
+        limit: 100
+      }
+    })
+  },
+
+  async getAccountingInvoice(_: any, { accountingId, invoiceNo }, context: ResolverContext) {
+    var accounting = await AccountingAPI.getAccounting(accountingId)
+
+    return await AccountingAPI.getInvoice(accounting, {
+      invoiceNo
+    })
+  }
+}
+
+export const mutateAccountingInvoice = {
+  async createAccountingInvoice(_: any, { accountingId, newInvoice }, context: ResolverContext) {
+    var accounting = await AccountingAPI.getAccounting(accountingId)
+
+    return await AccountingAPI.createInvoice(accounting, newInvoice)
+  },
+
+  async updateAccountingInvoice(_: any, { accountingId, patch }, context: ResolverContext) {
+    var accounting = await AccountingAPI.getAccounting(accountingId)
+
+    return await AccountingAPI.updateInvoice(accounting, patch)
+  }
+}

package/server/graphql/resolvers/accounting-api/accounting-item.ts

@@ -0,0 +1,42 @@
+import { AccountingAPI } from '../../../controllers/accounting-api'
+
+export const queryAccountingItem = {
+  async getAccountingItems(_: any, { accountingId, params: ListParam }, context: ResolverContext) {
+    var accounting = await AccountingAPI.getAccounting(accountingId)
+
+    return await AccountingAPI.getItems(accounting, {
+      pagination: {
+        page: 0,
+        limit: 100
+      }
+    })
+  },
+
+  async getAccountingItem(_: any, { accountingId, itemId }, context: ResolverContext) {
+    var accounting = await AccountingAPI.getAccounting(accountingId)
+
+    return await AccountingAPI.getItem(accounting, {
+      itemId
+    })
+  }
+}
+
+export const mutateAccountingItem = {
+  async createAccountingItem(_: any, { accountingId, newItem }, context: ResolverContext) {
+    var accounting = await AccountingAPI.getAccounting(accountingId)
+
+    return await AccountingAPI.createItem(accounting, newItem)
+  },
+
+  async updateAccountingItem(_: any, { accountingId, patch }, context: ResolverContext) {
+    var accounting = await AccountingAPI.getAccounting(accountingId)
+
+    return await AccountingAPI.updateItem(accounting, patch)
+  },
+
+  async deleteAccountingItem(_: any, { accountingId, itemId }, context: ResolverContext) {
+    var accounting = await AccountingAPI.getAccounting(accountingId)
+
+    return await AccountingAPI.deleteItem(accounting, itemId)
+  }
+}

package/server/graphql/resolvers/accounting-api/accounting-purchase-order.ts

@@ -0,0 +1,14 @@
+import { AccountingAPI } from '../../../controllers/accounting-api'
+
+export const queryAccountingPurchaseOrder = {
+  async getAccountingPurchaseOrders(_: any, { accountingId, params: ListParam }, context: ResolverContext) {
+    var accounting = await AccountingAPI.getAccounting(accountingId)
+
+    return await AccountingAPI.getPurchaseOrders(accounting, {
+      pagination: {
+        page: 0,
+        limit: 100
+      }
+    })
+  }
+}

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

@@ -0,0 +1,14 @@
+import { queryAccountingInvoice, mutateAccountingInvoice } from './accounting-invoice'
+import { queryAccountingItem, mutateAccountingItem } from './accounting-item'
+import { queryAccountingPurchaseOrder } from './accounting-purchase-order'
+
+export const Query = {
+  ...queryAccountingInvoice,
+  ...queryAccountingItem,
+  ...queryAccountingPurchaseOrder
+}
+
+export const Mutation = {
+  ...mutateAccountingInvoice,
+  ...mutateAccountingItem
+}

package/server/graphql/resolvers/index.ts

@@ -0,0 +1,5 @@
+import * as Accounting from './accounting'
+
+export const queries = [Accounting.Query] as any
+
+export const mutations = [Accounting.Mutation]

package/server/graphql/types/accounting/account-list.ts

@@ -0,0 +1,8 @@
+import gql from 'graphql-tag'
+
+export const AccountList = gql`
+  type AccountList {
+    items: [Account]
+    total: Int
+  }
+`

package/server/graphql/types/accounting/account-patch.ts

@@ -0,0 +1,14 @@
+import gql from 'graphql-tag'
+
+export const AccountPatch = gql`
+  input AccountPatch {
+    id: String
+    name: String
+    description: String
+    platform: String
+    accountId: String
+    countryCode: String
+    trackedInventory: Boolean
+    cuFlag: String
+  }
+`

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

@@ -0,0 +1,25 @@
+import gql from 'graphql-tag'
+
+export const Account = gql`
+  type Account {
+    id: String
+    name: String
+    domain: Domain
+    description: String
+    platform: String
+    accountId: String
+    countryCode: String
+    status: String
+    accessInfo: String
+    accessToken: String
+    refreshToken: String
+    trackedInventory: Boolean
+    expiresIn: String
+    tokenType: String
+    accountInfo: String
+    updater: User
+    creator: User
+    updatedAt: String
+    createdAt: String
+  }
+`

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

@@ -0,0 +1,44 @@
+import { Account } from './account'
+import { NewAccount } from './new-account'
+import { AccountPatch } from './account-patch'
+import { AccountList } from './account-list'
+
+export const Mutation = `
+  createAccount (
+    account: NewAccount!
+  ): Account
+
+  updateAccount (
+    id: String!
+    patch: AccountPatch!
+  ): Account
+
+  updateMultipleAccount (
+    patches: [AccountPatch]!
+  ): [Account]
+
+  deleteAccount (
+    id: String!
+  ): Boolean
+
+  deleteAccounts (
+    ids: [String]!
+  ): Boolean
+
+  refreshXeroAccessToken (
+    id: String!
+  ): Account
+
+  deactivateXeroAccount (
+    id: String!
+  ): Account
+`
+
+export const Query = `
+  accounts(filters: [Filter], pagination: Pagination, sortings: [Sorting]): AccountList
+  account(id: String!): Account
+  
+  getXeroAuthURL(accounting: String!): String
+`
+
+export const Types = [Account, NewAccount, AccountPatch, AccountList]

package/server/graphql/types/accounting/new-account.ts

@@ -0,0 +1,12 @@
+import gql from 'graphql-tag'
+
+export const NewAccount = gql`
+  input NewAccount {
+    name: String!
+    description: String
+    platform: String!
+    accountId: String
+    trackedInventory: Boolean
+    countryCode: String
+  }
+`

package/server/graphql/types/accounting-api/invoice.ts

@@ -0,0 +1,65 @@
+import gql from 'graphql-tag'
+
+const NewAccountInvoice = gql`
+  input NewAccountInvoice {
+    name: String!
+    description: String
+  }
+`
+
+const AccountInvoiceList = gql`
+  type AccountInvoiceList {
+    items: [AccountInvoice]
+    total: Int
+  }
+`
+
+const AccountInvoicePatch = gql`
+  input AccountInvoicePatch {
+    id: String!
+    name: String
+    description: String
+    cuFlag: String
+  }
+`
+
+const AccountInvoice = gql`
+  type AccountInvoice {
+    id: String
+    name: String
+    domain: Domain
+    description: String
+    updater: User
+    creator: User
+    updatedAt: String
+    createdAt: String
+  }
+`
+
+export const Mutation = `
+  createAccountInvoice(
+    accountingId: String!
+    invoice: NewAccountInvoice!
+  ): AccountInvoice
+
+  updateAccountInvoice(
+    accountingId: String!
+    patch: AccountInvoicePatch!
+  ): AccountInvoice
+`
+
+export const Query = `
+  getAccountInvoices(
+    accountingId: String!
+    filters: [Filter]
+    pagination: Pagination
+    sortings: [Sorting]  
+  ): AccountInvoiceList
+  
+  getAccountInvoice(
+    accountingId: String!
+    invoiceNo: String!
+  ): AccountInvoice
+`
+
+export const Types = [AccountInvoice, NewAccountInvoice, AccountInvoicePatch, AccountInvoiceList]

package/server/graphql/types/accounting-api/item.ts

@@ -0,0 +1,64 @@
+import gql from 'graphql-tag'
+
+const NewAccountItem = gql`
+  input NewAccountItem {
+    name: String!
+    description: String
+  }
+`
+
+const AccountItemList = gql`
+  type AccountItemList {
+    items: [AccountItem]
+    total: Int
+  }
+`
+
+const AccountItemPatch = gql`
+  input AccountItemPatch {
+    id: String
+    name: String
+    description: String
+    cuFlag: String
+  }
+`
+
+const AccountItem = gql`
+  type AccountItem {
+    id: String
+    name: String
+    domain: Domain
+    description: String
+    updater: User
+    creator: User
+    updatedAt: String
+    createdAt: String
+  }
+`
+export const Mutation = `
+  createAccountItem(
+    accountingId: String!
+    item: NewAccountItem!
+  ): AccountItem
+
+  updateAccountItem(
+    accountingId: String!
+    patch: AccountItemPatch!
+  ): AccountItem
+`
+
+export const Query = `
+  getAccountItems(
+    accountingId: String!
+    filters: [Filter]
+    pagination: Pagination
+    sortings: [Sorting]  
+  ): AccountItemList
+  
+  getAccountItem(
+    accountingId: String!
+    itemId: String!
+  ): AccountItem
+`
+
+export const Types = [AccountItem, NewAccountItem, AccountItemPatch, AccountItemList]

package/server/graphql/types/accounting-api/purchase-order.ts

@@ -0,0 +1,30 @@
+import gql from 'graphql-tag'
+
+const AccountPurchaseOrderList = gql`
+  type AccountPurchaseOrderList {
+    items: [AccountPurchaseOrder]
+    total: Int
+  }
+`
+const AccountPurchaseOrder = gql`
+  type AccountPurchaseOrder {
+    id: String
+    name: String
+    domain: Domain
+    description: String
+    updater: User
+    creator: User
+    updatedAt: String
+    createdAt: String
+  }
+`
+export const Query = `
+  getAccountPurchaseOrders(
+    accountingId: String!
+    filters: [Filter]
+    pagination: Pagination
+    sortings: [Sorting]  
+  ): AccountPurchaseOrderList
+  
+`
+export const Types = [AccountPurchaseOrder, AccountPurchaseOrderList]

package/server/graphql/types/index.ts

@@ -0,0 +1,10 @@
+import * as Accounting from './accounting'
+import * as Invoice from './accounting-api/invoice'
+import * as Item from './accounting-api/item'
+import * as PurchaseOrder from './accounting-api/purchase-order'
+
+export const queries = [Accounting.Query, Invoice.Query, Item.Query, PurchaseOrder.Query]
+
+export const mutations = [Accounting.Mutation, Invoice.Mutation, Item.Mutation]
+
+export const types = [...Accounting.Types, ...Invoice.Types, ...Item.Types, ...PurchaseOrder.Types]

package/server/index.ts

@@ -0,0 +1,9 @@
+export * from './entities'
+export * from './migrations'
+export * from './graphql'
+export * from './controllers'
+
+import './routes'
+import './engine'
+
+process.on('bootstrap-module-start' as any, async ({ app, config, client }: any) => {})

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/routers/xero-private-router.ts

@@ -0,0 +1,24 @@
+import Router from 'koa-router'
+
+import { config } from '@things-factory/env'
+import { getRedirectSubdomainPath } from '@things-factory/shell'
+
+const isPathBaseDomain = !config.get('subdomain') && !config.get('useVirtualHostBasedDomain')
+
+const debug = require('debug')('things-factory:integration-accounting:xero-router')
+
+export const xeroPrivateRouter = new Router()
+
+xeroPrivateRouter.get(`${isPathBaseDomain ? '/domain/:domain' : ''}/callback-private-xero`, async (context, next) => {
+  const { domain } = context.state
+
+  const xeroAccountingCookies = context.cookies.get('xero-accounting')
+  const { id, status, message } = JSON.parse(xeroAccountingCookies)
+
+  context.redirect(
+    `${getRedirectSubdomainPath(
+      context,
+      domain.subdomain
+    )}account-xero/${id}/connect-callback?status=${status}&message=${message}`
+  )
+})