@tasenor/common-node 1.9.16

package/src/commands/balance.ts

@@ -0,0 +1,131 @@
+/* eslint-disable camelcase */
+import { sprintf } from 'sprintf-js'
+import { Command } from '.'
+import { ArgumentParser } from 'argparse'
+import { AccountNumber, Asset, DocumentModelData, EntryModelData, log, PeriodModelData, StockValueData, warning } from '@dataplug/tasenor-common'
+import clone from 'clone'
+
+class BalanceCommand extends Command {
+
+  addArguments(parser: ArgumentParser): void {
+    const sub = parser.add_subparsers()
+
+    const ls = sub.add_parser('ls', { help: 'List account balances' })
+    ls.set_defaults({ subCommand: 'ls' })
+    ls.add_argument('db', { help: 'Name of the database' })
+    ls.add_argument('period', { help: 'Period year, date or ID' })
+
+    const create = sub.add_parser('create', { help: 'Initialize account balances' })
+    create.set_defaults({ subCommand: 'create' })
+    create.add_argument('--force', '-f', { action: 'store_true', help: 'If given, allow invalid entries to be created', required: false })
+    create.add_argument('--map', { help: 'Remap account numbers using JSON or @filepath mapping', required: false })
+    create.add_argument('--stock', { nargs: '*', help: 'Define initial stock using JSON or @filepath mapping', required: false })
+    create.add_argument('--text', { help: 'A description for the transaction', required: false })
+    create.add_argument('db', { help: 'Name of the database' })
+    create.add_argument('data', { help: 'A JSON data or @filepath for balances' })
+  }
+
+  async ls() {
+    const { db, period, verbose } = this.args
+    const periodId = await this.periodId(db, period)
+    const resp: PeriodModelData = await this.get(`/db/${db}/period/${periodId}`)
+    await this.readAccounts(db)
+    if (!verbose && resp.balances) {
+      this.out('balance', resp.balances.reduce((prev, cur) => ({ ...prev, [cur.number as string]: cur.total }), {}))
+      return
+    }
+    this.out('balance', resp)
+  }
+
+  print(data: Record<AccountNumber, number>) {
+    Object.keys(data).sort().forEach(number => {
+      console.log(number, this.accounts[number].name, '\t', sprintf('%.2f', data[number] / 100))
+    })
+  }
+
+  async create() {
+    const { db, data, map, stock, text, force } = this.args
+    if (!db) {
+      throw new Error(`Invalid database argument ${JSON.stringify(db)}`)
+    }
+
+    const dataArg: Record<AccountNumber, number> = await this.jsonData(data) as Record<AccountNumber, number>
+    const mapArg: Record<AccountNumber, AccountNumber> = (map ? await this.jsonData(map) : {}) as Record<AccountNumber, AccountNumber>
+    const period: PeriodModelData = await this.singlePeriod(db)
+    const stockArg: Record<AccountNumber, Partial<Record<Asset, StockValueData>>> = await this.jsonData(stock) as Record<AccountNumber, Partial<Record<Asset, StockValueData>>>
+
+    // Check if the DB is clean.
+    const docs: DocumentModelData[] = await this.get(`/db/${db}/document`)
+    if (docs.filter(d => d.number !== 0).length && !force) {
+      throw new Error('There are already non-initial transactions in the database and cannot be initialized anymore.')
+    }
+    // Ensure zero balance.
+    const sum = Object.values(dataArg).reduce((prev: number, cur: number) => prev + cur, 0)
+    if (sum) {
+      if (force) {
+        warning(`Initial balance total must be zero. Got ${sum} from ${JSON.stringify(dataArg)}.`)
+      } else {
+        throw new Error(`Initial balance total must be zero. Got ${sum} from ${JSON.stringify(dataArg)}.`)
+      }
+    }
+
+    // Ensure all accounts are valid.
+    for (const account of Object.keys(dataArg)) {
+      // Zero balance accounts not needed.
+      if (!dataArg[account]) {
+        continue
+      }
+      await this.accountId(db, mapArg[account] || account)
+    }
+
+    // Create initial doc.
+    const document: DocumentModelData = (docs.length > 0)
+      ? docs[0]
+      : await this.post(`/db/${db}/document`, {
+        period_id: period.id,
+        date: this.date(period.start_date),
+        number: 0
+      })
+    log(`Created a document #${document.id} on ${period.start_date}.`)
+    // Create entries.
+    const description = this.str(text) || 'Initial balance'
+    for (const account of Object.keys(dataArg)) {
+      const destAccount = mapArg[account] || account
+
+      // Skip zeroes.
+      if (!dataArg[account]) {
+        log(`Skipping an entry ${destAccount} ${description} ${sprintf('%.2f', 0)}.`)
+        continue
+      }
+      const entry: EntryModelData = {
+        document_id: document.id,
+        account_id: await this.accountId(db, destAccount),
+        debit: dataArg[account] >= 0 ? 1 : 0,
+        amount: Math.abs(dataArg[account]),
+        description
+      }
+      // Add stock if given.
+      if (stockArg[destAccount]) {
+        entry.data = {
+          stock: {
+            set: clone(stockArg[destAccount])
+          }
+        }
+        delete stockArg[destAccount]
+      }
+      // Add data if known.
+      const out: EntryModelData = await this.post(`/db/${db}/entry`, entry as unknown as Record<string, unknown>)
+      log(`Created an entry #${out.id} for ${destAccount} ${description} ${sprintf('%.2f', dataArg[account] / 100)}${entry.data ? ' ' + JSON.stringify(entry.data) : ''}.`)
+    }
+
+    if (Object.keys(stockArg).length) {
+      throw new Error(`Unused initial stocks for accounts ${Object.keys(stockArg).join(', ')}`)
+    }
+  }
+
+  async run() {
+    await this.runBy('subCommand')
+  }
+}
+
+export default BalanceCommand

