@things-factory/integration-accounting 8.0.0-beta.1 → 8.0.0-beta.4

package/server/routers/xero-router.ts

@@ -1,154 +0,0 @@
-import Router from 'koa-router'
-import fetch from 'node-fetch'
-
-import { User, VerificationToken, VerificationTokenType } from '@things-factory/auth-base'
-import { config } from '@things-factory/env'
-import { getRepository, getUrlFromContext } from '@things-factory/shell'
-import { parseJwt } from '@things-factory/utils'
-
-import { ACCOUNTING_STATUS, AccountingAPI } from '../controllers/accounting-api'
-import { Account } from '../entities'
-
-const { apiKey, apiSecret, hostname, callback: redirect_uri } = config.get('accountingIntegrationXero', {})
-
-const debug = require('debug')('things-factory:integration-accounting:xero-router')
-
-export const xeroRouter = new Router()
-
-xeroRouter.get('/callback-xero', async (context, next) => {
-  try {
-    const { code, state: nonce } = context.query
-
-    const verificationTokenRepository = getRepository(VerificationToken)
-
-    var verification: VerificationToken = await verificationTokenRepository.findOne({
-      where: {
-        token: nonce,
-        type: VerificationTokenType.REQUEST_ACCESS_TOKEN
-      }
-    })
-
-    const { userId, suppliment: accountId } = verification
-
-    await verificationTokenRepository.delete({
-      userId,
-      token: nonce,
-      type: VerificationTokenType.REQUEST_ACCESS_TOKEN
-    })
-
-    var account = await AccountingAPI.getAccounting(accountId)
-    const connectRequestData = {
-      grant_type: 'authorization_code',
-      code,
-      redirect_uri
-    }
-
-    const connectResponse = 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(connectRequestData)
-        .map(([key, value]) => encodeURIComponent(key) + '=' + encodeURIComponent(value))
-        .join('&')
-    })
-
-    if (!connectResponse.ok) {
-      throw new Error(`get account information failed: ${await connectResponse.text()}`)
-    }
-
-    const body = await connectResponse.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
-
-    /* decode access_token to get auth-event-id */
-    const accessInfo = parseJwt(access_token)
-    const { authentication_event_id, exp } = accessInfo
-
-    /* get connections through the authentication_event_id */
-    const connectionsResponse = await fetch(`https://api.xero.com/connections?authEventId=${authentication_event_id}`, {
-      method: 'get',
-      headers: {
-        Authorization: `Bearer ${access_token}`,
-        'Content-Type': 'application/json'
-      }
-    })
-
-    if (!connectionsResponse.ok) {
-      context.throw(connectionsResponse.status, `get connection list failed: ${await connectionsResponse.text()}`)
-    }
-
-    const connections = await connectionsResponse.json()
-    debug('connections', connections)
-
-    var connection = connections[0]
-    if (!connection) {
-      context.throw(400, 'connection not found for this access token')
-    }
-
-    var patch = {
-      name: connection.tenantName,
-      accessToken: access_token,
-      refreshToken: refresh_token,
-      accessInfo: JSON.stringify(accessInfo, null, 2),
-      accountInfo: JSON.stringify(connection, null, 2),
-      accountId: connection.tenantId,
-      status: ACCOUNTING_STATUS.ACTIVE,
-      tokenType,
-      expiresIn: new Date(exp * 1000)
-    }
-
-    var user = await getRepository(User).findOneBy({ id: userId })
-
-    account = await getRepository(Account).save({
-      ...account,
-      ...patch,
-      updater: user
-    })
-
-    context.cookies.set(
-      'xero-accounting',
-      JSON.stringify({
-        ...account,
-        message: 'success to activate'
-      }),
-      {
-        httpOnly: true
-      }
-    )
-
-    context.redirect(getUrlFromContext(context, '/callback-private-xero'))
-  } catch (err) {
-    var message: string = err.message
-
-    if (account) {
-      context.cookies.set(
-        'xero-accounting',
-        JSON.stringify({
-          ...account,
-          message
-        }),
-        {
-          httpOnly: true
-        }
-      )
-
-      context.redirect(getUrlFromContext(context, '/callback-private-xero'))
-      return
-    }
-
-    throw err
-  }
-})
-
-xeroRouter.post('/webhook-xero', async (context, next) => {
-  context.status = 200
-})

package/server/routes.ts

@@ -1,10 +0,0 @@
-import { xeroPrivateRouter } from './routers/xero-private-router'
-import { xeroRouter } from './routers/xero-router'
-
-process.on('bootstrap-module-global-public-route' as any, (app, globalPublicRouter) => {
-  globalPublicRouter.use(xeroRouter.routes(), xeroRouter.allowedMethods())
-})
-
-process.on('bootstrap-module-domain-private-route' as any, (app, domainPrivateRouter) => {
-  domainPrivateRouter.use(xeroPrivateRouter.routes(), xeroPrivateRouter.allowedMethods())
-})