chore: use monorepo organization

packages/server/lib/notifier/codes.js

@@ -0,0 +1,52 @@
+const T = require('../time')
+
+const PING = 'PING'
+const STALE = 'STALE'
+const LOW_CRYPTO_BALANCE = 'LOW_CRYPTO_BALANCE'
+const HIGH_CRYPTO_BALANCE = 'HIGH_CRYPTO_BALANCE'
+const CASH_BOX_FULL = 'CASH_BOX_FULL'
+const LOW_CASH_OUT = 'LOW_CASH_OUT'
+const LOW_RECYCLER_STACKER = 'LOW_RECYCLER_STACKER'
+const SECURITY = 'SECURITY'
+
+const CODES_DISPLAY = {
+  PING: 'Machine Down',
+  STALE: 'Machine Stuck',
+  LOW_CRYPTO_BALANCE: 'Low Crypto Balance',
+  HIGH_CRYPTO_BALANCE: 'High Crypto Balance',
+  CASH_BOX_FULL: 'Cash box full',
+  LOW_CASH_OUT: 'Low Cash-out',
+  LOW_RECYCLER_STACKER: 'Low Recycler Stacker',
+  HIGH_RECYCLER_STACKER: 'High Recycler Stacker',
+  CASHBOX_REMOVED: 'Cashbox removed'
+}
+
+const NETWORK_DOWN_TIME = 3 * T.minute
+const STALE_STATE = 7 * T.minute
+const ALERT_SEND_INTERVAL = T.hour
+
+const NOTIFICATION_TYPES = {
+  HIGH_VALUE_TX: 'highValueTransaction',
+  NORMAL_VALUE_TX: 'transaction',
+  FIAT_BALANCE: 'fiatBalance',
+  CRYPTO_BALANCE: 'cryptoBalance',
+  COMPLIANCE: 'compliance',
+  ERROR: 'error',
+  SECURITY: 'security'
+}
+
+module.exports = {
+  PING,
+  STALE,
+  LOW_CRYPTO_BALANCE,
+  HIGH_CRYPTO_BALANCE,
+  CASH_BOX_FULL,
+  LOW_CASH_OUT,
+  LOW_RECYCLER_STACKER,
+  SECURITY,
+  CODES_DISPLAY,
+  NETWORK_DOWN_TIME,
+  STALE_STATE,
+  ALERT_SEND_INTERVAL,
+  NOTIFICATION_TYPES
+}

packages/server/lib/notifier/email.js

@@ -0,0 +1,93 @@
+const _ = require('lodash/fp')
+const utils = require('./utils')
+
+const email = require('../email')
+
+const {
+  PING,
+  STALE,
+  LOW_CRYPTO_BALANCE,
+  HIGH_CRYPTO_BALANCE,
+  CASH_BOX_FULL,
+  LOW_CASH_OUT,
+  LOW_RECYCLER_STACKER,
+  SECURITY
+} = require('./codes')
+
+function alertSubject (alertRec, config) {
+  let alerts = []
+
+  if (config.balance) {
+    alerts = _.concat(alerts, alertRec.general)
+  }
+
+  _.forEach(device => {
+    alerts = _.concat(alerts, utils.deviceAlerts(config, alertRec, device))
+  }, _.keys(alertRec.devices))
+
+  if (alerts.length === 0) return null
+
+  const alertTypes = _.flow(_.map('code'), _.uniq, _.map(utils.codeDisplay), _.sortBy(o => o))(alerts)
+  return '[Lamassu] Errors reported: ' + alertTypes.join(', ')
+}
+
+function printEmailAlerts (alertRec, config) {
+  let body = 'Errors were reported by your Lamassu Machines.\n'
+
+  if (config.balance && alertRec.general.length !== 0) {
+    body += '\nGeneral errors:\n'
+    body += emailAlerts(alertRec.general) + '\n'
+  }
+
+  _.forEach(device => {
+    const deviceName = alertRec.deviceNames[device]
+    body += '\nErrors for ' + deviceName + ':\n'
+
+    const alerts = utils.deviceAlerts(config, alertRec, device)
+
+    body += emailAlerts(alerts)
+  }, _.keys(alertRec.devices))
+  return body
+}
+
+function emailAlerts (alerts) {
+  return _.join('\n', _.map(emailAlert, alerts)) + '\n'
+}
+
+function emailAlert (alert) {
+  switch (alert.code) {
+    case PING:
+      if (alert.age) {
+        const pingAge = utils.formatAge(alert.age, { compact: true, verbose: true })
+        return `Machine down for ${pingAge}`
+      }
+      return 'Machine down for a while.'
+    case STALE: {
+      const stuckAge = utils.formatAge(alert.age, { compact: true, verbose: true })
+      return `Machine is stuck on ${alert.state} screen for ${stuckAge}`
+    }
+    case LOW_CRYPTO_BALANCE: {
+      const balance = utils.formatCurrency(alert.fiatBalance.balance, alert.fiatCode)
+      return `Low balance in ${alert.cryptoCode} [${balance}]`
+    }
+    case HIGH_CRYPTO_BALANCE: {
+      const highBalance = utils.formatCurrency(
+        alert.fiatBalance.balance,
+        alert.fiatCode
+      )
+      return `High balance in ${alert.cryptoCode} [${highBalance}]`
+    }
+    case CASH_BOX_FULL:
+      return `Cash box full on ${alert.machineName} [${alert.notes} banknotes]`
+    case LOW_CASH_OUT:
+      return `Cassette for ${alert.denomination} ${alert.fiatCode} low [${alert.notes} banknotes]`
+    case LOW_RECYCLER_STACKER:
+      return `Recycler for ${alert.denomination} ${alert.fiatCode} low [${alert.notes} banknotes]`
+    case SECURITY:
+      return `Cashbox removed on ${alert.machineName}`
+  }
+}
+
+const sendMessage = email.sendMessage
+
+module.exports = { alertSubject, printEmailAlerts, sendMessage }

packages/server/lib/notifier/index.js

