@tasenor/common-node 1.9.16

package/src/commands/report.ts

@@ -0,0 +1,113 @@
+/* eslint-disable camelcase */
+import { sprintf } from 'sprintf-js'
+import { Command } from '.'
+import { ArgumentParser } from 'argparse'
+import { Report, ReportColumnDefinition } from '@dataplug/tasenor-common'
+
+class ReportCommand extends Command {
+
+  addArguments(parser: ArgumentParser): void {
+    const sub = parser.add_subparsers()
+
+    const ls = sub.add_parser('ls', { help: 'List of reports' })
+    ls.set_defaults({ subCommand: 'ls' })
+    ls.add_argument('db', { help: 'Name of the database' })
+
+    const view = sub.add_parser('view', { help: 'Show a report' })
+    view.set_defaults({ subCommand: 'view' })
+    view.add_argument('db', { help: 'Name of the database' })
+    view.add_argument('report', { help: 'Name of the report' })
+    view.add_argument('period', { help: 'Period year, date or ID' })
+    view.add_argument('options', { nargs: '*', help: 'Additinal report options for query as `key=value`' })
+  }
+
+  async ls() {
+    const { db } = this.args
+    const resp = await this.get(`/db/${db}/report`)
+    this.out('report', resp)
+  }
+
+  async view() {
+    const { db, period, report, options } = this.args
+    let query = ''
+    if (options?.length) {
+      query = '?' + (options as string[]).join('&')
+    }
+    const periodId = await this.periodId(db, period)
+    const resp = await this.get(`/db/${db}/report/${report}/${periodId}${query}`)
+    this.out('report', resp)
+  }
+
+  print(data: Record<string, unknown> | Report) {
+    if ('options' in data) {
+      Object.keys(data.options as Record<string, unknown>).forEach((opt) => console.log(opt))
+      return
+    }
+    if ('data' in data) {
+      const report = data as Report
+
+      // Header.
+      console.log()
+      console.log(report.format)
+      console.log()
+
+      // Meta data.
+      if ('meta' in data) {
+        Object.keys(report.meta as Record<string, unknown>).forEach((meta) => console.log(`${meta}: ${(report.meta as Record<string, unknown>)[meta]}`))
+        console.log()
+      }
+
+      // Collect data to tables.
+      const lines: string[][] = []
+      const columns: ReportColumnDefinition[] = (data as Report).columns || []
+
+      // Set up title line.
+      let line: string[] = []
+      for (const column of columns) {
+        line.push(column.title)
+      }
+      lines.push(line)
+
+      // Render each report line.
+      for (const item of report.data) {
+        line = []
+        for (const column of columns) {
+          const text = {
+            id: () => item.id,
+            name: () => item.name,
+            numeric: () => item.amounts && item.amounts[column.name] !== undefined && sprintf('%.2f', (item.amounts[column.name] || 0) / 100)
+          }[column.type]()
+          line.push(text || '')
+        }
+        lines.push(line)
+      }
+
+      // Find the longest line per column.
+      const spaces: string[] = columns.map(() => '')
+      for (let i = 0; i < lines.length; i++) {
+        for (let j = 0; j < columns.length; j++) {
+          if (lines[i][j].length > spaces[j].length) {
+            spaces[j] = lines[i][j].replace(/./g, ' ')
+          }
+        }
+      }
+
+      // Display.
+      for (let i = 0; i < lines.length; i++) {
+        let str = ''
+        for (let j = 0; j < columns.length; j++) {
+          str += (lines[i][j] + spaces[j] + ' ').substr(0, spaces[j].length + 1)
+        }
+        console.log(str)
+      }
+      return
+    }
+    throw new Error('Default output not implented.')
+  }
+
+  async run() {
+    await this.runBy('subCommand')
+  }
+}
+
+export default ReportCommand

package/src/commands/settings.ts

