chore: use monorepo organization

packages/server/lib/new-admin/services/bills.js

@@ -0,0 +1,31 @@
+const _ = require('lodash/fp')
+const pgp = require('pg-promise')()
+
+const db = require('../../db')
+
+const getBills = filters => {
+  const deviceStatement = !_.isNil(filters.deviceId) ? `WHERE device_id = ${pgp.as.text(filters.deviceId)}` : ``
+  const batchStatement = filter => {
+    switch (filter) {
+      case 'none':
+        return `WHERE b.cashbox_batch_id IS NULL`
+      case 'any':
+        return `WHERE b.cashbox_batch_id IS NOT NULL`
+      default:
+        return _.isNil(filter) ? `` : `WHERE b.cashbox_batch_id = ${pgp.as.text(filter)}`
+    }
+  }
+
+  const sql = `SELECT b.id, b.fiat, b.fiat_code, b.created, b.cashbox_batch_id, cit.device_id AS device_id FROM bills b LEFT OUTER JOIN (
+    SELECT id, device_id FROM cash_in_txs ${deviceStatement}
+  ) AS cit ON cit.id = b.cash_in_txs_id ${batchStatement(filters.batch)} ${_.isNil(batchStatement(filters.batch)) ? `WHERE` : `AND`} b.destination_unit = 'cashbox'`
+
+  const sql2 = `SELECT b.id, b.fiat, b.fiat_code, b.created, b.cashbox_batch_id, b.device_id FROM empty_unit_bills b ${deviceStatement} ${!_.isNil(filters.deviceId) && !_.isNil(filters.batch) ? `AND ${_.replace('WHERE', '', batchStatement(filters.batch))}` : `${batchStatement(filters.batch)}`}`
+
+  return Promise.all([db.any(sql), db.any(sql2)])
+    .then(([bills, operationalBills]) => _.map(_.mapKeys(_.camelCase), _.concat(bills, operationalBills)))
+}
+
+module.exports = {
+  getBills
+}

packages/server/lib/new-admin/services/customInfoRequests.js