@@ -0,0 +1,328 @@
+const _ = require('lodash/fp')
+
+const configManager = require('../new-config-manager')
+const logger = require('../logger')
+const queries = require('./queries')
+const settingsLoader = require('../new-settings-loader')
+const customers = require('../customers')
+
+const notificationCenter = require('./notificationCenter')
+const utils = require('./utils')
+const emailFuncs = require('./email')
+const smsFuncs = require('./sms')
+const webhookFuncs = require('./webhook')
+const { STALE, STALE_STATE } = require('./codes')
+
+function buildMessage (alerts, notifications) {
+  const smsEnabled = utils.isActive(notifications.sms)
+  const emailEnabled = utils.isActive(notifications.email)
+
+  let rec = {}
+  if (smsEnabled) {
+    rec = _.set(['sms', 'body'])(
+      smsFuncs.printSmsAlerts(alerts, notifications.sms)
+    )(rec)
+  }
+  if (emailEnabled) {
+    rec = _.set(['email', 'subject'])(
+      emailFuncs.alertSubject(alerts, notifications.email)
+    )(rec)
+    rec = _.set(['email', 'body'])(
+      emailFuncs.printEmailAlerts(alerts, notifications.email)
+    )(rec)
+  }
+
+  return rec
+}
+
+function checkNotification (plugins) {
+  const notifications = plugins.getNotificationConfig()
+  const smsEnabled = utils.isActive(notifications.sms)
+  const emailEnabled = utils.isActive(notifications.email)
+  const notificationCenterEnabled = utils.isActive(notifications.notificationCenter)
+
+  if (!(notificationCenterEnabled || smsEnabled || emailEnabled)) return Promise.resolve()
+
+  return getAlerts(plugins)
+    .then(alerts => {
+      notifyIfActive('errors', 'errorAlertsNotify', alerts)
+      const currentAlertFingerprint = utils.buildAlertFingerprint(
+        alerts,
+        notifications
+      )
+      if (!currentAlertFingerprint) {
+        const inAlert = !!utils.getAlertFingerprint()
+        // variables for setAlertFingerprint: (fingerprint = null, lastAlertTime = null)
+        utils.setAlertFingerprint(null, null)
+        if (inAlert) return utils.sendNoAlerts(plugins, smsEnabled, emailEnabled)
+      }
+      if (utils.shouldNotAlert(currentAlertFingerprint)) return
+
+      const message = buildMessage(alerts, notifications)
+      utils.setAlertFingerprint(currentAlertFingerprint, Date.now())
+      return plugins.sendMessage(message)
+    })
+    .then(results => {
+      if (results && results.length > 0) {
+        logger.debug('Successfully sent alerts')
+      }
+    })
+    .catch(logger.error)
+}
+
+function getAlerts (plugins) {
+  return Promise.all([
+    plugins.checkBalances(),
+    queries.machineEvents(),
+    plugins.getMachineNames()
+  ]).then(([balances, events, devices]) => {
+    notifyIfActive('balance', 'balancesNotify', balances)
+    return buildAlerts(checkPings(devices), balances, events, devices)
+  })
+}
+
+function buildAlerts (pings, balances, events, devices) {
+  const alerts = { devices: {}, deviceNames: {} }
+  alerts.general = _.filter(r => !r.deviceId, balances)
+  _.forEach(device => {
+    const deviceId = device.deviceId
+    const ping = pings[deviceId] || []
+    const stuckScreen = checkStuckScreen(events, device)
+
+    alerts.devices = _.set([deviceId, 'balanceAlerts'], _.filter(
+      ['deviceId', deviceId],
+      balances
+    ), alerts.devices)
+    alerts.devices[deviceId].deviceAlerts = _.isEmpty(ping) ? stuckScreen : ping
+
+    alerts.deviceNames[deviceId] = device.name
+  }, devices)
+
+  return alerts
+}
+
+function checkPings (devices) {
+  const deviceIds = _.map('deviceId', devices)
+  const pings = _.map(utils.checkPing, devices)
+  return _.zipObject(deviceIds)(pings)
+}
+
+function checkStuckScreen (deviceEvents, machine) {
+  const lastEvent = _.pipe(
+    _.filter(e => e.device_id === machine.deviceId),
+    _.sortBy(utils.getDeviceTime),
+    _.map(utils.parseEventNote),
+    _.last
+  )(deviceEvents)
+
+  if (!lastEvent) return []
+
+  const state = lastEvent.note.state
+  const isIdle = lastEvent.note.isIdle
+
+  if (isIdle) return []
+
+  const age = Math.floor(lastEvent.age)
+  const machineName = machine.name
+  if (age > STALE_STATE) return [{ code: STALE, state, age, machineName }]
+
+  return []
+}
+
+function transactionNotify (tx, rec) {
+  return settingsLoader.loadLatestConfig().then(config => {
+    const notifSettings = configManager.getGlobalNotifications(config)
+    const highValueTx = tx.fiat.gt(notifSettings.highValueTransaction || Infinity)
+    const isCashOut = tx.direction === 'cashOut'
+
+    // for notification center
+    const directionDisplay = isCashOut ? 'cash-out' : 'cash-in'
+    const readyToNotify = !isCashOut || (tx.direction === 'cashOut' && rec.isRedemption)
+    // awaiting for redesign. notification should not be sent if toggle in the settings table is disabled,
+    // but currently we're sending notifications of high value tx even with the toggle disabled
+    if (readyToNotify && !highValueTx) {
+      notifyIfActive('transactions', 'notifCenterTransactionNotify', highValueTx, directionDisplay, tx.fiat, tx.fiatCode, tx.deviceId, tx.toAddress)
+    } else if (readyToNotify && highValueTx) {
+      notificationCenter.notifCenterTransactionNotify(highValueTx, directionDisplay, tx.fiat, tx.fiatCode, tx.deviceId, tx.toAddress)
+    }
+
+    // alert through sms or email any transaction or high value transaction, if SMS || email alerts are enabled
+    const walletSettings = configManager.getWalletSettings(tx.cryptoCode, config)
+    const zeroConfLimit = walletSettings.zeroConfLimit || 0
+    const zeroConf = isCashOut && tx.fiat.lte(zeroConfLimit)
+    const notificationsEnabled = notifSettings.sms.transactions || notifSettings.email.transactions
+    const customerPromise = tx.customerId ? customers.getById(tx.customerId) : Promise.resolve({})
+
+    if (!notificationsEnabled && !highValueTx) return Promise.resolve()
+    if (zeroConf && isCashOut && !rec.isRedemption && !rec.error) return Promise.resolve()
+    if (!zeroConf && rec.isRedemption) return sendRedemptionMessage(tx.id, rec.error)
+
+    return Promise.all([
+      queries.getMachineName(tx.deviceId),
+      customerPromise
+    ]).then(([machineName, customer]) => {
+      return utils.buildTransactionMessage(tx, rec, highValueTx, machineName, customer)
+    }).then(([msg, highValueTx]) => sendTransactionMessage(msg, highValueTx))
+  })
+}
+
+function complianceNotify (settings, customer, deviceId, action, period) {
+  const timestamp = (new Date()).toLocaleString()
+  return queries.getMachineName(deviceId)
+    .then(machineName => {
+      const notifications = configManager.getGlobalNotifications(settings.config)
+
+      const msgCore = {
+        BLOCKED: `was blocked`,
+        SUSPENDED: `was suspended for ${!!period && period} days`,
+        PENDING_COMPLIANCE: `is waiting for your manual approval`,
+      }
+
+      const rec = {
+        sms: {
+          body: `Customer ${customer.phone} ${msgCore[action]} - ${machineName}. ${timestamp}`
+        },
+        email: {
+          subject: `Customer compliance`,
+          body: `Customer ${customer.phone} ${msgCore[action]} in machine ${machineName}. ${timestamp}`
+        },
+        webhook: {
+          topic: `Customer compliance`,
+          content: `Customer ${customer.phone} ${msgCore[action]} in machine ${machineName}. ${timestamp}`
+        }
+      }
+
+      const promises = []
+
+      const emailActive =
+        notifications.email.active &&
+        notifications.email.compliance
+
+      const smsActive =
+        notifications.sms.active &&
+        notifications.sms.compliance
+
+      const webhookActive = true
+
+      if (emailActive) promises.push(emailFuncs.sendMessage(settings, rec))
+      if (smsActive) promises.push(smsFuncs.sendMessage(settings, rec))
+      if (webhookActive) promises.push(webhookFuncs.sendMessage(settings, rec))
+
+      notifyIfActive('compliance', 'customerComplianceNotify', customer, deviceId, action, machineName, period)
+
+      return Promise.all(promises)
+        .catch(err => console.error(`An error occurred when sending a notification. Please check your notification preferences and 3rd party account configuration: ${err.stack}`))
+    })
+}
+
+function sendRedemptionMessage (txId, error) {
+  const subject = `Here's an update on transaction ${txId}`
+  const body = error
+    ? `Error: ${error}`
+    : 'It was just dispensed successfully'
+
+  const rec = {
+    sms: {
+      body: `${subject} - ${body}`
+    },
+    email: {
+      subject,
+      body
+    },
+    webhook: {
+      topic: `Transaction update`,
+      content: body
+    }
+  }
+  return sendTransactionMessage(rec)
+}
+
+function sendTransactionMessage (rec, isHighValueTx) {
+  return settingsLoader.loadLatest().then(settings => {
+    const notifications = configManager.getGlobalNotifications(settings.config)
+
+    const promises = []
+
+    const emailActive =
+      notifications.email.active &&
+      (notifications.email.transactions || isHighValueTx)
+    if (emailActive) promises.push(emailFuncs.sendMessage(settings, rec))
+
+    const smsActive =
+      notifications.sms.active &&
+      (notifications.sms.transactions || isHighValueTx)
+    if (smsActive) promises.push(smsFuncs.sendMessage(settings, rec))
+
+    // TODO: Webhook transaction notifications are dependent on notification settings, due to how transactionNotify() is programmed
+    // As changing it would require structural change to that function and the current behavior is temporary (webhooks will eventually have settings tied to them), it's not worth those changes right now
+    const webhookActive = true
+    if (webhookActive) promises.push(webhookFuncs.sendMessage(settings, rec))
+
+    return Promise.all(promises)
+      .catch(err => console.error(`An error occurred when sending a notification. Please check your notification preferences and 3rd party account configuration: ${err.stack}`))
+  })
+}
+
+function cashboxNotify (deviceId) {
+  return Promise.all([
+    settingsLoader.loadLatest(),
+    queries.getMachineName(deviceId)
+  ])
+    .then(([settings, machineName]) => {
+      const notifications = configManager.getGlobalNotifications(settings.config)
+      const rec = {
+        sms: {
+          body: `Cashbox removed - ${machineName}`
+        },
+        email: {
+          subject: `Cashbox removal`,
+          body: `Cashbox removed in machine ${machineName}`
+        },
+        webhook: {
+          topic: `Cashbox removal`,
+          content: `Cashbox removed in machine ${machineName}`
+        }
+      }
+
+      const promises = []
+
+      const emailActive =
+        notifications.email.active &&
+        notifications.email.security
+
+      const smsActive =
+        notifications.sms.active &&
+        notifications.sms.security
+
+      const webhookActive = true
+      
+      if (emailActive) promises.push(emailFuncs.sendMessage(settings, rec))
+      if (smsActive) promises.push(smsFuncs.sendMessage(settings, rec))
+      if (webhookActive) promises.push(webhookFuncs.sendMessage(settings, rec))
+      notifyIfActive('security', 'cashboxNotify', deviceId)
+
+      return Promise.all(promises)
+        .catch(err => console.error(`An error occurred when sending a notification. Please check your notification preferences and 3rd party account configuration: ${err.stack}`))
+    })
+}
+
+// for notification center, check if type of notification is active before calling the respective notify function
+const notifyIfActive = (type, fnName, ...args) => {
+  return settingsLoader.loadLatestConfig().then(config => {
+    const notificationSettings = configManager.getGlobalNotifications(config).notificationCenter
+    if (!notificationCenter[fnName]) return Promise.reject(new Error(`Notification function ${fnName} for type ${type} does not exist`))
+    if (!(notificationSettings.active && notificationSettings[type])) return Promise.resolve()
+    return notificationCenter[fnName](...args)
+  }).catch(logger.error)
+}
+
+module.exports = {
+  transactionNotify,
+  complianceNotify,
+  checkNotification,
+  checkPings,
+  checkStuckScreen,
+  sendRedemptionMessage,
+  cashboxNotify,
+  notifyIfActive
+}