package/src/commands/db.ts

@@ -0,0 +1,84 @@
+import { DatabaseModelData, FilePath, log } from '@dataplug/tasenor-common'
+import { ArgumentParser } from 'argparse'
+import fs from 'fs'
+import { Command } from '.'
+
+class DbCommand extends Command {
+
+  addArguments(parser: ArgumentParser): void {
+    const sub = parser.add_subparsers()
+
+    const ls = sub.add_parser('ls', { help: 'List all databases' })
+    ls.set_defaults({ subCommand: 'ls' })
+
+    const create = sub.add_parser('create', { help: 'Create a database' })
+    create.set_defaults({ subCommand: 'create' })
+    create.add_argument('scheme', { help: 'Bookkeeping scheme plugin code' })
+    create.add_argument('databaseName', { help: 'Name of the new database' })
+    create.add_argument('companyName', { nargs: '?', help: 'Name of the company (optional)' })
+    create.add_argument('companyCode', { nargs: '?', help: 'Registration code of the company (optional)' })
+    create.add_argument('language', { nargs: '?', help: 'Database language (optional)' })
+    create.add_argument('currency', { nargs: '?', help: 'Currency (optional)' })
+
+    const rm = sub.add_parser('rm', { help: 'Delete a database' })
+    rm.set_defaults({ subCommand: 'rm' })
+    rm.add_argument('databaseName', { help: 'Name of the database' })
+
+    const upload = sub.add_parser('upload', { help: 'Upload a database' })
+    upload.set_defaults({ subCommand: 'upload' })
+    upload.add_argument('path', { help: 'Path to the file to upload' })
+
+    const download = sub.add_parser('download', { help: 'Download a database' })
+    download.set_defaults({ subCommand: 'download' })
+    download.add_argument('databaseName', { help: 'Name of the database' })
+    download.add_argument('path', { help: 'Path to the file to save' })
+  }
+
+  async ls() {
+    const resp = await this.get('/db')
+    this.out('db', resp)
+  }
+
+  print(data: DatabaseModelData[]): void {
+    for (const db of data) {
+      console.log(db.name)
+    }
+  }
+
+  async rm() {
+    const { databaseName } = this.args
+    await this.delete(`/db/${databaseName}`)
+    log(`Database ${databaseName} deleted successfully.`)
+  }
+
+  async create() {
+    const { scheme, databaseName, companyName, companyCode, language, currency } = this.args
+    const settings = {
+      language, currency
+    }
+    const params = { scheme, databaseName, companyName, companyCode, settings }
+    await this.post('/db', params)
+    log(`Database ${databaseName} created successfully.`)
+  }
+
+  async upload() {
+    const { path } = this.args
+    if (!path || !fs.existsSync(this.str(path))) {
+      throw new Error(`File path ${path} does not exist.`)
+    }
+    await this.postUpload('/db/upload', path as FilePath)
+    log(`Database ${path} uploaded successfully.`)
+  }
+
+  async download() {
+    const { path, databaseName } = this.args
+    await this.getDownload(`/db/${databaseName}/download`, this.str(path) as FilePath)
+    log(`Database ${databaseName} downloaded successfully and saved to ${path}.`)
+  }
+
+  async run() {
+    await this.runBy('subCommand')
+  }
+}
+
+export default DbCommand

