153 lines
3.4 KiB
JavaScript
153 lines
3.4 KiB
JavaScript
const path = require('path')
|
|
const fs = require('fs')
|
|
|
|
const _ = require('lodash/fp')
|
|
const argv = require('minimist')(process.argv.slice(2))
|
|
const pify = require('pify')
|
|
|
|
const db = require('./db')
|
|
const schema = require('../lamassu-schema.json')
|
|
|
|
const mapWithKey = _.map.convert({cap: false})
|
|
|
|
let settingsCache
|
|
|
|
function expandFixture (fixture) {
|
|
const deviceId = argv.machine
|
|
|
|
function findField (code) {
|
|
const field = _.find(_.matchesProperty('code', code), schema.fields)
|
|
const group = _.find(r => _.includes(code, r.fields), schema.groups)
|
|
|
|
if (!field || !group) {
|
|
throw new Error('No such field from fixture: ' + code)
|
|
}
|
|
|
|
return _.merge({cryptoScope: group.cryptoScope, machineScope: group.machineScope}, field)
|
|
}
|
|
|
|
function expand (value, code) {
|
|
const field = findField(code)
|
|
|
|
const machine = field.machineScope === 'specific'
|
|
? deviceId
|
|
: 'global'
|
|
|
|
const crypto = field.cryptoScope === 'specific'
|
|
? 'BTC'
|
|
: 'global'
|
|
|
|
return {
|
|
fieldLocator: {
|
|
fieldScope: {crypto, machine},
|
|
code,
|
|
fieldType: field.fieldType,
|
|
fieldClass: field.fieldClass
|
|
},
|
|
fieldValue: {
|
|
fieldType: field.fieldType,
|
|
value
|
|
}
|
|
}
|
|
}
|
|
|
|
return mapWithKey(expand, fixture)
|
|
}
|
|
|
|
function loadFixture () {
|
|
const fixture = argv.fixture
|
|
const deviceId = argv.machine
|
|
|
|
if (fixture && !deviceId) throw new Error('Missing --machine parameter for --fixture')
|
|
|
|
const fixturePath = fixture => path.resolve(__dirname, '..', 'test', 'fixtures', fixture + '.json')
|
|
|
|
const promise = fixture
|
|
? pify(fs.readFile)(fixturePath(fixture)).then(JSON.parse)
|
|
: Promise.resolve({})
|
|
|
|
return promise
|
|
.then(expandFixture)
|
|
}
|
|
|
|
function isEquivalentField (a, b) {
|
|
return _.isEqual(
|
|
[a.fieldLocator.code, a.fieldLocator.fieldScope],
|
|
[b.fieldLocator.code, b.fieldLocator.fieldScope]
|
|
)
|
|
}
|
|
|
|
// b overrides a
|
|
function mergeValues (a, b) {
|
|
return _.unionWith(isEquivalentField, b, a)
|
|
}
|
|
|
|
function load (versionId) {
|
|
if (!versionId) throw new Error('versionId is required')
|
|
|
|
return Promise.all([loadConfig(versionId), loadAccounts()])
|
|
.then(([config, accounts]) => ({
|
|
config,
|
|
accounts
|
|
}))
|
|
}
|
|
|
|
function loadLatest () {
|
|
return Promise.all([loadLatestConfig(), loadAccounts()])
|
|
.then(([config, accounts]) => ({
|
|
config,
|
|
accounts
|
|
}))
|
|
}
|
|
|
|
function loadConfig (versionId) {
|
|
if (argv.fixture) return loadFixture()
|
|
|
|
const sql = `select data
|
|
from user_config
|
|
where id=$1 and type=$2`
|
|
|
|
return db.oneOrNone(sql, [versionId, 'config'])
|
|
.then(row => row ? row.data.config : [])
|
|
}
|
|
|
|
function loadLatestConfig () {
|
|
const sql = `select data
|
|
from user_config
|
|
where type=$1
|
|
order by id desc
|
|
limit 1`
|
|
|
|
return db.oneOrNone(sql, ['config'])
|
|
.then(row => row ? row.data.config : [])
|
|
}
|
|
|
|
function loadAccounts () {
|
|
const toFields = fieldArr => _.fromPairs(_.map(r => [r.code, r.value], fieldArr))
|
|
const toPairs = r => [r.code, toFields(r.fields)]
|
|
|
|
return db.oneOrNone('select data from user_config where type=$1', 'accounts')
|
|
.then(function (data) {
|
|
if (!data) return {}
|
|
return _.fromPairs(_.map(toPairs, data.data.accounts))
|
|
})
|
|
}
|
|
|
|
function settings () {
|
|
return settingsCache
|
|
}
|
|
|
|
function save (config) {
|
|
const sql = 'insert into user_config (type, data) values ($1, $2)'
|
|
return db.none(sql, ['config', config])
|
|
}
|
|
|
|
module.exports = {
|
|
settings,
|
|
loadConfig,
|
|
load,
|
|
loadLatest,
|
|
save,
|
|
loadFixture,
|
|
mergeValues
|
|
}
|