packages/server/lib/notifier/notificationCenter.js

@@ -0,0 +1,215 @@
+const _ = require('lodash/fp')
+
+const queries = require('./queries')
+const utils = require('./utils')
+const customers = require('../customers')
+const {
+  NOTIFICATION_TYPES: {
+    SECURITY,
+    COMPLIANCE,
+    CRYPTO_BALANCE,
+    FIAT_BALANCE,
+    ERROR,
+    HIGH_VALUE_TX,
+    NORMAL_VALUE_TX
+  },
+
+  STALE,
+  PING,
+
+  HIGH_CRYPTO_BALANCE,
+  LOW_CRYPTO_BALANCE,
+  CASH_BOX_FULL,
+  LOW_CASH_OUT,
+  LOW_RECYCLER_STACKER,
+} = require('./codes')
+
+const sanctionsNotify = (customer, phone) => {
+  const code = 'SANCTIONS'
+  const detailB = utils.buildDetail({ customerId: customer.id, code })
+  const addNotif = phone =>
+    queries.addNotification(COMPLIANCE, `Blocked customer with phone ${phone} for being on the OFAC sanctions list`, detailB)
+  // if it's a new customer then phone comes as undefined
+  return phone ? addNotif(phone) : customers.getById(customer.id).then(c => addNotif(c.phone))
+}
+
+const clearOldCustomerSuspendedNotifications = (customerId, deviceId) => {
+  const detailB = utils.buildDetail({ code: 'SUSPENDED', customerId, deviceId })
+  return queries.invalidateNotification(detailB, 'compliance')
+}
+
+const customerComplianceNotify = (customer, deviceId, code, machineName, days = null) => {
+  // code for now can be "BLOCKED", "SUSPENDED"
+  const detailB = utils.buildDetail({ customerId: customer.id, code, deviceId })
+  const date = new Date()
+  if (days) {
+    date.setDate(date.getDate() + days)
+  }
+  const message = code === 'SUSPENDED' ? `Customer ${customer.phone} suspended until ${date.toLocaleString()}` :
+    code === 'BLOCKED' ? `Customer ${customer.phone} blocked` :
+    `Customer ${customer.phone} has pending compliance in machine ${machineName}`
+
+  return clearOldCustomerSuspendedNotifications(customer.id, deviceId)
+    .then(() => queries.getValidNotifications(COMPLIANCE, detailB))
+    .then(res => {
+      if (res.length > 0) return Promise.resolve()
+      return queries.addNotification(COMPLIANCE, message, detailB)
+    })
+}
+
+const clearOldFiatNotifications = (balances) => {
+  return queries.getAllValidNotifications(FIAT_BALANCE).then(notifications => {
+    const filterByBalance = _.filter(notification => {
+      const { cassette, deviceId } = notification.detail
+      return !_.find(balance => balance.cassette === cassette && balance.deviceId === deviceId)(balances)
+    })
+    const indexesToInvalidate = _.compose(_.map('id'), filterByBalance)(notifications)
+    const notInvalidated = _.filter(notification => {
+      return !_.find(id => notification.id === id)(indexesToInvalidate)
+    }, notifications)
+    return (indexesToInvalidate.length ? queries.batchInvalidate(indexesToInvalidate) : Promise.resolve()).then(() => notInvalidated)
+  })
+}
+
+const fiatBalancesNotify = (fiatWarnings) => {
+  return clearOldFiatNotifications(fiatWarnings).then(notInvalidated => {
+    return fiatWarnings.forEach(balance => {
+      if (_.find(o => {
+        const { cassette, deviceId } = o.detail
+        return cassette === balance.cassette && deviceId === balance.deviceId
+      }, notInvalidated)) return
+      const message = balance.code === LOW_CASH_OUT ?
+        `Cash-out cassette ${balance.cassette} low or empty!` :
+        balance.code === LOW_RECYCLER_STACKER ?
+        `Recycler ${balance.cassette} low or empty!` :
+        balance.code === CASH_BOX_FULL ?
+        `Cash box full or almost full!` :
+        `Cash box full or almost full!` /* Shouldn't happen */
+      const detailB = utils.buildDetail({ deviceId: balance.deviceId, cassette: balance.cassette })
+      return queries.addNotification(FIAT_BALANCE, message, detailB)
+    })
+  })
+}
+
+const clearOldCryptoNotifications = balances => {
+  return queries.getAllValidNotifications(CRYPTO_BALANCE).then(res => {
+    const filterByBalance = _.filter(notification => {
+      const { cryptoCode, code } = notification.detail
+      return !_.find(balance => balance.cryptoCode === cryptoCode && balance.code === code)(balances)
+    })
+    const indexesToInvalidate = _.compose(_.map('id'), filterByBalance)(res)
+
+    const notInvalidated = _.filter(notification => {
+      return !_.find(id => notification.id === id)(indexesToInvalidate)
+    }, res)
+    return (indexesToInvalidate.length ? queries.batchInvalidate(indexesToInvalidate) : Promise.resolve()).then(() => notInvalidated)
+  })
+}
+
+const cryptoBalancesNotify = (cryptoWarnings) => {
+  return clearOldCryptoNotifications(cryptoWarnings).then(notInvalidated => {
+    return cryptoWarnings.forEach(balance => {
+      // if notification exists in DB and wasnt invalidated then don't add a duplicate
+      if (_.find(o => {
+        const { code, cryptoCode } = o.detail
+        return code === balance.code && cryptoCode === balance.cryptoCode
+      }, notInvalidated)) return
+
+      const fiat = utils.formatCurrency(balance.fiatBalance.balance, balance.fiatCode)
+      const message = `${balance.code === HIGH_CRYPTO_BALANCE ? 'High' : 'Low'} balance in ${balance.cryptoCode} [${fiat}]`
+      const detailB = utils.buildDetail({ cryptoCode: balance.cryptoCode, code: balance.code })
+      return queries.addNotification(CRYPTO_BALANCE, message, detailB)
+    })
+  })
+}
+
+const balancesNotify = (balances) => {
+  const isCryptoCode = c => _.includes(c, [HIGH_CRYPTO_BALANCE, LOW_CRYPTO_BALANCE])
+  const isFiatCode = c => _.includes(c, [LOW_CASH_OUT, CASH_BOX_FULL, LOW_RECYCLER_STACKER])
+  const by = o =>
+    isCryptoCode(o) ? 'crypto' :
+    isFiatCode(o) ? 'fiat' :
+    undefined
+  const warnings = _.flow(
+    _.groupBy(_.flow(_.get(['code']), by)),
+    _.update('crypto', _.defaultTo([])),
+    _.update('fiat', _.defaultTo([])),
+  )(balances)
+  return Promise.all([cryptoBalancesNotify(warnings.crypto), fiatBalancesNotify(warnings.fiat)])
+}
+
+const clearOldErrorNotifications = alerts => {
+  return queries.getAllValidNotifications(ERROR)
+    .then(res => {
+      // for each valid notification in DB see if it exists in alerts
+      // if the notification doesn't exist in alerts, it is not valid anymore
+      const filterByAlert = _.filter(notification => {
+        const { code, deviceId } = notification.detail
+        return !_.find(alert => alert.code === code && alert.deviceId === deviceId)(alerts)
+      })
+      const indexesToInvalidate = _.compose(_.map('id'), filterByAlert)(res)
+      if (!indexesToInvalidate.length) return Promise.resolve()
+      return queries.batchInvalidate(indexesToInvalidate)
+    })
+}
+
+const errorAlertsNotify = (alertRec) => {
+  const embedDeviceId = deviceId => _.assign({ deviceId })
+  const mapToAlerts = _.map(it => _.map(embedDeviceId(it), alertRec.devices[it].deviceAlerts))
+  const alerts = _.compose(_.flatten, mapToAlerts, _.keys)(alertRec.devices)
+
+  return clearOldErrorNotifications(alerts).then(() => {
+    _.forEach(alert => {
+      switch (alert.code) {
+        case PING: {
+          const detailB = utils.buildDetail({ code: PING, age: alert.age ? alert.age : -1, deviceId: alert.deviceId })
+          return queries.getValidNotifications(ERROR, _.omit(['age'], detailB)).then(res => {
+            if (res.length > 0) return Promise.resolve()
+            const message = `Machine down`
+            return queries.addNotification(ERROR, message, detailB)
+          })
+        }
+        case STALE: {
+          const detailB = utils.buildDetail({ code: STALE, deviceId: alert.deviceId })
+          return queries.getValidNotifications(ERROR, detailB).then(res => {
+            if (res.length > 0) return Promise.resolve()
+            const message = `Machine is stuck on ${alert.state} screen`
+            return queries.addNotification(ERROR, message, detailB)
+          })
+        }
+      }
+    }, alerts)
+  })
+}
+
+function notifCenterTransactionNotify (isHighValue, direction, fiat, fiatCode, deviceId, cryptoAddress) {
+  const messageSuffix = isHighValue ? 'High value' : ''
+  const message = `${messageSuffix} ${fiat} ${fiatCode} ${direction} transaction`
+  const detailB = utils.buildDetail({ deviceId: deviceId, direction, fiat, fiatCode, cryptoAddress })
+  return queries.addNotification(isHighValue ? HIGH_VALUE_TX : NORMAL_VALUE_TX, message, detailB)
+}
+
+const blacklistNotify = (tx, isAddressReuse) => {
+  const code = isAddressReuse ? 'REUSED' : 'BLOCKED'
+  const name = isAddressReuse ? 'reused' : 'blacklisted'
+
+  const detailB = utils.buildDetail({ cryptoCode: tx.cryptoCode, code, cryptoAddress: tx.toAddress })
+  const message = `Blocked ${name} address: ${tx.cryptoCode} ${tx.toAddress.substr(0, 10)}...`
+  return queries.addNotification(COMPLIANCE, message, detailB)
+}
+
+const cashboxNotify = deviceId => {
+  const detailB = utils.buildDetail({ deviceId: deviceId })
+  const message = `Cashbox removed`
+  return queries.addNotification(SECURITY, message, detailB)
+}
+
+module.exports = {
+  sanctionsNotify,
+  customerComplianceNotify,
+  balancesNotify,
+  errorAlertsNotify,
+  notifCenterTransactionNotify,
+  blacklistNotify,
+  cashboxNotify
+}