package/src/commands/entry.ts

@@ -0,0 +1,117 @@
+/* eslint-disable camelcase */
+import { sprintf } from 'sprintf-js'
+import { Command } from '.'
+import { ArgumentParser } from 'argparse'
+import { EntryModelData, log } from '@dataplug/tasenor-common'
+
+class EntryCommand extends Command {
+
+  addArguments(parser: ArgumentParser): void {
+    const sub = parser.add_subparsers()
+
+    const ls = sub.add_parser('ls', { help: 'Find entries matching the filter' })
+    ls.set_defaults({ subCommand: 'ls' })
+    ls.add_argument('--account', { help: 'Match to this account number', required: false })
+    ls.add_argument('--text', { help: 'Match to this exact description', required: false })
+    ls.add_argument('--period', { help: 'Match to period with this date/year/id', required: false })
+    ls.add_argument('db', { help: 'Name of the database' })
+
+    const edit = sub.add_parser('edit', { help: 'Change entries matching the filter' })
+    edit.set_defaults({ subCommand: 'edit' })
+    edit.add_argument('--account', { help: 'Match to this account number', required: false })
+    edit.add_argument('--text', { help: 'Match to this exact description', required: false })
+    edit.add_argument('--period', { help: 'Match to period with this date/year/id', required: false })
+    edit.add_argument('db', { help: 'Name of the database' })
+    edit.add_argument('data', { help: 'JSON data for patching the entry' })
+
+    const rm = sub.add_parser('rm', { help: 'Remove entries matching the filter' })
+    rm.set_defaults({ subCommand: 'rm' })
+    rm.add_argument('--account', { help: 'Match to this account number', required: false })
+    rm.add_argument('--text', { help: 'Match to this exact description', required: false })
+    rm.add_argument('--period', { help: 'Match to period with this date/year/id', required: false })
+    rm.add_argument('--all', { help: 'Delete the whole transaction that includes the matching line.', action: 'store_true', required: false })
+    rm.add_argument('db', { help: 'Name of the database' })
+  }
+
+  async filter(): Promise<EntryModelData[]> {
+    const { db, account, text, period } = this.args
+    await this.readAccounts(db)
+    const query: string[] = []
+    if (account) {
+      const id = await this.accountId(db, account)
+      query.push(`account_id=${id}`)
+    }
+    if (text) {
+      query.push(`text=${encodeURIComponent(text as string)}`)
+    }
+    if (period) {
+      const id = await this.periodId(db, period)
+      query.push(`period_id=${id}`)
+    }
+    return this.get(`/db/${db}/entry${query.length ? '?' + query.join('&') : ''}`)
+  }
+
+  async ls() {
+    const resp = await this.filter()
+    this.out('entry', resp)
+  }
+
+  print(data: EntryModelData[]): void {
+    for (const entry of data) {
+      const { id, account_id, debit, amount, description } = entry
+      console.log(`#${id} ${this.accountsById[account_id || -1].number} ${this.accountsById[account_id || -1].name}`)
+      console.log('    ', sprintf('%.2f', debit ? amount / 100 : amount / -100), '\t', description)
+      if (entry.data && Object.keys(entry.data).length) {
+        console.log('    ', JSON.stringify(entry.data))
+      }
+    }
+  }
+
+  async edit() {
+    const { db, data } = this.args
+    const params = await this.jsonData(data)
+    for (const key of Object.keys(params)) {
+      switch (key) {
+        case 'data':
+        case 'description':
+          break
+        case 'account':
+          params.account_id = await this.accountId(db, `${params[key]}`)
+          delete params.account
+          break
+        default:
+          throw new Error(`No handler yet for entry data '${key}'.`)
+      }
+    }
+    const resp: EntryModelData[] = await this.filter()
+    for (const entry of resp) {
+      const newParams = { ...params, data: Object.assign({}, entry.data, params.data) }
+      log(`Changing entry #${entry.id} to have ${JSON.stringify(newParams)}`)
+      await this.patch(`/db/${db}/entry/${entry.id}`, newParams)
+    }
+  }
+
+  async rm() {
+    const { db } = this.args
+    const resp: EntryModelData[] = await this.filter()
+    if (this.args.all) {
+      const docIds = new Set()
+      for (const entry of resp) {
+        docIds.add(entry.document_id)
+      }
+      for (const id of docIds) {
+        await this.delete(`/db/${db}/document/${id}`)
+      }
+    } else {
+      for (const entry of resp) {
+        await this.delete(`/db/${db}/entry/${entry.id}`)
+      }
+    }
+  }
+
+  async run() {
+    await this.runBy('subCommand')
+  }
+}
+
+export default EntryCommand