@@ -0,0 +1,75 @@
+/* eslint-disable camelcase */
+import { Command } from '.'
+import { ArgumentParser } from 'argparse'
+import { log, needHiding } from '@dataplug/tasenor-common'
+
+class SettingsCommand extends Command {
+
+  addArguments(parser: ArgumentParser): void {
+    const sub = parser.add_subparsers()
+
+    const ls = sub.add_parser('ls', { help: 'List all settings' })
+    ls.set_defaults({ subCommand: 'ls' })
+    ls.add_argument('--all', '-a', { help: 'Show all UI configurations and other extras.', action: 'store_true', required: false })
+    ls.add_argument('db', { help: 'Name of the database', nargs: '?' })
+
+    const set = sub.add_parser('set', { help: 'Change a settings' })
+    set.set_defaults({ subCommand: 'set' })
+    set.add_argument('dest', { help: 'Name of the database, name of the plugin  or `system`' })
+    set.add_argument('key', { help: 'Name of the setting' })
+    set.add_argument('value', { help: 'New value for the setting' })
+  }
+
+  async ls() {
+    const { db, all } = this.args
+    const resp = db ? await this.get(`/db/${db}/settings`) : null
+    const resp2 = await this.get('/system/settings')
+    const resp3: Record<string, Record<string, unknown>> = await this.get('/system/settings/plugins')
+    const pluginSettings = {}
+
+    Object.keys(resp3).forEach(plugin => {
+      pluginSettings[plugin] = all ? resp3[plugin] : resp3[plugin].settings
+    })
+
+    this.out('settings', db
+      ? {
+          db: resp,
+          system: resp2,
+          plugin: pluginSettings
+        }
+      : {
+          system: resp2,
+          plugins: pluginSettings
+        })
+  }
+
+  print(data): void {
+    console.dir(data, { depth: null })
+  }
+
+  async set() {
+    const { dest, key, value } = this.args
+    const valueArg = await this.value(value)
+    const keyArg = this.str(key)
+    const destArg = this.str(dest)
+    if (destArg === 'system') {
+      log(`Setting system variable ${keyArg} to ${JSON.stringify(valueArg)}.`)
+      await this.patch('/system/settings', { [keyArg]: valueArg })
+      return
+    }
+    const resp: Record<string, unknown> = await this.get('/system/settings/plugins')
+    if (destArg in resp) {
+      log(`Setting plugin ${destArg} setting ${keyArg} to ${needHiding(keyArg) ? '*******' : JSON.stringify(valueArg)}.`)
+      await this.patch('/system/settings/plugins', { [`${destArg}.${keyArg}`]: valueArg })
+      return
+    }
+    log(`Setting database ${destArg} setting ${keyArg} to ${JSON.stringify(valueArg)}.`)
+    await this.patch(`/db/${destArg}/settings`, { [keyArg]: valueArg })
+  }
+
+  async run() {
+    await this.runBy('subCommand')
+  }
+}
+
+export default SettingsCommand

package/src/commands/stock.ts