@@ -0,0 +1,142 @@
+const db = require('../../db')
+const uuid = require('uuid')
+const _ = require('lodash/fp')
+const pgp = require('pg-promise')()
+const { loadLatestConfigOrNone, saveConfig } = require('../../../lib/new-settings-loader')
+
+const getCustomInfoRequests = (onlyEnabled = false) => {
+  const sql = onlyEnabled
+    ? `SELECT * FROM custom_info_requests WHERE enabled = true ORDER BY custom_request->>'name'`
+    : `SELECT * FROM custom_info_requests ORDER BY custom_request->>'name'`
+  return db.any(sql).then(res => {
+    return res.map(item => ({
+      id: item.id,
+      enabled: item.enabled,
+      customRequest: item.custom_request
+    }))
+  })
+}
+
+const addCustomInfoRequest = (customRequest) => {
+  const sql = 'INSERT INTO custom_info_requests (id, custom_request) VALUES ($1, $2)'
+  const id = uuid.v4()
+  return db.none(sql, [id, customRequest]).then(() => ({ id }))
+}
+
+const removeCustomInfoRequest = (id) => {
+  return loadLatestConfigOrNone()
+    .then(cfg => saveConfig({triggers: _.remove(x => x.customInfoRequestId === id, cfg.triggers ?? [])}))
+    .then(() => db.none('UPDATE custom_info_requests SET enabled = false WHERE id = $1', [id]))
+    .then(() => ({ id }));
+}
+
+const editCustomInfoRequest = (id, customRequest) => {
+  return db.none('UPDATE custom_info_requests SET custom_request = $1 WHERE id=$2', [customRequest, id]).then(() => ({ id, customRequest }))
+}
+
+const getAllCustomInfoRequestsForCustomer = (customerId) => {
+  const sql = `SELECT * FROM customers_custom_info_requests WHERE customer_id = $1`
+  return db.any(sql, [customerId]).then(res => res.map(item => ({
+    customerId: item.customer_id,
+    infoRequestId: item.info_request_id,
+    customerData: item.customer_data,
+    override: item.override,
+    overrideAt: item.override_at,
+    overrideBy: item.override_by
+  })))
+}
+
+const getCustomInfoRequestForCustomer = (customerId, infoRequestId) => {
+  const sql = `SELECT * FROM customers_custom_info_requests WHERE customer_id = $1 AND info_request_id = $2`
+  return db.one(sql, [customerId, infoRequestId]).then(item => {
+    return {
+      customerId: item.customer_id,
+      infoRequestId: item.info_request_id,
+      customerData: item.customer_data,
+      override: item.override,
+      overrideAt: item.override_at,
+      overrideBy: item.override_by
+    }
+  })
+}
+
+const batchGetAllCustomInfoRequestsForCustomer = (customerIds) => {
+  const sql = `SELECT * FROM customers_custom_info_requests WHERE customer_id IN ($1^)`
+  return db.any(sql, [_.map(pgp.as.text, customerIds).join(',')]).then(res => {
+    const map = _.groupBy('customer_id', res)
+    return customerIds.map(id => {
+      const items = map[id] || []
+      return items.map(item => ({
+        customerId: item.customer_id,
+        infoRequestId: item.info_request_id,
+        customerData: item.customer_data,
+        override: item.override,
+        overrideAt: item.override_at,
+        overrideBy: item.override_by
+      }))
+    })
+  })
+}
+
+const getCustomInfoRequest = (infoRequestId) => {
+  const sql = `SELECT * FROM custom_info_requests WHERE id = $1`
+  return db.one(sql, [infoRequestId]).then(item => ({
+    id: item.id,
+    enabled: item.enabled,
+    customRequest: item.custom_request
+  }))
+}
+
+const batchGetCustomInfoRequest = (infoRequestIds) => {
+  if (infoRequestIds.length === 0) return Promise.resolve([])
+  const sql = `SELECT * FROM custom_info_requests WHERE id IN ($1^)`
+  return db.any(sql, [_.map(pgp.as.text, infoRequestIds).join(',')]).then(res => {
+    const map = _.groupBy('id', res)
+    return infoRequestIds.map(id => {
+      const item = map[id][0] // since id is primary key the array always has 1 element
+      return {
+        id: item.id,
+        enabled: item.enabled,
+        customRequest: item.custom_request
+      }
+    })
+  })
+}
+
+const setAuthorizedCustomRequest = (customerId, infoRequestId, override, token) => {
+  const sql = `UPDATE customers_custom_info_requests SET override = $1, override_by = $2, override_at = now() WHERE customer_id = $3 AND info_request_id = $4`
+  return db.none(sql, [override, token, customerId, infoRequestId]).then(() => true)
+}
+
+const setCustomerData = (customerId, infoRequestId, data) => {
+  const sql = `
+  INSERT INTO customers_custom_info_requests (customer_id, info_request_id, customer_data)
+    VALUES ($1, $2, $3)
+      ON CONFLICT (customer_id, info_request_id)
+      DO UPDATE SET customer_data = $3`
+  return db.none(sql, [customerId, infoRequestId, data])
+}
+
+const setCustomerDataViaMachine = (customerId, infoRequestId, data) => {
+  const sql = `
+  INSERT INTO customers_custom_info_requests (customer_id, info_request_id, customer_data)
+    VALUES ($1, $2, $3)
+      ON CONFLICT (customer_id, info_request_id)
+      DO UPDATE SET customer_data = $3, override = $4, override_by = $5, override_at = now()`
+  return db.none(sql, [customerId, infoRequestId, data, 'automatic', null])
+}
+
+module.exports = {
+  getCustomInfoRequests,
+  addCustomInfoRequest,
+  removeCustomInfoRequest,
+  editCustomInfoRequest,
+  getAllCustomInfoRequestsForCustomer,
+  getCustomInfoRequestForCustomer,
+  batchGetAllCustomInfoRequestsForCustomer,
+  getCustomInfoRequest,
+  batchGetCustomInfoRequest,
+  setAuthorizedCustomRequest,
+  setCustomerData,
+  setCustomerDataViaMachine
+}

packages/server/lib/new-admin/services/funding.js