package/src/commands/import.ts

@@ -0,0 +1,160 @@
+/* eslint-disable camelcase */
+import fs from 'fs'
+import mime from 'mime-types'
+import { Command } from '.'
+import { ArgumentParser } from 'argparse'
+import { ImportState, ProcessConfig, ProcessModelData, ProcessStepModelData, RuleEditorElement, TransactionDescription, error, log } from '@dataplug/tasenor-common'
+
+type ProcessPostResponse = { processId: number, step: number, status: string }
+type ProcessGetResponse = { steps: ProcessStepModelData[] }
+
+class ImportCommand extends Command {
+
+  addArguments(parser: ArgumentParser): void {
+    const sub = parser.add_subparsers()
+
+    const ls = sub.add_parser('ls', { help: 'List all imports' })
+    ls.set_defaults({ subCommand: 'ls' })
+    ls.add_argument('db', { help: 'Name of the database' })
+    ls.add_argument('name', { help: 'Name of the importer' })
+
+    const show = sub.add_parser('show', { help: 'Display import process in detail' })
+    show.set_defaults({ subCommand: 'show' })
+    show.add_argument('db', { help: 'Name of the database' })
+    show.add_argument('name', { help: 'Name of the importer' })
+    show.add_argument('id', { help: 'Import number' })
+
+    const create = sub.add_parser('create', { help: 'Import a file' })
+    create.set_defaults({ subCommand: 'create' })
+    create.add_argument('--first', { help: 'First date of the allowed period YYYY-MM-DD', default: '1900-01-01' })
+    create.add_argument('--last', { help: 'Final date of the allowed period YYYY-MM-DD', default: '2999-12-31' })
+    create.add_argument('--answers', { help: 'Answer file', required: false })
+    create.add_argument('db', { help: 'Name of the database' })
+    create.add_argument('name', { help: 'Name of the importer' })
+    create.add_argument('file', { help: 'Path to the file(s) to import', nargs: '+' })
+  }
+
+  async ls() {
+    const { db, name } = this.args
+    const importer = await this.importer(db, name)
+    const resp = await this.get(`/db/${db}/import/${importer.id}`)
+    this.out('import', resp)
+  }
+
+  async show() {
+    const { db, name, id } = this.args
+    const importer = await this.importer(db, name)
+    const resp = await this.get(`/db/${db}/import/${importer.id}/process/${id}`) as ProcessGetResponse
+
+    const steps: (ProcessStepModelData & { state: ImportState})[] = []
+
+    for (const step of resp.steps) {
+      const resp = await this.get(`/db/${db}/import/${importer.id}/process/${id}/step/${step.number}`) as { state: ImportState }
+      steps.push({ ...step, state: resp.state as ImportState })
+    }
+
+    for (const step of steps) {
+      if (step.directions && step.directions.element) {
+        const element: RuleEditorElement = step.directions.element as RuleEditorElement
+        if (element.config) {
+          element.config = '* * * config * * *' as unknown as ProcessConfig
+        }
+      }
+    }
+
+    if (this.args.json) {
+      this.out('import', steps)
+    } else {
+      for (const step of steps) {
+        const state = step.state
+        console.log()
+        console.log(`Step #${step.number}`)
+        console.log('Action:', step.action)
+        console.log('Direction:', step.directions && step.directions.type)
+        console.log('State:')
+        console.log(`  Files: ${Object.keys(state.files).join(', ')}`)
+        console.log(`  Stage: ${state.stage}`)
+        if (state.output) {
+          console.log('  Output:', state.output)
+        }
+        if (state.segments) {
+          console.log(`  Segments: ${Object.keys(state.segments).join(', ')}`)
+        }
+        if (state.result !== undefined) {
+          console.log('  Results:')
+          Object.keys(state.result).forEach(segmentId => {
+            console.log(`=== ${segmentId} ===`)
+            const result: TransactionDescription = state.result as TransactionDescription
+            console.dir(result[segmentId], { depth: null })
+          })
+        }
+        // console.log()
+        // console.log(step.state)
+        // console.log()
+      }
+    }
+
+  }
+
+  async create() {
+    const { db, name, file, answers, first, last } = this.args
+    const importer = await this.importer(db, name)
+    const encoding = 'base64'
+    const files: Record<string, string>[] = []
+    for (const filePath of (file || [])) {
+      const data = fs.readFileSync(filePath).toString(encoding)
+      files.push({
+        name: filePath,
+        encoding,
+        type: mime.lookup(filePath),
+        data
+      })
+    }
+    const answersArg = answers ? await this.jsonData(answers) : null
+
+    const resp: ProcessPostResponse = await this.post(`/db/${db}/importer/${importer.id}`, {
+      firstDate: first,
+      lastDate: last,
+      files
+    })
+    this.out('import', resp)
+
+    if (answersArg) {
+      log(`Uploading answers to process #${resp.processId}`)
+      const resp2 = await this.post(`/db/${db}/import/${importer.id}/process/${resp.processId}`, {
+        answer: answersArg
+      })
+      this.out('import', resp2)
+    }
+  }
+
+  print(data: ProcessModelData[] | ProcessPostResponse) {
+    if ('processId' in data && 'step' in data) {
+      log(`Process ID: ${data.processId}, Step: ${data.step}, ${data.status}`)
+      return
+    }
+    if ('processId' in data && 'status' in data && data.length === undefined) {
+      if (data.status === 'CRASHED') {
+        error(`Process ID: ${data.processId}, ${data.status}`)
+      } else {
+        log(`Process ID: ${data.processId}, ${data.status}`)
+      }
+      return
+    }
+    for (const imp of data.sort((a, b) => (a.id || 0) - (b.id || 0))) {
+      const { id, name, status, error } = imp
+      console.log(`#${id} ${name} ${status}`)
+      if (error) {
+        console.log('  ', error)
+      }
+      console.log()
+    }
+
+  }
+
+  async run() {
+    await this.runBy('subCommand')
+  }
+}
+
+export default ImportCommand