@@ -0,0 +1,80 @@
+/* eslint-disable camelcase */
+import { sprintf } from 'sprintf-js'
+import { Command } from '.'
+import { ArgumentParser } from 'argparse'
+import { AccountNumber, Asset, DocumentModelData, EntryModelData, log, PeriodModelData, StockValueData } from '@dataplug/tasenor-common'
+
+class StockCommand extends Command {
+
+  addArguments(parser: ArgumentParser): void {
+    const sub = parser.add_subparsers()
+
+    const create = sub.add_parser('create', { help: 'Create initial stock' })
+    create.set_defaults({ subCommand: 'create' })
+    create.add_argument('db', { help: 'Name of the database' })
+    create.add_argument('data', { help: 'A JSON data or @filepath for initial stock data' })
+  }
+
+  async create() {
+    const { db, data } = this.args
+    if (!db) {
+      throw new Error(`Invalid database argument ${JSON.stringify(db)}`)
+    }
+    const dataArg: Record<AccountNumber, Partial<Record<Asset, StockValueData>>> = await this.jsonData(data) as Record<AccountNumber, Partial<Record<Asset, StockValueData>>>
+    const period: PeriodModelData = await this.singlePeriod(db)
+    const docs: DocumentModelData[] = await this.get(`/db/${db}/document?period=${period.id}&entries`)
+    const zeroTx = docs.filter(doc => doc.number === 0)
+    if (!zeroTx.length) {
+      throw new Error('Cannot set stock unless there is 0-transaction for initial balances defined.')
+    }
+    if (!zeroTx[0].entries) {
+      throw new Error('Cannot set stock unless there are entries in 0-transaction for initial balances.')
+    }
+    // Get map of indexes in entry list for existing accounts.
+    const entryIndex: Record<number, number> = {}
+    let i = 0
+    for (const entry of zeroTx[0].entries) {
+      if (entry.account_id) {
+        entryIndex[entry.account_id] = i++
+      }
+    }
+    // Prepare and create missing entries for stock data upates.
+    for (const account of Object.keys(dataArg)) {
+      const accountId = await this.accountId(db, account)
+      if (accountId && !entryIndex[accountId]) {
+        const newEntry: EntryModelData = await this.post(`/db/${db}/entry`, {
+          document_id: zeroTx[0].id,
+          account_id: accountId,
+          debit: 1,
+          amount: 0,
+          description: zeroTx[0].entries[0].description
+        })
+        log(`Created an entry #${newEntry.id} for ${account} ${zeroTx[0].entries[0].description} ${sprintf('%.2f', 0)}.`)
+
+        zeroTx[0].entries.push(newEntry)
+        entryIndex[accountId] = zeroTx[0].entries.length - 1
+      }
+    }
+    // Update stock data.
+    for (const account of Object.keys(dataArg)) {
+      const accountId = await this.accountId(db, account)
+      if (accountId) {
+        const entry = zeroTx[0].entries[entryIndex[accountId]]
+        entry.data = entry.data || {}
+        Object.assign(entry.data, {
+          stock: {
+            set: dataArg[account]
+          }
+        })
+        await this.patch(`/db/${db}/entry/${entry.id}`, { data: entry.data })
+        log(`Updated initial stock data for entry #${entry.id}.`)
+      }
+    }
+  }
+
+  async run() {
+    await this.runBy('subCommand')
+  }
+}
+
+export default StockCommand

package/src/commands/tag.ts

@@ -0,0 +1,102 @@
+/* eslint-disable camelcase */
+import fs from 'fs'
+import mimeTypes from 'mime-types'
+import { log, TagModelData } from '@dataplug/tasenor-common'
+import { Command } from '.'
+import { ArgumentParser } from 'argparse'
+
+class TagCommand extends Command {
+
+  addArguments(parser: ArgumentParser): void {
+    const sub = parser.add_subparsers()
+
+    const ls = sub.add_parser('ls', { help: 'List all tags' })
+    ls.set_defaults({ subCommand: 'ls' })
+    ls.add_argument('db', { help: 'Name of the database' })
+    ls.add_argument('--tags-only', { help: 'Show only tags', action: 'store_true', required: false })
+
+    const download = sub.add_parser('download', { help: 'Download a tag image' })
+    download.set_defaults({ subCommand: 'download' })
+    download.add_argument('db', { help: 'Name of the database' })
+    download.add_argument('tag', { help: 'Name of the tag' })
+
+    const rm = sub.add_parser('rm', { help: 'Delete a tag' })
+    rm.set_defaults({ subCommand: 'rm' })
+    rm.add_argument('db', { help: 'Name of the database' })
+    rm.add_argument('id', { help: 'ID of the tag' })
+
+    const create = sub.add_parser('create', { help: 'Create a tag' })
+    create.set_defaults({ subCommand: 'create' })
+    create.add_argument('db', { help: 'Name of the database' })
+    create.add_argument('tag', { help: 'Tag itself' })
+    create.add_argument('name', { help: 'Description' })
+    create.add_argument('type', { help: 'Group name of the tag' })
+    create.add_argument('path', { help: 'Path to the file' })
+    create.add_argument('order', { help: 'Ordering number for the tag', nargs: '?' })
+  }
+
+  async ls() {
+    const { db, tags_only } = this.args
+    const resp: TagModelData[] = await this.get(`/db/${db}/tags`)
+    if (tags_only) {
+      for (const tag of resp.map(t => t.tag)) {
+        console.log(tag)
+      }
+    } else {
+      this.out('tag', resp)
+    }
+  }
+
+  print(data: TagModelData[]): void {
+    for (const line of data.sort((a, b) => (a.id || 0) - (b.id || 0))) {
+      const { id, tag, name, mime, type, order } = line
+      console.log(`#${id} ${tag}\t${name}\t${mime}\t${type}\t${order}`)
+    }
+  }
+
+  async rm() {
+    const { db, id } = this.args
+    await this.delete(`/db/${db}/tags/${id}`)
+    log(`Tag ${id} deleted successfully.`)
+  }
+
+  async download() {
+    const { db, tag } = this.args
+    const tagArg = await this.tag(db, tag)
+    const name = `${tagArg.tag}.${(tagArg.mime || '/bin').split('/')[1]}`
+    const data = Buffer.from(tagArg.picture || '', 'base64')
+    fs.writeFileSync(name, data)
+    log(`Saved a tag to file ${name}.`)
+  }
+
+  async create() {
+    const { db, tag, name, path, type } = this.args
+    if (!path || !fs.existsSync(this.str(path))) {
+      throw new Error(`File path ${path} does not exist.`)
+    }
+    const mime = mimeTypes.lookup(path)
+    let order = this.num(this.args.order)
+    if (!order) {
+      const maxNumber: Record<string, number> = {}
+      const old: TagModelData[] = await this.get(`/db/${db}/tags`)
+      for (const tag of old) {
+        if (!tag.type) {
+          continue
+        }
+        maxNumber[tag.type] = Math.max(maxNumber[tag.type] || 0, tag.order)
+      }
+      order = (maxNumber[this.str(type)] || 0) + 1
+    }
+    const picture = fs.readFileSync(this.str(path)).toString('base64')
+
+    const params = { tag, name, mime, type, order, picture }
+    await this.post(`/db/${db}/tags`, params)
+    log(`Tag ${tag} created successfully.`)
+  }
+
+  async run() {
+    await this.runBy('subCommand')
+  }
+}
+
+export default TagCommand