@@ -0,0 +1,75 @@
+const _ = require('lodash/fp')
+const BN = require('../../bn')
+const settingsLoader = require('../../new-settings-loader')
+const configManager = require('../../new-config-manager')
+const wallet = require('../../wallet')
+const ticker = require('../../ticker')
+const txBatching = require('../../tx-batching')
+const { utils: coinUtils } = require('@lamassu/coins')
+
+function computeCrypto (cryptoCode, _balance) {
+  const cryptoRec = coinUtils.getCryptoCurrency(cryptoCode)
+  const unitScale = cryptoRec.unitScale
+
+  return new BN(_balance).shiftedBy(-unitScale).decimalPlaces(5)
+}
+
+function computeFiat (rate, cryptoCode, _balance) {
+  const cryptoRec = coinUtils.getCryptoCurrency(cryptoCode)
+  const unitScale = cryptoRec.unitScale
+
+  return new BN(_balance).shiftedBy(-unitScale).times(rate).decimalPlaces(5)
+}
+
+function getSingleCoinFunding (settings, fiatCode, cryptoCode) {
+  const promises = [
+    wallet.newFunding(settings, cryptoCode),
+    ticker.getRates(settings, fiatCode, cryptoCode),
+    txBatching.getOpenBatchCryptoValue(cryptoCode)
+  ]
+
+  return Promise.all(promises)
+    .then(([fundingRec, ratesRec, batchRec]) => {
+      const rates = ratesRec.rates
+      const rate = (rates.ask.plus(rates.bid)).div(2)
+      const fundingConfirmedBalance = fundingRec.fundingConfirmedBalance
+      const fiatConfirmedBalance = computeFiat(rate, cryptoCode, fundingConfirmedBalance)
+      const pending = fundingRec.fundingPendingBalance.minus(batchRec)
+      const fiatPending = computeFiat(rate, cryptoCode, pending)
+      const fundingAddress = fundingRec.fundingAddress
+      const fundingAddressUrl = coinUtils.buildUrl(cryptoCode, fundingAddress)
+
+      return {
+        cryptoCode,
+        fundingAddress,
+        fundingAddressUrl,
+        confirmedBalance: computeCrypto(cryptoCode, fundingConfirmedBalance).toFormat(5),
+        pending: computeCrypto(cryptoCode, pending).toFormat(5),
+        fiatConfirmedBalance: fiatConfirmedBalance,
+        fiatPending: fiatPending,
+        fiatCode
+      }
+    })
+}
+
+// Promise.allSettled not running on current version of node
+const reflect = p => p.then(value => ({ value, status: 'fulfilled' }), error => ({ error: error.toString(), status: 'rejected' }))
+
+function getFunding () {
+  return settingsLoader.loadLatest().then(settings => {
+    const cryptoCodes = configManager.getAllCryptoCurrencies(settings.config)
+    const fiatCode = configManager.getGlobalLocale(settings.config).fiatCurrency
+    const pareCoins = c => _.includes(c.cryptoCode, cryptoCodes)
+    const cryptoCurrencies = coinUtils.cryptoCurrencies()
+    const cryptoDisplays = _.filter(pareCoins, cryptoCurrencies)
+
+    const promises = cryptoDisplays.map(it => getSingleCoinFunding(settings, fiatCode, it.cryptoCode))
+    return Promise.all(promises.map(reflect))
+      .then((response) => {
+        const mapped = response.map(it => _.merge({ errorMsg: it.error }, it.value))
+        return _.toArray(_.merge(mapped, cryptoDisplays))
+      })
+  })
+}
+
+module.exports = { getFunding }

packages/server/lib/new-admin/services/login.js

@@ -0,0 +1,16 @@
+const db = require('../../db')
+
+function validateUser (username, password) {
+  return db.tx(t => {
+    const q1 = t.one('SELECT * FROM users WHERE username=$1 AND password=$2', [username, password])
+    const q2 = t.none('UPDATE users SET last_accessed = now() WHERE username=$1', [username])
+
+    return t.batch([q1, q2])
+      .then(([user]) => user)
+      .catch(() => false)
+  })
+}
+
+module.exports = {
+  validateUser
+}

packages/server/lib/new-admin/services/machines.js

@@ -0,0 +1,20 @@
+const machineLoader = require('../../machine-loader')
+const { UserInputError } = require('../graphql/errors')
+
+function getMachine (machineId) {
+  return machineLoader.getMachines()
+    .then(machines => machines.find(({ deviceId }) => deviceId === machineId))
+}
+
+function machineAction ({ deviceId, action, cashUnits, newName }, context) {
+  const operatorId = context.res.locals.operatorId
+  return getMachine(deviceId)
+    .then(machine => {
+      if (!machine) throw new UserInputError(`machine:${deviceId} not found`, { deviceId })
+      return machine
+    })
+    .then(machineLoader.setMachine({ deviceId, action, cashUnits, newName }, operatorId))
+    .then(getMachine(deviceId))
+}
+
+module.exports = { machineAction }

packages/server/lib/new-admin/services/pairing.js

@@ -0,0 +1,34 @@
+const fs = require('fs')
+const pify = require('pify')
+const readFile = pify(fs.readFile)
+const crypto = require('crypto')
+const baseX = require('base-x')
+const { parse, NIL } = require('uuid')
+
+const db = require('../../db')
+const pairing = require('../../pairing')
+
+const ALPHA_BASE = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:'
+const bsAlpha = baseX(ALPHA_BASE)
+
+const CA_PATH = process.env.CA_PATH
+const HOSTNAME = process.env.HOSTNAME
+
+const unpair = pairing.unpair
+
+function totem (name) {
+  return readFile(CA_PATH)
+    .then(data => {
+      const caHash = crypto.createHash('sha256').update(data).digest()
+      const token = crypto.randomBytes(32)
+      const hexToken = token.toString('hex')
+      const caHexToken = crypto.createHash('sha256').update(hexToken).digest('hex')
+      const buf = Buffer.concat([caHash, token, Buffer.from(HOSTNAME)])
+      const sql = 'insert into pairing_tokens (token, name) values ($1, $3), ($2, $3)'
+
+      return db.none(sql, [hexToken, caHexToken, name])
+        .then(() => bsAlpha.encode(buf))
+    })
+}
+
+module.exports = { totem, unpair }