packages/server/lib/notifier/queries.js

@@ -0,0 +1,109 @@
+const { v4: uuidv4 } = require('uuid')
+const pgp = require('pg-promise')()
+const _ = require('lodash/fp')
+
+const dbm = require('../postgresql_interface')
+const db = require('../db')
+const logger = require('../logger')
+
+// types of notifications able to be inserted into db:
+/*
+highValueTransaction - for transactions of value higher than threshold
+fiatBalance - when the number of notes in cash cassettes falls below threshold
+cryptoBalance - when ammount of crypto balance in fiat falls below or above low/high threshold
+compliance - notifications related to warnings triggered by compliance settings
+error - notifications related to errors
+*/
+
+function getMachineName (machineId) {
+  const sql = 'SELECT * FROM devices WHERE device_id=$1'
+  return db.oneOrNone(sql, [machineId])
+    .then(it => it.name).catch(logger.error)
+}
+
+const addNotification = (type, message, detail) => {
+  const sql = `INSERT INTO notifications (id, type, message, detail) VALUES ($1, $2, $3, $4)`
+  return db.oneOrNone(sql, [uuidv4(), type, message, detail]).catch(logger.error)
+}
+
+const getAllValidNotifications = (type) => {
+  const sql = `SELECT * FROM notifications WHERE type = $1 AND valid = 't'`
+  return db.any(sql, [type]).catch(logger.error)
+}
+
+const invalidateNotification = (detail, type) => {
+  detail = _.omitBy(_.isEmpty, detail)
+  const sql = `UPDATE notifications SET valid = 'f', read = 't' WHERE valid = 't' AND type = $1 AND detail::jsonb @> $2::jsonb`
+  return db.none(sql, [type, detail]).catch(logger.error)
+}
+
+const batchInvalidate = (ids) => {
+  const formattedIds = _.map(pgp.as.text, ids).join(',')
+  const sql = `UPDATE notifications SET valid = 'f', read = 't' WHERE id IN ($1^)`
+  return db.none(sql, [formattedIds]).catch(logger.error)
+}
+
+const clearBlacklistNotification = (cryptoCode, cryptoAddress) => {
+  const sql = `UPDATE notifications SET valid = 'f', read = 't' WHERE type = 'compliance' AND detail->>'cryptoCode' = $1 AND detail->>'cryptoAddress' = $2 AND (detail->>'code' = 'BLOCKED' OR detail->>'code' = 'REUSED')`
+  return db.none(sql, [cryptoCode, cryptoAddress]).catch(logger.error)
+}
+
+const getValidNotifications = (type, detail) => {
+  const sql = `SELECT * FROM notifications WHERE type = $1 AND valid = 't' AND detail @> $2`
+  return db.any(sql, [type, detail]).catch(logger.error)
+}
+
+const WITHIN_PAST_WEEK = `created > (CURRENT_TIMESTAMP - INTERVAL '7' DAY)`
+
+const getNotifications = () => {
+  const sql = `
+    SELECT * FROM notifications
+    WHERE ${WITHIN_PAST_WEEK}
+    ORDER BY created DESC
+  `
+  return db.any(sql).catch(logger.error)
+}
+const setRead = (id, read) => {
+  const sql = `UPDATE notifications SET read = $1 WHERE id = $2`
+  return db.none(sql, [read, id]).catch(logger.error)
+}
+
+const markAllAsRead = () => {
+  const sql = `UPDATE notifications SET read = 't'`
+  return db.none(sql).catch(logger.error)
+}
+
+const hasUnreadNotifications = () => {
+  const sql = `
+    SELECT EXISTS
+    (SELECT * FROM notifications
+    WHERE NOT read AND ${WITHIN_PAST_WEEK})
+    `
+  return db.oneOrNone(sql).then(res => res.exists).catch(logger.error)
+}
+
+const getAlerts = () => {
+  const types = ['fiatBalance', 'cryptoBalance', 'error']
+  const sql = `
+    SELECT * FROM notifications
+    WHERE ${WITHIN_PAST_WEEK} AND valid='t' AND type IN ($1:list)
+    ORDER BY created DESC
+    `
+  return db.any(sql, [types]).catch(logger.error)
+}
+
+module.exports = {
+  machineEvents: dbm.machineEvents,
+  addNotification,
+  getAllValidNotifications,
+  invalidateNotification,
+  batchInvalidate,
+  clearBlacklistNotification,
+  getValidNotifications,
+  getNotifications,
+  setRead,
+  markAllAsRead,
+  hasUnreadNotifications,
+  getAlerts,
+  getMachineName
+}

