improve config loading; remove debug

lib/config-validate.js

@@ -0,0 +1,150 @@
+const _ = require('lodash/fp')
+
+const configManager = require('./config-manager')
+const machines = require('./admin/machines')
+const schema = require('../lamassu-schema.json')
+
+function allScopes (cryptoScopes, machineScopes) {
+  const scopes = []
+  cryptoScopes.forEach(c => {
+    machineScopes.forEach(m => scopes.push([c, m]))
+  })
+
+  return scopes
+}
+
+function allCryptoScopes (cryptos, cryptoScope) {
+  const cryptoScopes = []
+
+  if (cryptoScope === 'global' || cryptoScope === 'both') cryptoScopes.push('global')
+  if (cryptoScope === 'specific' || cryptoScope === 'both') cryptos.forEach(r => cryptoScopes.push(r))
+
+  return cryptoScopes
+}
+
+function allMachineScopes (machineList, machineScope) {
+  const machineScopes = []
+
+  if (machineScope === 'global' || machineScope === 'both') machineScopes.push('global')
+  if (machineScope === 'specific' || machineScope === 'both') machineList.forEach(r => machineScopes.push(r))
+
+  return machineScopes
+}
+
+function satisfiesRequire (config, cryptos, machineList, field, refFields) {
+  const fieldCode = field.code
+
+  const scopes = allScopes(
+    allCryptoScopes(cryptos, field.cryptoScope),
+    allMachineScopes(machineList, field.machineScope)
+  )
+
+  return scopes.every(scope => {
+    const isEnabled = () => refFields.some(refField => {
+      return isScopeEnabled(config, cryptos, machineList, refField, scope)
+    })
+
+    const isBlank = () => _.isNil(configManager.scopedValue(scope[0], scope[1], fieldCode, config))
+    const isRequired = refFields.length === 0 || isEnabled()
+
+    return isRequired ? !isBlank() : true
+  })
+}
+
+function isScopeEnabled (config, cryptos, machineList, refField, scope) {
+  const [cryptoScope, machineScope] = scope
+  const candidateCryptoScopes = cryptoScope === 'global'
+  ? allCryptoScopes(cryptos, refField.cryptoScope)
+  : [cryptoScope]
+
+  const candidateMachineScopes = machineScope === 'global'
+  ? allMachineScopes(machineList, refField.machineScope)
+  : [ machineScope ]
+
+  const allRefCandidateScopes = allScopes(candidateCryptoScopes, candidateMachineScopes)
+  const getFallbackValue = scope => configManager.scopedValue(scope[0], scope[1], refField.code, config)
+  const values = allRefCandidateScopes.map(getFallbackValue)
+
+  return values.some(r => r)
+}
+
+function getCryptos (config, machineList) {
+  const scopes = allScopes(['global'], allMachineScopes(machineList, 'both'))
+  const scoped = scope => configManager.scopedValue(scope[0], scope[1], 'cryptoCurrencies', config)
+  return scopes.reduce((acc, scope) => _.union(acc, scoped(scope)), [])
+}
+
+function getGroup (fieldCode) {
+  return _.find(group => _.includes(fieldCode, group.fields), schema.groups)
+}
+
+function getField (group, fieldCode) {
+  if (!group) group = getGroup(fieldCode)
+  const field = _.find(_.matchesProperty('code', fieldCode), schema.fields)
+  return _.merge(_.pick(['cryptoScope', 'machineScope'], group), field)
+}
+
+const fetchMachines = () => machines.getMachines()
+.then(machineList => machineList.map(r => r.deviceId))
+
+function validateFieldParameter (value, validator) {
+  switch (validator.code) {
+    case 'required':
+      return true   // We don't validate this here
+    case 'min':
+      return value >= validator.min
+    case 'max':
+      return value <= validator.max
+    default:
+      throw new Error('Unknown validation type: ' + validator.code)
+  }
+}
+
+function ensureConstraints (config) {
+  const pickField = fieldCode => schema.fields.find(r => r.code === fieldCode)
+
+  return Promise.resolve()
+  .then(() => {
+    config.every(fieldInstance => {
+      const fieldCode = fieldInstance.fieldLocator.code
+      const field = pickField(fieldCode)
+      const fieldValue = fieldInstance.fieldValue
+
+      const isValid = field.fieldValidation
+      .every(validator => validateFieldParameter(fieldValue.value, validator))
+
+      if (isValid) return true
+      throw new Error('Invalid config value')
+    })
+  })
+}
+
+function validateRequires (config) {
+  return fetchMachines()
+  .then(machineList => {
+    const cryptos = getCryptos(config, machineList)
+
+    return schema.groups.filter(group => {
+      return group.fields.some(fieldCode => {
+        const field = getField(group, fieldCode)
+        if (!field.fieldValidation.find(r => r.code === 'required')) return false
+
+        const refFields = _.map(_.partial(getField, null), field.enabledIf)
+        return !satisfiesRequire(config, cryptos, machineList, field, refFields)
+      })
+    })
+  })
+  .then(arr => arr.map(r => r.code))
+}
+
+function validate (config) {
+  return Promise.resolve()
+  .then(() => ensureConstraints(config))
+  .then(() => validateRequires(config))
+  .then(arr => {
+    if (arr.length === 0) return config
+    throw new Error('Invalid configuration')
+  })
+}
+
+module.exports = {validate, ensureConstraints, validateRequires}