package/src/commands/tx.ts

@@ -0,0 +1,93 @@
+/* eslint-disable camelcase */
+import { sprintf } from 'sprintf-js'
+import { Command } from '.'
+import { ArgumentParser } from 'argparse'
+import { DocumentModelData, EntryModelData, log } from '@dataplug/tasenor-common'
+
+class TxCommand extends Command {
+
+  addArguments(parser: ArgumentParser): void {
+    const sub = parser.add_subparsers()
+
+    const ls = sub.add_parser('ls', { help: 'List all transactions' })
+    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 rm = sub.add_parser('rm', { help: 'Delete a transaction' })
+    rm.set_defaults({ subCommand: 'rm' })
+    rm.add_argument('db', { help: 'Name of the database' })
+    rm.add_argument('id', { help: 'ID of the transaction' })
+
+    const create = sub.add_parser('create', { help: 'Create a transaction' })
+    create.set_defaults({ subCommand: 'create' })
+    create.add_argument('--force', { help: 'Allow invalid transactions.', action: 'store_true', required: false })
+    create.add_argument('--data', { help: 'Define additional data field for all entries as JSON.', required: false })
+    create.add_argument('db', { help: 'Name of the database' })
+    create.add_argument('date', { help: 'The transaction date' })
+    create.add_argument('entry', { nargs: '+', help: 'A transaction line as string, e.g "1234 Description +12,00" or "1234 Description +12,00 {<data>}"' })
+  }
+
+  async ls() {
+    const { db, period } = this.args
+    const periodId = await this.periodId(db, period)
+    const resp = await this.get(`/db/${db}/document?period=${periodId}&entries`)
+    await this.readAccounts(db)
+    this.out('document', resp)
+  }
+
+  print(data: DocumentModelData[]): void {
+    for (const doc of data.sort((a, b) => (a.number || 0) - (b.number || 0))) {
+      const { number, date } = doc
+      console.log(`#${number} ${date}`)
+      if (doc.entries) {
+        for (const entry of doc.entries) {
+          console.log('  ', this.accountsById[entry.account_id || -1].number, sprintf('%.2f', entry.debit ? entry.amount / 100 : entry.amount / -100), entry.description)
+        }
+      }
+    }
+  }
+
+  async rm() {
+    const { db, id } = this.args
+    await this.delete(`/db/${db}/document/${id}`)
+    log(`Document ${id} deleted successfully.`)
+  }
+
+  async create() {
+    const { db, date, data, entry, force } = this.args
+    if (!db) {
+      throw new Error(`Invalid database argument ${JSON.stringify(db)}`)
+    }
+    const periodId = await this.periodId(db, date)
+    let entries = await this.entries(db, entry)
+    if (data) {
+      const extras = await this.jsonData(data)
+      entries = entries.map(e => ({ ...e, data: extras }))
+    }
+    const sum = entries.reduce((prev, cur) => prev + cur.amount, 0)
+    if (sum && !force) {
+      throw new Error(`Transaction total must be zero. Got ${sum} from ${JSON.stringify(entries)}.`)
+    }
+
+    const document: DocumentModelData = await this.post(`/db/${db}/document`, { period_id: periodId, date: this.date(date) })
+    log(`Created a document #${document.id} on ${date}.`)
+    for (const e of entries) {
+      const out: EntryModelData = await this.post(`/db/${db}/entry`, {
+        document_id: document.id,
+        account_id: e.account_id,
+        debit: e.amount > 0,
+        amount: Math.abs(e.amount),
+        description: e.description,
+        data: e.data
+      })
+      log(`Created an entry #${out.id} for ${e.number} ${e.description} ${sprintf('%.2f', e.amount / 100)}${e.data ? ' ' + JSON.stringify(e.data) : ''}.`)
+    }
+  }
+
+  async run() {
+    await this.runBy('subCommand')
+  }
+}
+
+export default TxCommand