packages/server/lib/notifier/sms.js

@@ -0,0 +1,56 @@
+const _ = require('lodash/fp')
+const utils = require('./utils')
+const sms = require('../sms')
+
+function printSmsAlerts (alertRec, config) {
+  let alerts = []
+
+  if (config.balance) {
+    alerts = _.concat(alerts, alertRec.general)
+  }
+
+  _.forEach(device => {
+    alerts = _.concat(alerts, utils.deviceAlerts(config, alertRec, device))
+  }, _.keys(alertRec.devices))
+
+  if (alerts.length === 0) return null
+
+  const alertsMap = _.groupBy('code', alerts)
+
+  const alertTypes = _.map(entry => {
+    const code = entry[0]
+    const machineNames = _.filter(
+      _.negate(_.isEmpty),
+      _.map('machineName', entry[1])
+    )
+
+    const cryptoCodes = _.filter(
+      _.negate(_.isEmpty),
+      _.map('cryptoCode', entry[1])
+    )
+
+    return {
+      codeDisplay: utils.codeDisplay(code),
+      machineNames,
+      cryptoCodes
+    }
+  }, _.toPairs(alertsMap))
+
+  const mapByCodeDisplay = _.map(it => {
+    if (_.isEmpty(it.machineNames) && _.isEmpty(it.cryptoCodes)) return it.codeDisplay
+    if (_.isEmpty(it.machineNames)) return `${it.codeDisplay} (${it.cryptoCodes.join(', ')})`
+    return `${it.codeDisplay} (${it.machineNames.join(', ')})`
+  })
+
+  const displayAlertTypes = _.compose(
+    _.uniq,
+    mapByCodeDisplay,
+    _.sortBy('codeDisplay')
+  )(alertTypes)
+
+  return '[Lamassu] Errors reported: ' + displayAlertTypes.join(', ')
+}
+
+const sendMessage = sms.sendMessage
+
+module.exports = { printSmsAlerts, sendMessage }

packages/server/lib/notifier/test/email.test.js

@@ -0,0 +1,28 @@
+const email = require('../email')
+
+const alertRec = {
+  devices: {
+    f02af604ca9010bd9ae04c427a24da90130da10d355f0a9b235886a89008fc05: {
+      balanceAlerts: [],
+      deviceAlerts: [
+        { code: 'PING', age: 602784301.446, machineName: 'Abc123' }
+      ]
+    }
+  },
+  deviceNames: {
+    f02af604ca9010bd9ae04c427a24da90130da10d355f0a9b235886a89008fc05: 'Abc123'
+  },
+  general: []
+}
+
+const printEmailMsg = `Errors were reported by your Lamassu Machines.
+
+Errors for Abc123:
+Machine down for ~6 days
+`
+
+test('Print Email Alers', () => {
+  expect(email.printEmailAlerts(alertRec, { active: true, errors: true })).toBe(
+    printEmailMsg
+  )
+})

packages/server/lib/notifier/test/notifier.test.js