packages/server/lib/new-admin/services/server-logs.js

@@ -0,0 +1,17 @@
+const _ = require('lodash/fp')
+const uuid = require('uuid')
+
+const db = require('../../db')
+
+function getServerLogs (from = new Date(0).toISOString(), until = new Date().toISOString(), limit = null, offset = 0) {
+  const sql = `select id, log_level, timestamp, message from server_logs
+  where timestamp >= $1 and timestamp <= $2
+  order by timestamp desc
+  limit $3
+  offset $4`
+
+  return db.any(sql, [ from, until, limit, offset ])
+    .then(_.map(_.mapKeys(_.camelCase)))
+}
+
+module.exports = { getServerLogs }

packages/server/lib/new-admin/services/supervisor.js

@@ -0,0 +1,62 @@
+const xmlrpc = require('xmlrpc')
+const logger = require('../../logger')
+const { promisify } = require('util')
+
+// TODO new-admin: add the following to supervisor config
+// [inet_http_server]
+// port = 127.0.0.1:9001
+
+function getAllProcessInfo () {
+  const convertStates = (state) => {
+    // From http://supervisord.org/subprocess.html#process-states
+    switch (state) {
+      case 'STOPPED':
+        return 'STOPPED'
+      case 'STARTING':
+        return 'RUNNING'
+      case 'RUNNING':
+        return 'RUNNING'
+      case 'BACKOFF':
+        return 'FATAL'
+      case 'STOPPING':
+        return 'STOPPED'
+      case 'EXITED':
+        return 'STOPPED'
+      case 'UNKNOWN':
+        return 'FATAL'
+      default:
+        logger.error(`Supervisord returned an unsupported state: ${state}`)
+        return 'FATAL'
+    }
+  }
+
+  const client = xmlrpc.createClient({
+    host: 'localhost',
+    port: '9001',
+    path: '/RPC2'
+  })
+
+  client.methodCall[promisify.custom] = (method, params) => {
+    return new Promise((resolve, reject) => client.methodCall(method, params, (err, value) => {
+      if (err) reject(err)
+      else resolve(value)
+    }))
+  }
+
+  return promisify(client.methodCall)('supervisor.getAllProcessInfo', [])
+    .then((value) => {
+      return value.map(process => (
+        {
+          name: process.name,
+          state: convertStates(process.statename),
+          uptime: (process.statename === 'RUNNING') ? process.now - process.start : 0
+        }
+      ))
+    })
+    .catch((error) => {
+      if (error.code === 'ECONNREFUSED') logger.error('Failed to connect to supervisord HTTP server.')
+      else logger.error(error)
+    })
+}
+
+module.exports = { getAllProcessInfo }

packages/server/lib/new-admin/services/transactions.js