package/src/commands/importer.ts

@@ -0,0 +1,84 @@
+/* eslint-disable camelcase */
+import { ImporterModelData, log } from '@dataplug/tasenor-common'
+import { Command } from '.'
+import { ArgumentParser } from 'argparse'
+
+class ImporterCommand extends Command {
+
+  addArguments(parser: ArgumentParser): void {
+    const sub = parser.add_subparsers()
+
+    const ls = sub.add_parser('ls', { help: 'List all importers' })
+    ls.set_defaults({ subCommand: 'ls' })
+    ls.add_argument('db', { help: 'Name of the database' })
+
+    const create = sub.add_parser('create', { help: 'Create an importer' })
+    create.set_defaults({ subCommand: 'create' })
+    create.add_argument('db', { help: 'Name of the database' })
+    create.add_argument('name', { help: 'Name of the importer' })
+    create.add_argument('plugin', { help: 'Code of the import handler plugin' })
+
+    const set = sub.add_parser('set', { help: 'Set configuration variable for an importer' })
+    set.set_defaults({ subCommand: 'set' })
+    set.add_argument('db', { help: 'Name of the database' })
+    set.add_argument('name', { help: 'The name of the importer' })
+    set.add_argument('variable', { help: 'Name of the configuration variable' })
+    set.add_argument('value', { help: 'Value for the configuration variable' })
+
+    const config = sub.add_parser('config', { help: 'Set whole configuration for an importer' })
+    config.set_defaults({ subCommand: 'config' })
+    config.add_argument('db', { help: 'Name of the database' })
+    config.add_argument('name', { help: 'The name of the importer' })
+    config.add_argument('config', { help: 'JSON data or @filepath for configuration' })
+  }
+
+  async ls() {
+    const { db } = this.args
+    const resp = await this.get(`/db/${db}/importer`)
+    this.out('importer', resp)
+  }
+
+  print(data: ImporterModelData[]): void {
+    for (const importer of data.sort((a, b) => (a.id || 0) - (b.id || 0))) {
+      const { id, name, config } = importer
+      console.log(`#${id} ${name}`)
+      if (config.rules) {
+        config.rules = '...skipped...'
+      }
+      console.dir(config, { depth: null })
+      console.log()
+    }
+  }
+
+  async create() {
+    const { db, name, plugin } = this.args
+    await this.plugin(plugin)
+    const code = this.str(plugin)
+    await this.post(`/db/${db}/importer`, { name, config: { handlers: [code] } })
+    log(`Importer ${name} created successfully.`)
+  }
+
+  async set() {
+    const { db, name, variable, value } = this.args
+    const importer = await this.importer(db, name)
+    const variableArg = this.str(variable)
+    const valueArg = this.value(value)
+    await this.patch(`/db/${db}/importer/${importer.id}`, { config: { [variableArg]: valueArg } })
+    const newImporter: ImporterModelData = await this.get(`/db/${db}/importer/${importer.id}`)
+    log(`Variable ${variableArg} set to ${JSON.stringify(newImporter.config[variableArg])}`)
+  }
+
+  async config() {
+    const { db, name, config } = this.args
+    const importer = await this.importer(db, name)
+    const configArg = await this.jsonData(config)
+    await this.patch(`/db/${db}/importer/${importer.id}`, { config: configArg })
+    log(`Updated configuration for importer ${name}`)
+  }
+
+  async run() {
+    await this.runBy('subCommand')
+  }
+}
+
+export default ImporterCommand