@@ -0,0 +1,332 @@
+const BN = require('../../../lib/bn')
+
+const notifier = require('..')
+const utils = require('../utils')
+const smsFuncs = require('../sms')
+
+afterEach(() => {
+  // https://stackoverflow.com/questions/58151010/difference-between-resetallmocks-resetmodules-resetmoduleregistry-restoreallm
+  jest.restoreAllMocks()
+})
+
+// mock plugins object with mock data to test functions
+const plugins = {
+  sendMessage: rec => {
+    return rec
+  },
+  getNotificationConfig: () => ({
+    email_active: false,
+    sms_active: true,
+    email_errors: false,
+    sms_errors: true,
+    sms: { active: true, errors: true },
+    email: { active: false, errors: false }
+  }),
+  getMachineNames: () => [
+    {
+      deviceId:
+        'f02af604ca9010bd9ae04c427a24da90130da10d355f0a9b235886a89008fc05',
+      cashbox: 0,
+      cassette1: 444,
+      cassette2: 222,
+      version: '7.5.0-beta.0',
+      model: 'unknown',
+      pairedAt: '2020-11-13T16:20:31.624Z',
+      lastPing: '2020-11-16T13:11:03.169Z',
+      name: 'Abc123',
+      paired: true,
+      cashOut: true,
+      statuses: [{ label: 'Unresponsive', type: 'error' }]
+    }
+  ],
+  checkBalances: () => []
+}
+
+const tx = {
+  id: 'bec8d452-9ea2-4846-841b-55a9df8bbd00',
+  deviceId:
+    '490ab16ee0c124512dc769be1f3e7ee3894ce1e5b4b8b975e134fb326e551e88',
+  toAddress: 'bc1q7s4yy5n9vp6zhlf6mrw3cttdgx5l3ysr2mhc4v',
+  cryptoAtoms: new BN(252100),
+  cryptoCode: 'BTC',
+  fiat: new BN(55),
+  fiatCode: 'USD',
+  fee: null,
+  txHash: null,
+  phone: null,
+  error: null,
+  created: '2020-12-04T16:28:11.016Z',
+  send: true,
+  sendConfirmed: false,
+  timedout: false,
+  sendTime: null,
+  errorCode: null,
+  operatorCompleted: false,
+  sendPending: true,
+  cashInFee: new BN(2),
+  minimumTx: 5,
+  customerId: '47ac1184-8102-11e7-9079-8f13a7117867',
+  txVersion: 6,
+  termsAccepted: false,
+  commissionPercentage: new BN(0.11),
+  rawTickerPrice: new BN(18937.4),
+  isPaperWallet: false,
+  direction: 'cashIn'
+}
+
+const notifSettings = {
+  email_active: false,
+  sms_active: true,
+  email_errors: false,
+  sms_errors: true,
+  sms_transactions: true,
+  highValueTransaction: Infinity, // this will make highValueTx always false
+  sms: {
+    active: true,
+    errors: true,
+    transactions: false // force early return
+  },
+  email: {
+    active: false,
+    errors: false,
+    transactions: false // force early return
+  }
+}
+
+test('Exits checkNotifications with Promise.resolve() if SMS and Email are disabled', async () => {
+  expect.assertions(1)
+  await expect(
+    notifier.checkNotification({
+      getNotificationConfig: () => ({
+        sms: { active: false, errors: false },
+        email: { active: false, errors: false }
+      })
+    })
+  ).resolves.toBe(undefined)
+})
+
+test('Exits checkNotifications with Promise.resolve() if SMS and Email are disabled even if errors or balance are defined to something', async () => {
+  expect.assertions(1)
+  await expect(
+    notifier.checkNotification({
+      getNotificationConfig: () => ({
+        sms: { active: false, errors: true, balance: true },
+        email: { active: false, errors: true, balance: true }
+      })
+    })
+  ).resolves.toBe(undefined)
+})
+
+test("Check Pings should return code PING for devices that haven't been pinged recently", () => {
+  expect(
+    notifier.checkPings([
+      {
+        deviceId:
+          '7e531a2666987aa27b9917ca17df7998f72771c57fdb21c90bc033999edd17e4',
+        lastPing: '2020-11-16T13:11:03.169Z',
+        name: 'Abc123'
+      }
+    ])
+  ).toMatchObject({
+    '7e531a2666987aa27b9917ca17df7998f72771c57fdb21c90bc033999edd17e4': [
+      { code: 'PING', machineName: 'Abc123' }
+    ]
+  })
+})
+
+test('Checkpings returns empty array as the value for the id prop, if the lastPing is more recent than 60 seconds', () => {
+  expect(
+    notifier.checkPings([
+      {
+        deviceId:
+          '7a531a2666987aa27b9917ca17df7998f72771c57fdb21c90bc033999edd17e4',
+        lastPing: new Date(),
+        name: 'Abc123'
+      }
+    ])
+  ).toMatchObject({
+    '7a531a2666987aa27b9917ca17df7998f72771c57fdb21c90bc033999edd17e4': []
+  })
+})
+
+test('Check notification resolves to undefined if shouldNotAlert is called and is true', async () => {
+  const mockShouldNotAlert = jest.spyOn(utils, 'shouldNotAlert')
+  mockShouldNotAlert.mockReturnValue(true)
+
+  const result = await notifier.checkNotification(plugins)
+  expect(mockShouldNotAlert).toHaveBeenCalledTimes(1)
+  expect(result).toBe(undefined)
+})
+
+test('Sendmessage is called if shouldNotAlert is called and is false', async () => {
+  const mockShouldNotAlert = jest.spyOn(utils, 'shouldNotAlert')
+  const mockSendMessage = jest.spyOn(plugins, 'sendMessage')
+
+  mockShouldNotAlert.mockReturnValue(false)
+  const result = await notifier.checkNotification(plugins)
+
+  expect(mockShouldNotAlert).toHaveBeenCalledTimes(1)
+  expect(mockSendMessage).toHaveBeenCalledTimes(1)
+  expect(result).toBe(undefined)
+})
+
+test('If no alert fingerprint and inAlert is true, exits on call to sendNoAlerts', async () => {
+  // mock utils.buildAlertFingerprint to return null
+  // mock utils.getAlertFingerprint to be true which will make inAlert true
+
+  const buildFp = jest.spyOn(utils, 'buildAlertFingerprint')
+  const mockGetFp = jest.spyOn(utils, 'getAlertFingerprint')
+  const mockSendNoAlerts = jest.spyOn(utils, 'sendNoAlerts')
+
+  buildFp.mockReturnValue(null)
+  mockGetFp.mockReturnValue(true)
+  await notifier.checkNotification(plugins)
+
+  expect(mockGetFp).toHaveBeenCalledTimes(1)
+  expect(mockSendNoAlerts).toHaveBeenCalledTimes(1)
+})
+
+// vvv tests for checkstuckscreen...
+test('checkStuckScreen returns [] when no events are found', () => {
+  expect(notifier.checkStuckScreen([], 'Abc123')).toEqual([])
+})
+
+test('checkStuckScreen returns [] if most recent event is idle', () => {
+  // device_time is what matters for the sorting of the events by recency
+  expect(
+    notifier.checkStuckScreen([
+      {
+        id: '48ae51c6-c5b4-485e-b81d-aa337fc025e2',
+        device_id:
+          'f02af604ca9010bd9ae04c427a24da90130da10d355f0a9b235886a89008fc05',
+        event_type: 'stateChange',
+        note: '{"state":"chooseCoin","isIdle":false}',
+        created: '2020-11-23T19:30:29.209Z',
+        device_time: '1999-11-23T19:30:29.177Z',
+        age: 157352628.123
+      },
+      {
+        id: '48ae51c6-c5b4-485e-b81d-aa337fc025e2',
+        device_id:
+          'f02af604ca9010bd9ae04c427a24da90130da10d355f0a9b235886a89008fc05',
+        event_type: 'stateChange',
+        note: '{"state":"chooseCoin","isIdle":true}',
+        created: '2020-11-23T19:30:29.209Z',
+        device_time: '2020-11-23T19:30:29.177Z',
+        age: 157352628.123
+      }
+    ])
+  ).toEqual([])
+})
+
+test('checkStuckScreen returns object array of length 1 with prop code: "STALE" if age > STALE_STATE', () => {
+  // there is an age 0 and an isIdle true in the first object but it will be below the second one in the sorting order and thus ignored
+  const result = notifier.checkStuckScreen([
+    {
+      id: '48ae51c6-c5b4-485e-b81d-aa337fc025e2',
+      device_id:
+        'f02af604ca9010bd9ae04c427a24da90130da10d355f0a9b235886a89008fc05',
+      event_type: 'stateChange',
+      note: '{"state":"chooseCoin","isIdle":true}',
+      created: '2020-11-23T19:30:29.209Z',
+      device_time: '1999-11-23T19:30:29.177Z',
+      age: 0
+    },
+    {
+      id: '48ae51c6-c5b4-485e-b81d-aa337fc025e2',
+      device_id:
+        'f02af604ca9010bd9ae04c427a24da90130da10d355f0a9b235886a89008fc05',
+      event_type: 'stateChange',
+      note: '{"state":"chooseCoin","isIdle":false}',
+      created: '2020-11-23T19:30:29.209Z',
+      device_time: '2020-11-23T19:30:29.177Z',
+      age: 157352628.123
+    }
+  ])
+  expect(result[0]).toMatchObject({ code: 'STALE' })
+})
+
+test('checkStuckScreen returns empty array if age < STALE_STATE', () => {
+  const STALE_STATE = require('../codes').STALE_STATE
+  const result1 = notifier.checkStuckScreen([
+    {
+      id: '48ae51c6-c5b4-485e-b81d-aa337fc025e2',
+      device_id:
+        'f02af604ca9010bd9ae04c427a24da90130da10d355f0a9b235886a89008fc05',
+      event_type: 'stateChange',
+      note: '{"state":"chooseCoin","isIdle":false}',
+      created: '2020-11-23T19:30:29.209Z',
+      device_time: '2020-11-23T19:30:29.177Z',
+      age: 0
+    }
+  ])
+  const result2 = notifier.checkStuckScreen([
+    {
+      id: '48ae51c6-c5b4-485e-b81d-aa337fc025e2',
+      device_id:
+        'f02af604ca9010bd9ae04c427a24da90130da10d355f0a9b235886a89008fc05',
+      event_type: 'stateChange',
+      note: '{"state":"chooseCoin","isIdle":false}',
+      created: '2020-11-23T19:30:29.209Z',
+      device_time: '2020-11-23T19:30:29.177Z',
+      age: STALE_STATE
+    }
+  ])
+  expect(result1).toEqual([])
+  expect(result2).toEqual([])
+})
+
+test('calls sendRedemptionMessage if !zeroConf and rec.isRedemption', async () => {
+  const configManager = require('../../new-config-manager')
+  const settingsLoader = require('../../new-settings-loader')
+
+  const loadLatest = jest.spyOn(settingsLoader, 'loadLatest')
+  const getGlobalNotifications = jest.spyOn(configManager, 'getGlobalNotifications')
+  const getWalletSettings = jest.spyOn(configManager, 'getWalletSettings')
+
+  // sendRedemptionMessage will cause this func to be called
+  jest.spyOn(smsFuncs, 'sendMessage').mockImplementation((_, rec) => rec)
+
+  getWalletSettings.mockReturnValue({ zeroConfLimit: -Infinity })
+  loadLatest.mockReturnValue(Promise.resolve({}))
+  getGlobalNotifications.mockReturnValue({ ...notifSettings, sms: { active: true, errors: true, transactions: true }, notificationCenter: { active: true } })
+
+  const response = await notifier.transactionNotify(tx, { isRedemption: true })
+
+  // this type of response implies sendRedemptionMessage was called
+  expect(response[0]).toMatchObject({
+    sms: {
+      body: "Here's an update on transaction bec8d452-9ea2-4846-841b-55a9df8bbd00 - It was just dispensed successfully"
+    },
+    email: {
+      subject: "Here's an update on transaction bec8d452-9ea2-4846-841b-55a9df8bbd00",
+      body: 'It was just dispensed successfully'
+    }
+  })
+})
+
+test('calls sendTransactionMessage if !zeroConf and !rec.isRedemption', async () => {
+  const configManager = require('../../new-config-manager')
+  const settingsLoader = require('../../new-settings-loader')
+  const queries = require('../queries')
+  const loadLatest = jest.spyOn(settingsLoader, 'loadLatest')
+  const getGlobalNotifications = jest.spyOn(configManager, 'getGlobalNotifications')
+  const getWalletSettings = jest.spyOn(configManager, 'getWalletSettings')
+  const getMachineName = jest.spyOn(queries, 'getMachineName')
+  const buildTransactionMessage = jest.spyOn(utils, 'buildTransactionMessage')
+
+  // sendMessage on emailFuncs isn't called because it is disabled in getGlobalNotifications.mockReturnValue
+  jest.spyOn(smsFuncs, 'sendMessage').mockImplementation((_, rec) => ({ prop: rec }))
+  buildTransactionMessage.mockImplementation(() => ['mock message', false])
+
+  getMachineName.mockResolvedValue('mockMachineName')
+  getWalletSettings.mockReturnValue({ zeroConfLimit: -Infinity })
+  loadLatest.mockReturnValue(Promise.resolve({}))
+  getGlobalNotifications.mockReturnValue({ ...notifSettings, sms: { active: true, errors: true, transactions: true }, notificationCenter: { active: true } })
+
+  const response = await notifier.transactionNotify(tx, { isRedemption: false })
+
+  // If the return object is this, it means the code went through all the functions expected to go through if
+  // getMachineName, buildTransactionMessage and sendTransactionMessage were called, in this order
+  expect(response).toEqual([{prop: 'mock message'}])
+})