@@ -0,0 +1,403 @@
+const _ = require('lodash/fp')
+const pgp = require('pg-promise')()
+
+const db = require('../../db')
+const BN = require('../../bn')
+const { utils: coinUtils } = require('@lamassu/coins')
+const machineLoader = require('../../machine-loader')
+const tx = require('../../tx')
+const cashInTx = require('../../cash-in/cash-in-tx')
+const { REDEEMABLE_AGE, CASH_OUT_TRANSACTION_STATES } = require('../../cash-out/cash-out-helper')
+
+const NUM_RESULTS = 1000
+
+function addProfits (txs) {
+  return _.map(it => {
+    const profit = getProfit(it).toString()
+    return _.set('profit', profit, it)
+  }, txs)
+}
+
+const camelize = _.mapKeys(_.camelCase)
+
+const DEVICE_NAME_QUERY = `
+  CASE 
+    WHEN ud.name IS NOT NULL THEN ud.name || ' (unpaired)'
+    WHEN d.name IS NOT NULL THEN d.name
+    ELSE 'Unpaired'
+  END AS machine_name
+`
+
+  const DEVICE_NAME_JOINS = `
+  LEFT JOIN devices d ON txs.device_id = d.device_id
+  LEFT JOIN (
+    SELECT device_id, name, unpaired, paired 
+    FROM unpaired_devices
+  ) ud ON txs.device_id = ud.device_id 
+    AND ud.unpaired >= txs.created
+    AND (txs.created >= ud.paired)
+  `
+
+function batch (
+  from = new Date(0).toISOString(),
+  until = new Date().toISOString(),
+  limit = null,
+  offset = 0,
+  txClass = null,
+  deviceId = null,
+  customerName = null,
+  fiatCode = null,
+  cryptoCode = null,
+  toAddress = null,
+  status = null,
+  swept = null,
+  excludeTestingCustomers = false,
+  simplified
+) {
+  const isCsvExport = _.isBoolean(simplified)
+  const packager = _.flow(
+    _.flatten,
+    _.orderBy(_.property('created'), ['desc']),
+    _.map(_.flow(
+      camelize,
+      _.mapKeys(k =>
+        k == 'cashInFee' ? 'fixedFee' :
+        k
+      )
+    )),
+    addProfits
+  )
+
+  const cashInSql = `SELECT 'cashIn' AS tx_class, txs.*,
+  c.phone AS customer_phone,
+  c.email AS customer_email,
+  c.id_card_data_number AS customer_id_card_data_number,
+  c.id_card_data_expiration AS customer_id_card_data_expiration,
+  c.id_card_data AS customer_id_card_data,
+  array_to_string(array[c.id_card_data::json->>'firstName', c.id_card_data::json->>'lastName'], ' ') AS customer_name,
+  c.front_camera_path AS customer_front_camera_path,
+  c.id_card_photo_path AS customer_id_card_photo_path,
+  txs.tx_customer_photo_at AS tx_customer_photo_at,
+  txs.tx_customer_photo_path AS tx_customer_photo_path,
+  ((NOT txs.send_confirmed) AND (txs.created <= now() - interval $1)) AS expired,
+  tb.error_message AS batch_error,
+  ${DEVICE_NAME_QUERY}
+  FROM (SELECT *, ${cashInTx.TRANSACTION_STATES} AS txStatus FROM cash_in_txs) AS txs
+  LEFT OUTER JOIN customers c ON txs.customer_id = c.id
+  ${DEVICE_NAME_JOINS}
+  LEFT OUTER JOIN transaction_batches tb ON txs.batch_id = tb.id
+  WHERE txs.created >= $2 AND txs.created <= $3
+  AND ($6 is null or $6 = 'Cash In')
+  AND ($7 is null or txs.device_id = $7)
+  AND ($8 is null or concat(c.id_card_data::json->>'firstName', ' ', c.id_card_data::json->>'lastName') = $8)
+  AND ($9 is null or txs.fiat_code = $9)
+  AND ($10 is null or txs.crypto_code = $10)
+  AND ($11 is null or txs.to_address = $11)
+  AND ($12 is null or txs.txStatus = $12)
+  ${excludeTestingCustomers ? `AND c.is_test_customer is false` : ``}
+  ${isCsvExport && !simplified ? '' : 'AND (error IS NOT null OR tb.error_message IS NOT null OR fiat > 0)'}
+  ORDER BY created DESC limit $4 offset $5`
+
+  const cashOutSql = `SELECT 'cashOut' AS tx_class,
+  txs.*,
+  actions.tx_hash,
+  c.phone AS customer_phone,
+  c.email AS customer_email,
+  c.id_card_data_number AS customer_id_card_data_number,
+  c.id_card_data_expiration AS customer_id_card_data_expiration,
+  c.id_card_data AS customer_id_card_data,
+  array_to_string(array[c.id_card_data::json->>'firstName', c.id_card_data::json->>'lastName'], ' ') AS customer_name,
+  c.front_camera_path AS customer_front_camera_path,
+  c.id_card_photo_path AS customer_id_card_photo_path,
+  txs.tx_customer_photo_at AS tx_customer_photo_at,
+  txs.tx_customer_photo_path AS tx_customer_photo_path,
+  (NOT txs.dispense AND extract(epoch FROM (now() - greatest(txs.created, txs.confirmed_at))) >= $1) AS expired,
+  ${DEVICE_NAME_QUERY}
+  FROM (SELECT *, ${CASH_OUT_TRANSACTION_STATES} AS txStatus FROM cash_out_txs) txs
+  INNER JOIN cash_out_actions actions ON txs.id = actions.tx_id
+  AND actions.action = 'provisionAddress'
+  LEFT OUTER JOIN customers c ON txs.customer_id = c.id
+  ${DEVICE_NAME_JOINS}
+  WHERE txs.created >= $2 AND txs.created <= $3 
+  AND ($6 is null or $6 = 'Cash Out')
+  AND ($7 is null or txs.device_id = $7)
+  AND ($8 is null or concat(c.id_card_data::json->>'firstName', ' ', c.id_card_data::json->>'lastName') = $8)
+  AND ($9 is null or txs.fiat_code = $9)
+  AND ($10 is null or txs.crypto_code = $10)
+  AND ($11 is null or txs.to_address = $11)
+  AND ($12 is null or txs.txStatus = $12)
+  AND ($13 is null or txs.swept = $13)
+  ${excludeTestingCustomers ? `AND c.is_test_customer is false` : ``}
+  ${isCsvExport ? '' : 'AND fiat > 0'}
+  ORDER BY created DESC limit $4 offset $5`
+
+  // The swept filter is cash-out only, so omit the cash-in query entirely
+  const hasCashInOnlyFilters = false
+  const hasCashOutOnlyFilters = !_.isNil(swept)
+
+  let promises
+
+  if (hasCashInOnlyFilters && hasCashOutOnlyFilters) {
+    throw new Error('Trying to filter transactions with mutually exclusive filters')
+  }
+
+  if (hasCashInOnlyFilters) {
+    promises = [db.any(cashInSql, [cashInTx.PENDING_INTERVAL, from, until, limit, offset, txClass, deviceId, customerName, fiatCode, cryptoCode, toAddress, status])]
+  } else if (hasCashOutOnlyFilters) {
+    promises = [db.any(cashOutSql, [REDEEMABLE_AGE, from, until, limit, offset, txClass, deviceId, customerName, fiatCode, cryptoCode, toAddress, status, swept])]
+  } else {
+    promises = [
+      db.any(cashInSql, [cashInTx.PENDING_INTERVAL, from, until, limit, offset, txClass, deviceId, customerName, fiatCode, cryptoCode, toAddress, status]),
+      db.any(cashOutSql, [REDEEMABLE_AGE, from, until, limit, offset, txClass, deviceId, customerName, fiatCode, cryptoCode, toAddress, status, swept])
+    ]
+  }
+
+  return Promise.all(promises)
+    .then(packager)
+    .then(res =>
+      !isCsvExport ? res :
+      // GQL transactions and transactionsCsv both use this function and
+      // if we don't check for the correct simplified value, the Transactions page polling
+      // will continuously build a csv in the background
+      simplified ? simplifiedBatch(res) :
+      advancedBatch(res)
+    )
+}
+
+function advancedBatch (data) {
+  const fields = ['txClass', 'id', 'deviceId', 'toAddress', 'cryptoAtoms',
+  'cryptoCode', 'fiat', 'fiatCode', 'fee', 'status', 'fiatProfit', 'cryptoAmount',
+  'dispense', 'notified', 'redeem', 'phone', 'error', 'fixedFee',
+  'created', 'confirmedAt', 'hdIndex', 'swept', 'timedout',
+  'dispenseConfirmed', 'provisioned1', 'provisioned2', 'provisioned3', 'provisioned4',
+  'provisionedRecycler1', 'provisionedRecycler2', 'provisionedRecycler3', 'provisionedRecycler4', 'provisionedRecycler5', 'provisionedRecycler6',
+  'denomination1', 'denomination2', 'denomination3', 'denomination4',
+  'denominationRecycler1', 'denominationRecycler2', 'denominationRecycler3', 'denominationRecycler4', 'denominationRecycler5', 'denominationRecycler6',
+  'errorCode', 'customerId', 'txVersion', 'publishedAt', 'termsAccepted', 'layer2Address',
+  'commissionPercentage', 'rawTickerPrice', 'receivedCryptoAtoms',
+  'discount', 'txHash', 'customerPhone', 'customerEmail', 'customerIdCardDataNumber',
+  'customerIdCardDataExpiration', 'customerIdCardData', 'customerName', 'sendTime',
+  'customerFrontCameraPath', 'customerIdCardPhotoPath', 'expired', 'machineName', 'walletScore']
+
+  const addAdvancedFields = _.map(it => ({
+    ...it,
+    status: getStatus(it),
+    fiatProfit: getProfit(it).toString(),
+    cryptoAmount: getCryptoAmount(it).toString(),
+    fixedFee: it.fixedFee ?? null,
+    fee: it.fee ?? null,
+  }))
+
+  return _.compose(_.map(_.pick(fields)), addAdvancedFields)(data)
+}
+
+function simplifiedBatch (data) {
+  const fields = ['txClass', 'id', 'created', 'machineName', 'fee',
+    'cryptoCode', 'cryptoAtoms', 'fiat', 'fiatCode', 'phone', 'email', 'toAddress',
+    'txHash', 'dispense', 'error', 'status', 'fiatProfit', 'cryptoAmount']
+
+  const addSimplifiedFields = _.map(it => ({
+    ...it,
+    status: getStatus(it),
+    fiatProfit: getProfit(it).toString(),
+    cryptoAmount: getCryptoAmount(it).toString()
+  }))
+
+  return _.compose(_.map(_.pick(fields)), addSimplifiedFields)(data)
+}
+
+const getCryptoAmount = it => coinUtils.toUnit(BN(it.cryptoAtoms), it.cryptoCode)
+
+const getProfit = it => {
+  /* fiat - crypto*tickerPrice */
+  const calcCashInProfit = (fiat, crypto, tickerPrice) => fiat.minus(crypto.times(tickerPrice))
+  /* crypto*tickerPrice - fiat */
+  const calcCashOutProfit = (fiat, crypto, tickerPrice) => crypto.times(tickerPrice).minus(fiat)
+
+  const fiat = BN(it.fiat)
+  const crypto = getCryptoAmount(it)
+  const tickerPrice = BN(it.rawTickerPrice)
+  const isCashIn = it.txClass === 'cashIn'
+
+  return isCashIn
+    ? calcCashInProfit(fiat, crypto, tickerPrice)
+    : calcCashOutProfit(fiat, crypto, tickerPrice)
+}
+
+const getCashOutStatus = it => {
+  if (it.hasError) return 'Error'
+  if (it.dispense) return 'Success'
+  if (it.expired) return 'Expired'
+  return 'Pending'
+}
+
+const getCashInStatus = it => {
+  if (it.operatorCompleted) return 'Cancelled'
+  if (it.hasError) return 'Error'
+  if (it.batchError) return 'Error'
+  if (it.sendConfirmed) return 'Sent'
+  if (it.expired) return 'Expired'
+  return 'Pending'
+}
+
+const getStatus = it => {
+  if (it.txClass === 'cashOut') {
+    return getCashOutStatus(it)
+  }
+  return getCashInStatus(it)
+}
+
+function getCustomerTransactionsBatch (ids) {
+  const packager = _.flow(it => {
+    return it
+  }, _.flatten, _.orderBy(_.property('created'), ['desc']), _.map(camelize))
+
+  const cashInSql = `SELECT 'cashIn' AS tx_class, txs.*,
+  c.phone AS customer_phone,
+  c.email AS customer_email,
+  c.id_card_data_number AS customer_id_card_data_number,
+  c.id_card_data_expiration AS customer_id_card_data_expiration,
+  c.id_card_data AS customer_id_card_data,
+  c.name AS customer_name,
+  c.front_camera_path AS customer_front_camera_path,
+  c.id_card_photo_path AS customer_id_card_photo_path,
+  ((NOT txs.send_confirmed) AND (txs.created <= now() - interval $2)) AS expired,
+  tb.error_message AS batch_error,
+  ${DEVICE_NAME_QUERY}
+  FROM cash_in_txs AS txs
+  LEFT OUTER JOIN customers c ON txs.customer_id = c.id
+  ${DEVICE_NAME_JOINS}
+  LEFT OUTER JOIN transaction_batches tb ON txs.batch_id = tb.id
+  WHERE c.id IN ($1^)
+  ORDER BY created DESC limit $3`
+
+  const cashOutSql = `SELECT 'cashOut' AS tx_class,
+  txs.*,
+  actions.tx_hash,
+  c.phone AS customer_phone,
+  c.email AS customer_email,
+  c.id_card_data_number AS customer_id_card_data_number,
+  c.id_card_data_expiration AS customer_id_card_data_expiration,
+  c.id_card_data AS customer_id_card_data,
+  c.name AS customer_name,
+  c.front_camera_path AS customer_front_camera_path,
+  c.id_card_photo_path AS customer_id_card_photo_path,
+  (NOT txs.dispense AND extract(epoch FROM (now() - greatest(txs.created, txs.confirmed_at))) >= $3) AS expired,
+  ${DEVICE_NAME_QUERY}
+  FROM cash_out_txs txs
+  INNER JOIN cash_out_actions actions ON txs.id = actions.tx_id
+  AND actions.action = 'provisionAddress'
+  LEFT OUTER JOIN customers c ON txs.customer_id = c.id
+  ${DEVICE_NAME_JOINS}
+  WHERE c.id IN ($1^)
+  ORDER BY created DESC limit $2`
+  return Promise.all([
+    db.any(cashInSql, [_.map(pgp.as.text, ids).join(','), cashInTx.PENDING_INTERVAL, NUM_RESULTS]),
+    db.any(cashOutSql, [_.map(pgp.as.text, ids).join(','), NUM_RESULTS, REDEEMABLE_AGE])
+  ])
+    .then(packager).then(transactions => {
+      const transactionMap = _.groupBy('customerId', transactions)
+      return ids.map(id => transactionMap[id])
+    })
+}
+
+function single (txId) {
+  const packager = _.flow(_.compact, _.map(camelize))
+
+  const cashInSql = `SELECT 'cashIn' AS tx_class, txs.*,
+  c.phone AS customer_phone,
+  c.email AS customer_email,
+  c.id_card_data_number AS customer_id_card_data_number,
+  c.id_card_data_expiration AS customer_id_card_data_expiration,
+  c.id_card_data AS customer_id_card_data,
+  c.name AS customer_name,
+  c.front_camera_path AS customer_front_camera_path,
+  c.id_card_photo_path AS customer_id_card_photo_path,
+  ((NOT txs.send_confirmed) AND (txs.created <= now() - interval $1)) AS expired,
+  tb.error_message AS batch_error,
+  ${DEVICE_NAME_QUERY}
+  FROM cash_in_txs AS txs
+  LEFT OUTER JOIN customers c ON txs.customer_id = c.id
+  ${DEVICE_NAME_JOINS}
+  LEFT OUTER JOIN transaction_batches tb ON txs.batch_id = tb.id
+  WHERE id=$2`
+
+  const cashOutSql = `SELECT 'cashOut' AS tx_class,
+  txs.*,
+  actions.tx_hash,
+  c.phone AS customer_phone,
+  c.email AS customer_email,
+  c.id_card_data_number AS customer_id_card_data_number,
+  c.id_card_data_expiration AS customer_id_card_data_expiration,
+  c.id_card_data AS customer_id_card_data,
+  c.name AS customer_name,
+  c.front_camera_path AS customer_front_camera_path,
+  c.id_card_photo_path AS customer_id_card_photo_path,
+  (NOT txs.dispense AND extract(epoch FROM (now() - greatest(txs.created, txs.confirmed_at))) >= $2) AS expired,
+  ${DEVICE_NAME_QUERY}
+  FROM cash_out_txs txs
+  INNER JOIN cash_out_actions actions ON txs.id = actions.tx_id
+  AND actions.action = 'provisionAddress'
+  LEFT OUTER JOIN customers c ON txs.customer_id = c.id
+  ${DEVICE_NAME_JOINS}
+  WHERE id=$1`
+
+  return Promise.all([
+    db.oneOrNone(cashInSql, [cashInTx.PENDING_INTERVAL, txId]),
+    db.oneOrNone(cashOutSql, [txId, REDEEMABLE_AGE])
+  ])
+    .then(packager)
+    .then(_.head)
+}
+
+function cancel (txId) {
+  return tx.cancel(txId)
+    .then(() => single(txId))
+}
+
+function getTx (txId, txClass) {
+  const cashInSql = `select 'cashIn' as tx_class, txs.*,
+  ((not txs.send_confirmed) and (txs.created <= now() - interval $1)) as expired
+  from cash_in_txs as txs
+  where txs.id=$2`
+
+  const cashOutSql = `select 'cashOut' as tx_class,
+  txs.*,
+  (extract(epoch from (now() - greatest(txs.created, txs.confirmed_at))) * 1000) >= $2 as expired
+  from cash_out_txs txs
+  where txs.id=$1`
+
+  return txClass === 'cashIn'
+    ? db.oneOrNone(cashInSql, [cashInTx.PENDING_INTERVAL, txId])
+    : db.oneOrNone(cashOutSql, [txId, REDEEMABLE_AGE])
+}
+
+function getTxAssociatedData (txId, txClass) {
+  const billsSql = `select 'bills' as bills, b.* from bills b where cash_in_txs_id = $1`
+  const actionsSql = `select 'cash_out_actions' as cash_out_actions, actions.* from cash_out_actions actions where tx_id = $1`
+
+  return txClass === 'cashIn'
+    ? db.manyOrNone(billsSql, [txId])
+    : db.manyOrNone(actionsSql, [txId])
+}
+
+function updateTxCustomerPhoto (customerId, txId, direction, data) {
+  const formattedData = _.mapKeys(_.snakeCase, data)
+  const cashInSql = 'UPDATE cash_in_txs SET tx_customer_photo_at = $1, tx_customer_photo_path = $2 WHERE customer_id=$3 AND id=$4'
+
+  const cashOutSql = 'UPDATE cash_out_txs SET tx_customer_photo_at = $1, tx_customer_photo_path = $2 WHERE customer_id=$3 AND id=$4'
+
+  return direction === 'cashIn'
+    ? db.oneOrNone(cashInSql, [formattedData.tx_customer_photo_at, formattedData.tx_customer_photo_path, customerId, txId])
+    : db.oneOrNone(cashOutSql, [formattedData.tx_customer_photo_at, formattedData.tx_customer_photo_path, customerId, txId])
+}
+
+module.exports = {
+  batch,
+  single,
+  cancel,
+  getCustomerTransactionsBatch,
+  getTx,
+  getTxAssociatedData,
+  updateTxCustomerPhoto
+}