package/src/commands/user.ts

@@ -0,0 +1,65 @@
+import { log } from '@dataplug/tasenor-common'
+import { Command } from '.'
+import { ArgumentParser } from 'argparse'
+
+class UserCommand extends Command {
+
+  addArguments(parser: ArgumentParser): void {
+    const sub = parser.add_subparsers()
+
+    const ls = sub.add_parser('ls', { help: 'List all users' })
+    ls.set_defaults({ subCommand: 'ls' })
+
+    const rm = sub.add_parser('rm', { help: 'Delete a user' })
+    rm.set_defaults({ subCommand: 'rm' })
+    rm.add_argument('email', { help: 'Email address of the user' })
+
+    const create = sub.add_parser('create', { help: 'Create a user' })
+    create.set_defaults({ subCommand: 'create' })
+    create.add_argument('name', { help: 'Full name of the user' })
+    create.add_argument('passwd', { help: 'Initial password for the user' })
+    create.add_argument('email', { help: 'Email address of the user' })
+
+    const add = sub.add_parser('add', { help: 'Add a user to the database' })
+    add.set_defaults({ subCommand: 'add' })
+    add.add_argument('email', { help: 'Email address of the user' })
+    add.add_argument('db', { help: 'Name of the database' })
+  }
+
+  async ls() {
+    const resp = await this.get('/admin/user')
+    this.out('user', resp)
+  }
+
+  print(data): void {
+    for (const user of data.sort((a, b) => (a.id || 0) - (b.id || 0))) {
+      const { id, name, email, config } = user
+      console.log(`#${id} ${name} ${email} ${JSON.stringify(config)}`)
+    }
+  }
+
+  async rm() {
+    const { email } = this.args
+    await this.delete(`/admin/user/${email}`)
+    log(`User ${email} deleted successfully.`)
+  }
+
+  async create() {
+    const { name, passwd, email } = this.args
+    const params = { name, password: passwd, email }
+    await this.post('/admin/user', params)
+    log(`User ${name} created successfully.`)
+  }
+
+  async add() {
+    const { email, db } = this.args
+    log(`Adding user ${email} to database ${db}`)
+    await this.post(`/admin/user/${email}/databases`, { database: this.str(db) })
+  }
+
+  async run() {
+    await this.runBy('subCommand')
+  }
+}
+
+export default UserCommand