packages/server/lib/notifier/test/sms.test.js

@@ -0,0 +1,22 @@
+const sms = require('../sms')
+
+const alertRec = {
+  devices: {
+    f02af604ca9010bd9ae04c427a24da90130da10d355f0a9b235886a89008fc05: {
+      balanceAlerts: [],
+      deviceAlerts: [
+        { code: 'PING', age: 602784301.446, machineName: 'Abc123' }
+      ]
+    }
+  },
+  deviceNames: {
+    f02af604ca9010bd9ae04c427a24da90130da10d355f0a9b235886a89008fc05: 'Abc123'
+  },
+  general: []
+}
+
+test('Print SMS alerts', () => {
+  expect(sms.printSmsAlerts(alertRec, { active: true, errors: true })).toBe(
+    '[Lamassu] Errors reported: Machine Down (Abc123)'
+  )
+})

packages/server/lib/notifier/test/utils.test.js

@@ -0,0 +1,104 @@
+const utils = require('../utils')
+
+const plugins = {
+  sendMessage: rec => {
+    return rec
+  }
+}
+
+const alertRec = {
+  devices: {
+    f02af604ca9010bd9ae04c427a24da90130da10d355f0a9b235886a89008fc05: {
+      balanceAlerts: [],
+      deviceAlerts: [
+        { code: 'PING', age: 1605532263169, machineName: 'Abc123' }
+      ]
+    }
+  },
+  deviceNames: {
+    f02af604ca9010bd9ae04c427a24da90130da10d355f0a9b235886a89008fc05: 'Abc123'
+  },
+  general: []
+}
+
+const notifications = {
+  sms: { active: true, errors: true },
+  email: { active: false, errors: false }
+}
+
+describe('buildAlertFingerprint', () => {
+  test('Build alert fingerprint returns null if no sms or email alerts', () => {
+    expect(
+      utils.buildAlertFingerprint(
+        {
+          devices: {},
+          deviceNames: {},
+          general: []
+        },
+        notifications
+      )
+    ).toBe(null)
+  })
+  
+  test('Build alert fingerprint returns null if sms and email are disabled', () => {
+    expect(
+      utils.buildAlertFingerprint(alertRec, {
+        sms: { active: false, errors: true },
+        email: { active: false, errors: false }
+      })
+    ).toBe(null)
+  })
+  
+  test('Build alert fingerprint returns hash if email or [sms] are enabled and there are alerts in alertrec', () => {
+    expect(
+      typeof utils.buildAlertFingerprint(alertRec, {
+        sms: { active: true, errors: true },
+        email: { active: false, errors: false }
+      })
+    ).toBe('string')
+  })
+  
+  test('Build alert fingerprint returns hash if [email] or sms are enabled and there are alerts in alertrec', () => {
+    expect(
+      typeof utils.buildAlertFingerprint(alertRec, {
+        sms: { active: false, errors: false },
+        email: { active: true, errors: true }
+      })
+    ).toBe('string')
+  })
+})
+
+describe('sendNoAlerts', () => {
+  test('Send no alerts returns empty object with sms and email disabled', () => {
+    expect(utils.sendNoAlerts(plugins, false, false)).toEqual({})
+  })
+
+  test('Send no alerts returns object with sms prop with sms only enabled', () => {
+    expect(utils.sendNoAlerts(plugins, true, false)).toEqual({
+      sms: {
+        body: '[Lamassu] All clear'
+      }
+    })
+  })
+
+  test('Send no alerts returns object with sms and email prop with both enabled', () => {
+    expect(utils.sendNoAlerts(plugins, true, true)).toEqual({
+      email: {
+        body: 'No errors are reported for your machines.',
+        subject: '[Lamassu] All clear'
+      },
+      sms: {
+        body: '[Lamassu] All clear'
+      }
+    })
+  })
+
+  test('Send no alerts returns object with email prop if only email is enabled', () => {
+    expect(utils.sendNoAlerts(plugins, false, true)).toEqual({
+      email: {
+        body: 'No errors are reported for your machines.',
+        subject: '[Lamassu] All clear'
+      }
+    })
+  })
+})

