waibu-db 1.1.11 → 1.1.13

package/lib/crud/list-handler.js

@@ -3,7 +3,7 @@ async function listHandler ({ req, reply, model, template, params = {}, addOnsHa
   const { recordFind, getSchemaExt } = this.app.waibuDb
   const { get, merge, isArray, upperFirst } = this.lib._
   const qsKey = this.app.waibu.config.qsKey
-  const options = { count: true }
+  const options = { count: true, rels: '*' }
   model = model ?? pascalCase(req.params.model)
   const { schema } = await getSchemaExt(model, 'list', { params })
   if (schema.disabled.includes('find')) return reply.view(templateDisabled, { action: 'list' })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "waibu-db",
-  "version": "1.1.11",
+  "version": "1.1.13",
   "description": "DB Helper",
   "main": "index.js",
   "scripts": {

package/plugin/method/format-record.js

@@ -0,0 +1,46 @@
+async function formatRow ({ data, req, component, schema, options = {} }) {
+  const { get, find, isFunction, cloneDeep } = this.lib._
+  const { format, callHandler } = this.app.bajo
+  const fields = get(schema, 'view.fields', Object.keys(schema.properties))
+  const rec = cloneDeep(data)
+  for (const f of fields) {
+    if (f === '_rel') continue
+    let prop = find(schema.properties, { name: f })
+    if (!prop) prop = find(schema.view.calcFields, { name: f })
+    if (!prop) continue
+    const opts = {
+      lang: options.lang ?? (req ? req.lang : undefined),
+      longitude: ['lng', 'longitude'].includes(f),
+      latitude: ['lat', 'latitude'].includes(f),
+      speed: ['speed'].includes(f),
+      degree: ['course', 'heading'].includes(f),
+      distance: ['distance'].includes(f)
+    }
+    rec[f] = format(data[f], prop.type, opts)
+    const vf = get(schema, `view.valueFormatter.${f}`)
+    if (vf) {
+      if (isFunction(vf)) rec[f] = await vf.call(req ?? this, data[f], data)
+      else rec[f] = await callHandler(vf, req, data[f], data)
+    }
+    const formatter = get(schema, `view.formatter.${f}`)
+    if (formatter && component) {
+      if (isFunction(formatter)) rec[f] = await formatter.call(req ?? this, data[f], data)
+      else rec[f] = await callHandler(formatter, req, data[f], data)
+      rec[f] = await component.buildSentence(rec[f])
+    }
+  }
+  return rec
+}
+
+async function formatRecord ({ data, req, schema, component, options = {} }) {
+  const { isArray } = this.lib._
+  if (!isArray(data)) return await formatRow.call(this, { data, req, schema, component, options })
+  const items = []
+  for (const d of data) {
+    const item = await formatRow.call(this, { data: d, req, schema, component, options })
+    items.push(item)
+  }
+  return items
+}
+
+export default formatRecord

package/plugin/method/get-schema-ext.js

@@ -2,8 +2,14 @@ import path from 'path'
 
 const defReadonly = ['id', 'createdAt', 'updatedAt']
 
+const defFormatter = {}
+
 function getCommons (action, schema, ext, opts = {}) {
-  const { map, get, set, without, uniq } = this.lib._
+  const { merge, map, get, set, without, uniq } = this.lib._
+  const calcFields = get(ext, `view.${action}.calcFields`, get(ext, 'common.calcFields', []))
+  const noEscape = get(ext, `view.${action}.noEscape`, get(ext, 'common.noEscape', []))
+  const valueFormatter = get(ext, `view.${action}.valueFormatter`, get(ext, 'common.valueFormatter', {}))
+  const formatter = get(ext, `view.${action}.formatter`, get(ext, 'common.formatter', {}))
   const label = get(ext, `view.${action}.label`, get(ext, 'common.label', {}))
   const card = get(ext, `view.${action}.card`, get(ext, 'common.card', true))
   const hidden = get(ext, `view.${action}.hidden`, get(ext, 'common.hidden', []))
@@ -13,15 +19,20 @@ function getCommons (action, schema, ext, opts = {}) {
   hidden.push(...schema.hidden, ...(opts.hidden ?? []))
   const allFields = without(map(schema.properties, 'name'), ...hidden)
   const forFields = get(ext, `view.${action}.fields`, get(ext, 'common.fields', allFields))
+  set(schema, 'view.calcFields', calcFields)
+  set(schema, 'view.noEscape', noEscape)
+  set(schema, 'view.valueFormatter', valueFormatter)
+  set(schema, 'view.formatter', merge({}, defFormatter, formatter))
   set(schema, 'view.stat.aggregate', aggregate)
   set(schema, 'view.disabled', disabled)
   set(schema, 'view.x', x)
   if (schema.disabled.length > 0) schema.view.disabled.push(...schema.disabled)
   let fields = []
   for (const f of forFields) {
-    if (allFields.includes(f)) fields.push(f)
+    if (allFields.includes(f) || map(calcFields, 'name').includes(f)) fields.push(f)
   }
   fields = uniq(without(fields, ...hidden))
+
   if (action !== 'add' && !fields.includes('id')) fields.unshift('id')
   let noWrap = get(ext, `view.${action}.noWrap`, get(ext, 'common.noWrap', true))
   if (noWrap === true) noWrap = fields

package/waibuBootstrap/theme/component/factory/table.js

@@ -21,15 +21,17 @@ async function table () {
 
     build = async () => {
       const { req } = this.component
-      const { callHandler } = this.plugin.app.bajo
       const { escape } = this.plugin.app.waibu
+      const { formatRecord } = this.plugin.app.waibuDb
       const { attrToArray, groupAttrs } = this.plugin.app.waibuMpa
-      const { get, omit, set, find, isEmpty, without, isFunction, merge } = this.plugin.app.bajo.lib._
+      const { get, omit, set, find, isEmpty, without, merge } = this.plugin.app.bajo.lib._
       const group = groupAttrs(this.params.attr, ['body', 'head', 'foot'])
       this.params.attr = group._
       const prettyUrl = this.params.attr.prettyUrl
 
+      const schema = get(this, 'component.locals.schema', {})
       const data = get(this, 'component.locals.list.data', [])
+      const fdata = await formatRecord.call(this.plugin, { data, req, schema, component: this.component })
       const filter = get(this, 'component.locals.list.filter', {})
       const count = get(this, 'component.locals.list.count', 0)
       if (count === 0) {
@@ -38,7 +40,6 @@ async function table () {
         this.params.html = await this.component.buildSentence(alert)
         return
       }
-      const schema = get(this, 'component.locals.schema', {})
       const disableds = get(schema, 'view.disabled', [])
       if (disableds.includes('find')) {
         this.params.html = ''
@@ -112,7 +113,9 @@ async function table () {
       html.push(await this.component.buildTag({ tag: 'thead', attr: group.head, html: header }))
       // body
       items = []
-      for (const d of data) {
+      for (const idx in data) {
+        const d = data[idx]
+        const fd = fdata[idx]
         const lines = []
         if (selection) {
           const tag = selection === 'single' ? 'formRadio' : 'formCheck'
@@ -126,41 +129,29 @@ async function table () {
           let prop = find(schema.properties, { name: f })
           if (!prop) prop = find(schema.view.calcFields, { name: f })
           if (!prop) continue
-          const opts = {}
-          if (f === 'lng') opts.longitude = true
-          else if (f === 'lat') opts.latitude = true
-          let value = req.format(d[f], prop.type, opts)
-          if (prop.type === 'boolean') {
-            value = (await this.component.buildTag({ tag: 'icon', attr: { name: `circle${d[f] ? 'Check' : ''}` } })) +
-              ' ' + (req.t(d[f] ? 'Yes' : 'No'))
-          } else value = escape(value)
           let dataValue = d[f] ?? ''
           if (['datetime'].includes(prop.type)) dataValue = escape(dataValue.toISOString())
           if (['string', 'text'].includes(prop.type)) dataValue = escape(dataValue)
           if (['array', 'object'].includes(prop.type)) dataValue = escape(JSON.stringify(d[f]))
-          const vf = get(schema, `view.valueFormatter.${f}`)
-          if (vf) {
-            if (isFunction(vf)) dataValue = escape(await vf(d[f], d))
-            else dataValue = await callHandler(vf, req, d[f], d)
+          let value = fd[f]
+          if (prop.type === 'boolean') {
+            value = (await this.component.buildTag({ tag: 'icon', attr: { name: `circle${d[f] ? 'Check' : ''}` } })) +
+              ' ' + (req.t(d[f] ? 'Yes' : 'No'))
+          } else {
+            if (!get(schema, 'view.noEscape', []).includes(f)) value = escape(value)
           }
           const attr = { dataValue, dataKey: prop.name, dataType: prop.type }
           if (!disableds.includes('get')) attr.style = { cursor: 'pointer' }
           const cellFormatter = get(schema, `view.cellFormatter.${f}`)
-          if (cellFormatter) merge(attr, await cellFormatter(dataValue, d))
+          if (cellFormatter) merge(attr, await cellFormatter.call(req, dataValue, d))
           const noWrap = this.isNoWrap(f, schema, group.body.nowrap) ? 'nowrap' : ''
           if (this.isRightAligned(f, schema)) attr.text = `align:end ${noWrap}`
           else attr.text = noWrap
           const lookup = get(schema, `view.lookup.${f}`)
           if (lookup) {
-            const item = find(lookup.values, set({}, lookup.id ?? 'id', value))
+            const item = find(lookup.values, set({}, lookup.id ?? 'id', d[f]))
             if (item) value = req.t(item[lookup.field ?? 'name'])
           }
-          const formatter = get(schema, `view.formatter.${f}`)
-          if (formatter) {
-            if (isFunction(formatter)) value = await formatter(dataValue, d)
-            else value = await callHandler(formatter, req, dataValue, d)
-            value = await this.component.buildSentence(value)
-          }
           const line = await this.component.buildTag({ tag: 'td', attr, html: value })
           lines.push(line)
         }