packages/server/lib/notifier/utils.js

@@ -0,0 +1,204 @@
+const _ = require('lodash/fp')
+const crypto = require('crypto')
+const { utils: coinUtils } = require('@lamassu/coins')
+const prettyMs = require('pretty-ms')
+
+const {
+  CODES_DISPLAY,
+  NETWORK_DOWN_TIME,
+  PING,
+  ALERT_SEND_INTERVAL
+} = require('./codes')
+
+const DETAIL_TEMPLATE = {
+  deviceId: '',
+  cryptoCode: '',
+  code: '',
+  cassette: '',
+  age: '',
+  customerId: '',
+  cryptoAddress: '',
+  direction: '',
+  fiat: '',
+  fiatCode: ''
+}
+
+function parseEventNote (event) {
+  return _.set('note', JSON.parse(event.note), event)
+}
+
+function checkPing (device) {
+  const age = Date.now() - (new Date(device.lastPing).getTime())
+  if (age > NETWORK_DOWN_TIME) return [{ code: PING, age, machineName: device.name }]
+  return []
+}
+
+const getDeviceTime = _.flow(_.get('device_time'), Date.parse)
+
+const isActive = it => it.active && (it.balance || it.errors)
+
+const codeDisplay = code => CODES_DISPLAY[code]
+
+const alertFingerprint = {
+  fingerprint: null,
+  lastAlertTime: null
+}
+
+const getAlertFingerprint = () => alertFingerprint.fingerprint
+
+const getLastAlertTime = () => alertFingerprint.lastAlertTime
+
+const setAlertFingerprint = (fp, time = Date.now()) => {
+  alertFingerprint.fingerprint = fp
+  alertFingerprint.lastAlertTime = time
+}
+
+const shouldNotAlert = currentAlertFingerprint => {
+  return (
+    currentAlertFingerprint === getAlertFingerprint() &&
+    getLastAlertTime() - Date.now() < ALERT_SEND_INTERVAL
+  )
+}
+
+function buildAlertFingerprint (alertRec, notifications) {
+  const sms = getAlertTypes(alertRec, notifications.sms)
+  const email = getAlertTypes(alertRec, notifications.email)
+  if (sms.length === 0 && email.length === 0) return null
+
+  const smsTypes = _.map(codeDisplay, _.uniq(_.map('code', sms))).sort()
+  const emailTypes = _.map(codeDisplay, _.uniq(_.map('code', email))).sort()
+
+  const subject = _.concat(smsTypes, emailTypes).join(', ')
+  return crypto.createHash('sha256').update(subject).digest('hex')
+}
+
+function sendNoAlerts (plugins, smsEnabled, emailEnabled) {
+  const subject = '[Lamassu] All clear'
+
+  let rec = {}
+  if (smsEnabled) {
+    rec = _.set(['sms', 'body'])(subject)(rec)
+  }
+
+  if (emailEnabled) {
+    rec = _.set(['email', 'subject'])(subject)(rec)
+    rec = _.set(['email', 'body'])('No errors are reported for your machines.')(
+      rec
+    )
+  }
+
+  return plugins.sendMessage(rec)
+}
+
+const buildTransactionMessage = (tx, rec, highValueTx, machineName, customer) => {
+  const isCashOut = tx.direction === 'cashOut'
+  const direction = isCashOut ? 'Cash Out' : 'Cash In'
+  const crypto = `${coinUtils.toUnit(tx.cryptoAtoms, tx.cryptoCode)} ${
+    tx.cryptoCode
+  }`
+  const fiat = `${tx.fiat} ${tx.fiatCode}`
+  const customerName = customer.name || customer.id
+  const phone = customer.phone ? `- Phone: ${customer.phone}` : ''
+
+  let status = null
+  if (rec.error) {
+    status = `Error - ${rec.error}`
+  } else {
+    status = !isCashOut
+      ? 'Successful'
+      : !rec.isRedemption
+        ? 'Successful & awaiting redemption'
+        : 'Successful & dispensed'
+  }
+
+  const body = `
+  - Transaction ID: ${tx.id}
+  - Status: ${status}
+  - Machine name: ${machineName} 
+  - ${direction}
+  - ${fiat}
+  - ${crypto}
+  - Customer: ${customerName}
+  ${phone}
+`
+  const smsSubject = `A ${highValueTx ? 'high value ' : ''}${direction.toLowerCase()} transaction just happened at ${machineName} for ${fiat}`
+  const emailSubject = `A ${highValueTx ? 'high value ' : ''}transaction just happened`
+
+  return [{
+    sms: {
+      body: `${smsSubject} – ${status}`
+    },
+    email: {
+      emailSubject,
+      body
+    },
+    webhook: {
+      topic: `New transaction`,
+      content: body
+    }
+  }, highValueTx]
+}
+
+function formatCurrency (num = 0, code) {
+  const formattedNumber = Number(num).toLocaleString(undefined, {maximumFractionDigits:2, minimumFractionDigits:2})
+  return `${formattedNumber} ${code}`
+}
+
+function formatAge (age, settings) {
+  return prettyMs(age, settings)
+}
+
+function buildDetail (obj) {
+  // obj validation
+  const objKeys = _.keys(obj)
+  const detailKeys = _.keys(DETAIL_TEMPLATE)
+  if ((_.difference(objKeys, detailKeys)).length > 0) {
+    return Promise.reject(new Error('Error when building detail object: invalid properties'))
+  }
+  return { ...DETAIL_TEMPLATE, ...obj }
+}
+
+function deviceAlerts (config, alertRec, device) {
+  let alerts = []
+  if (config.balance) {
+    alerts = _.concat(alerts, alertRec.devices[device].balanceAlerts)
+  }
+
+  if (config.errors) {
+    alerts = _.concat(alerts, alertRec.devices[device].deviceAlerts)
+  }
+  return alerts
+}
+
+function getAlertTypes (alertRec, config) {
+  let alerts = []
+  if (!isActive(config)) return alerts
+
+  if (config.balance) {
+    alerts = _.concat(alerts, alertRec.general)
+  }
+
+  _.forEach(device => {
+    alerts = _.concat(alerts, deviceAlerts(config, alertRec, device))
+  }, _.keys(alertRec.devices))
+  return alerts
+}
+
+module.exports = {
+  codeDisplay,
+  parseEventNote,
+  getDeviceTime,
+  checkPing,
+  isActive,
+  getAlertFingerprint,
+  getLastAlertTime,
+  setAlertFingerprint,
+  shouldNotAlert,
+  buildAlertFingerprint,
+  sendNoAlerts,
+  buildTransactionMessage,
+  formatCurrency,
+  formatAge,
+  buildDetail,
+  deviceAlerts
+}

packages/server/lib/notifier/webhook.js

@@ -0,0 +1,21 @@
+const axios = require('axios')
+const _ = require('lodash/fp')
+const uuid = require('uuid')
+
+const WEBHOOK_URL = process.env.WEBHOOK_URL
+
+const sendMessage = (settings, rec) => {
+  if (_.isEmpty(WEBHOOK_URL)) return Promise.resolve()
+
+  const body = _.merge(rec.webhook, { id: uuid.v4() })
+
+  return axios({
+    method: 'POST',
+    url: WEBHOOK_URL,
+    data: body
+  })
+}
+
+module.exports = {
+  sendMessage
+}