@opengis/bi 1.0.21 → 1.0.22

package/server/routes/dataset/controllers/form.js

@@ -0,0 +1,99 @@
+import {
+  config, pgClients, getMeta, getToken,
+} from '@opengis/fastify-table/utils.js';
+
+import datasetForms from '../utils/datasetForms.js';
+
+const inputType = {
+  text: 'Text',
+  autocomplete: 'Autocomplete',
+  select: 'Autocomplete',
+  date: 'DatePicker',
+  'yes/no': 'Switcher',
+  badge: 'Select',
+  number: 'Number',
+  tags: 'Tags',
+  file: 'File',
+};
+
+const systemColumns = [
+  'uid',
+  'cdate',
+  'editor_id',
+  'editor_date',
+  'files',
+];
+
+export default async function datasetForm({
+  pg = pgClients.client, params = {}, query = {}, user = {},
+}) {
+  if (!user?.uid) {
+    return { message: 'access restricted', status: 403 };
+  }
+
+  if (!params?.id) {
+    return { message: 'not enough params: id', status: 404 };
+  }
+
+  const tokenData = await getToken({
+    uid: user?.uid,
+    token: params.id,
+    mode: 'a',
+    json: 1,
+  });
+
+  if (!tokenData && !config.local && !config.debug) {
+    return { message: 'token not allow', status: 403 };
+  }
+
+  const {
+    id, columns, formSetting, table, style,
+  } = await pg.query(`select dataset_id as id, table_name as table, column_list as columns, style, 
+      form_setting as "formSetting" from bi.dataset where dataset_id=$1`, [tokenData?.dataset || params.id])
+    .then(el => el.rows?.[0] || {});
+
+  if (!id) {
+    return { message: 'dataset not found', status: 404 };
+  }
+
+  if (datasetForms[id] && !query.nocache) {
+    return datasetForms[id];
+  }
+
+  const { columns: dbColumns = [] } = await getMeta(table) || {};
+  const isFilesColumn = dbColumns.find((el) => el.name === 'files' && pg.pgType[el.dataTypeID] === 'text');
+
+  const formSchema = formSetting
+    || ((columns || dbColumns).filter((col) => !systemColumns.includes(col.name))).reduce((acc, curr) => Object.assign(acc, {
+      [curr.name]: {
+        type: inputType[curr?.format || curr?.type || 'text'] || 'Text',
+        ua: curr?.description || curr?.title || curr?.name,
+        validators: curr?.is_required ? ['required'] : null,
+        options: curr?.values?.length ? curr?.values : null,
+        data: curr?.data,
+        min: curr?.type || curr?.format === 'number' ? 0 : null,
+      },
+    }), {});
+
+  Object.assign(formSchema, {
+    geom: {
+      type: 'Geom',
+      ua: 'Геометрія',
+      height: '500',
+      geom_edit_controol: [style?.type ? [style.type] : null],
+    },
+  });
+
+  if (isFilesColumn) {
+    Object.assign(formSchema, {
+      files: {
+        type: 'FileList',
+        ua: 'Файли',
+      },
+    });
+  }
+
+  datasetForms[id] = formSchema;
+
+  return formSchema;
+}

package/server/routes/dataset/controllers/format.js

@@ -0,0 +1,44 @@
+import getTableData from "../utils/getTableData.js";
+import getLayersData from "../utils/getLayersData.js";
+
+export default async function gisFormat({ query = {}, pg }) {
+  const time = [Date.now()];
+  const { layer, table, id, lat, lng } = query;
+
+  if (!table && !layer) {
+    return { message: 'not enough params', status: 400 };
+  }
+
+  if (layer && !(lat && lng)) {
+    return { message: 'not enough params: lat/lng', status: 400 };
+  }
+
+  if (table && !(id || layer)) {
+    return { message: 'not enough params: id', status: 400 };
+  }
+
+  const { message, template, rows, layers, html, body } = layer
+    ? await getLayersData({ pg, layer, table, id, lat, lng, time })
+    : await getTableData({ pg, table, id, time });
+
+  if (message) return { message, status: 400 };
+
+  return {
+    time: {
+      layer: time[1] - time[0],
+      data: time[2] - time[1],
+      html: time[3] - time[2],
+      total: time[3] - time[0],
+    },
+
+    id: rows[0]?.id,
+    table,
+    layers,
+
+    data: { geom: rows[0]?.geom },
+    rows,
+    html,
+    template,
+    body,
+  };
+}

package/server/routes/dataset/controllers/insert.js

@@ -0,0 +1,46 @@
+import {
+  config, getToken, dataInsert, pgClients,
+} from '@opengis/fastify-table/utils.js';
+
+import datasetForms from '../utils/datasetForms.js';
+
+export default async function datasetDataInsert({
+  pg = pgClients.client, params = {}, body = {}, user = {},
+}) {
+  if (!user?.uid) {
+    return { message: 'access restricted', status: 403 };
+  }
+
+  const tokenData = await getToken({
+    uid: user?.uid,
+    token: params.id,
+    mode: 'a',
+    json: 1,
+  });
+
+  if (!tokenData && !config.local && !config.debug) {
+    return { message: 'token not allow', status: 403 };
+  }
+
+  const dataset = await pg.query('select dataset_id as id, table_name as table from bi.dataset where dataset_id=$1', [tokenData?.dataset || params.id])
+    .then(el => el.rows[0] || {});
+
+  const { form, table: add } = tokenData
+    || { form: `${dataset.id}.form`, table: dataset.table };
+
+  if (!form || !dataset.id || !datasetForms[dataset.id]) {
+    return { message: 'dataset not found', status: 404 };
+  }
+
+  const res = await dataInsert({
+    table: add,
+    data: body,
+    uid: user?.uid,
+  });
+
+  if (!res) {
+    return { message: 'nothing added' };
+  }
+
+  return { rows: res.rows };
+}

package/server/routes/dataset/controllers/table.js

@@ -0,0 +1,69 @@
+import {
+    config, pgClients, getMeta, setToken, getToken,
+} from '@opengis/fastify-table/utils.js';
+  
+export default async function datasetFormData({
+    pg = pgClients.client, params = {}, query = {}, user = {},
+}) {  
+    if (!params?.id) {
+      return { message: 'not enough params: id', status: 400 };
+    }
+      
+    if (!user?.uid) {
+        return { message: 'access restricted', status: 403 };
+    }
+    
+    const { user_type: userType = 'regular' } = user;
+      
+    const tokenData = await getToken({
+        uid: user?.uid,
+        token: params.id,
+        mode: 'w',
+        json: 1,
+    });
+    
+    if (!tokenData && !params?.object_id) {
+        return { message: 'not enough params: object_id', status: 400 };
+    }
+  
+    const dataset = await pg.query(`select dataset_id as id, table_name as table, column_list as columns, filter_list as filters,
+      sql_list as sql, style, form_setting, pk, access_level from bi.dataset where dataset_id=$1`, [tokenData?.dataset || params.id]).then(el => el.rows[0] || {});
+  
+    if (!dataset?.id) {
+      return { message: 'dataset not found', status: 404 };
+    }
+
+    const tlist = await pg.query(`select array_agg((select nspname from pg_namespace where oid=relnamespace)||'.'||relname) tlist 
+      from pg_class where relkind in ('r','v')`).then(el => el.rows[0]?.tlist || []);
+  
+    if (!dataset.table || !tlist.includes(dataset.table.replace(/"/g, '')) || (!pg.pk?.[dataset.table.replace(/"/g, '')] && !dataset.pk)) {
+      return { message: `table not found: ${dataset.table}`, status: 404 };
+    }
+  
+    const { pk = dataset.pk, columns: dbColumns = [] } = await getMeta(dataset.table) || {};
+    const cols = dataset.columns?.filter((el) => el.name !== 'geom')?.map((el) => el.name || el)?.join(',');
+    
+    const where = [`"${pk}" = $1`, dataset.query].filter((el) => el);
+
+  const geom = dbColumns.find((el) => el.name === 'geom' && pg.pgType[el.dataTypeID] === 'geometry') ? ',st_asgeojson(geom)::json as geom' : '';
+  const files = dbColumns.find((el) => el.name === 'files' && pg.pgType[el.dataTypeID] === 'text') ? ',files' : '';
+    const q = `select "${pk}" as id, ${cols || '*'} ${files} ${geom} from ${dataset.table} t where ${where.join(' and ') || 'true'} limit 1`;
+  
+    if (query.sql === '1' && (config.debug || userType.includes('admin'))) { return q; }
+  
+    const data = await pg.query(q, [tokenData?.id || params.object_id]).then(el => el.rows?.[0] || {});
+  
+    data.token = setToken({
+        ids: [JSON.stringify({
+            id: data.id,
+            table: dataset.table,
+            form: `${dataset.id}.form`,
+            dataset: dataset.id,
+        })],
+        uid: user?.uid,
+        array: 1,
+    })[0];
+    
+    return data;
+}
+  

package/server/routes/dataset/controllers/update.js

@@ -0,0 +1,42 @@
+import {
+  config, getToken, dataUpdate, pgClients,
+} from '@opengis/fastify-table/utils.js';
+
+import datasetForms from '../utils/datasetForms.js';
+
+export default async function datasetDataUpdate({
+  pg = pgClients.client, params = {}, body = {}, user = {},
+}) {
+  if (!user?.uid) {
+    return { message: 'access restricted', status: 403 };
+  }
+
+  const tokenData = await getToken({
+    uid: user?.uid,
+    token: params.id,
+    mode: 'a',
+    json: 1,
+  });
+
+  if (!tokenData && !config.local && !config.debug) {
+    return { message: 'token not allow', status: 403 };
+  }
+
+  const dataset = await pg.query('select dataset_id as id, table_name as table from bi.dataset where dataset_id=$1', [tokenData?.dataset || params.id])
+    .then(el => el.rows[0] || {});
+
+  const table = tokenData?.table || dataset.table;
+
+  if (!dataset.id || !datasetForms[dataset.id]) {
+    return { message: 'dataset not found', status: 404 };
+  }
+
+  const res = await dataUpdate({
+    id: tokenData?.id || params?.object_id,
+    table,
+    data: body,
+    uid: user?.uid,
+  });
+
+  return res;
+}

package/server/routes/dataset/index.mjs

@@ -1,75 +1,120 @@
-import biDatasetDataList from './controllers/bi.dataset.data.list.js'; // get dataset structure + data
-import biDatasetDemoAdd from './controllers/bi.dataset.demo.add.js'; // import demo datasets
-import biDatasetList from './controllers/bi.dataset.list.js'; // get dataset list
-import biDatasetAdd from './controllers/bi.dataset.add.js'; // assign table / import data from body (vue sheet) or file (relative path)
-import biDatasetDel from './controllers/bi.dataset.del.js'; // delete dataset + data
-import biDatasetEdit from './controllers/bi.dataset.edit.js'; // edit dataset structure
-import biDbList from './controllers/bi.db.list.js'; // list db
-import biDatasetDataAdd from './controllers/bi.dataset.data.add.js';
-import biDatasetDataEdit from './controllers/bi.dataset.data.edit.js';
-import biDatasetDataDel from './controllers/bi.dataset.data.del.js';
+import dbTables from './controllers/dbTables.js';
+import dbTablePreview from './controllers/dbTablePreview.js';
 
-const biSchema = {};
+import createDatasetPost from './controllers/createDatasetPost.js';
+import editDataset from './controllers/editDataset.js';
+import datasetData from './controllers/data.js';
+import datasetFormData from './controllers/table.js';
+import datasetDataInsert from './controllers/insert.js';
+import datasetDataUpdate from './controllers/update.js';
+import datasetDataDelete from './controllers/delete.js';
+import datasetDataExport from './controllers/export.js';
+import datasetForm from './controllers/form.js';
+import format from './controllers/format.js';
+import datasetEditComment from './controllers/comment.js';
+import biDbList from './controllers/bi.db.list.js'; // list db
+import biDatasetList from './controllers/bi.dataset.list.js'; // list datasets
 
 export default async function route(fastify, opts) {
   fastify.route({
-    method: 'POST',
-    url: '/bi-datasets',
-    schema: biSchema,
-    handler: biDatasetAdd,
+    method: 'GET',
+    url: '/bi-db-list',
+    schema: {},
+    handler: biDbList,
   });
   fastify.route({
     method: 'GET',
-    url: '/bi-dataset-demo',
-    schema: biSchema,
-    handler: biDatasetDemoAdd,
+    url: '/bi-datasets',
+    schema: {},
+    handler: biDatasetList,
   });
   fastify.route({
     method: 'GET',
-    url: '/bi-db-list',
-    schema: biSchema,
-    handler: biDbList,
+    url: '/gis-format',
+    config: { policy: ['site'] },
+    handler: format,
   });
   fastify.route({
     method: 'GET',
-    url: '/bi-datasets',
-    schema: biSchema,
-    handler: biDatasetList,
+    url: '/db-tables',
+    schema: {},
+    config: { policy: ['site'] },
+    handler: dbTables,
   });
   fastify.route({
     method: 'GET',
-    url: '/bi-datasets/:id',
-    schema: biSchema,
-    handler: biDatasetDataList,
+    url: '/db-tables/:name',
+    schema: {},
+    config: { policy: ['site'] },
+    handler: dbTablePreview,
   });
   fastify.route({
-    method: 'DELETE',
-    url: '/bi-datasets/:id',
-    schema: biSchema,
-    handler: biDatasetDel,
+    method: 'POST',
+    url: '/dataset',
+    schema: {},
+    config: { policy: ['site'] },
+    handler: createDatasetPost,
   });
   fastify.route({
     method: 'PUT',
-    url: '/bi-datasets/:id',
-    schema: biSchema,
-    handler: biDatasetEdit,
+    url: '/dataset',
+    schema: {},
+    config: { policy: ['site'] },
+    handler: editDataset,
+  });
+  fastify.route({
+    method: 'GET',
+    url: '/dataset-data/:id',
+    schema: {},
+    config: { policy: ['site'] },
+    handler: datasetData,
+  });
+  fastify.route({
+    method: 'GET',
+    url: '/dataset-data/:id/:object_id',
+    schema: {},
+    config: { policy: ['site'] },
+    handler: datasetFormData,
   });
   fastify.route({
     method: 'POST',
-    url: '/bi-datasets/:id',
-    schema: biSchema,
-    handler: biDatasetDataAdd,
+    url: '/dataset-data/:id',
+    schema: {},
+    config: { policy: ['site'] },
+    handler: datasetDataInsert,
   });
   fastify.route({
     method: 'PUT',
-    url: '/bi-datasets/:id/:objectId',
-    schema: biSchema,
-    handler: biDatasetDataEdit,
+    url: '/dataset-data/:id/:object_id?',
+    schema: {},
+    config: { policy: ['site'] },
+    handler: datasetDataUpdate,
   });
   fastify.route({
     method: 'DELETE',
-    url: '/bi-datasets/:id/:objectId',
-    schema: biSchema,
-    handler: biDatasetDataDel,
+    url: '/dataset-data/:id/:object_id?',
+    schema: {},
+    config: { policy: ['site'] },
+    handler: datasetDataDelete,
+  });
+  fastify.route({
+    method: 'GET',
+    url: '/dataset-form/:id',
+    schema: {},
+    config: { policy: ['site'] },
+    handler: datasetForm,
+  });
+  fastify.route({
+    method: 'GET',
+    url: '/dataset-export/:id',
+    schema: {},
+    config: { policy: ['site'] },
+    handler: datasetDataExport,
+  });
+  fastify.route({
+    method: 'POST',
+    url: '/dataset-comment/:id',
+    config: { policy: ['site'] },
+    handler: datasetEditComment,
   });
 }

package/server/routes/dataset/utils/convertJSONToCSV.js

@@ -0,0 +1,17 @@
+import path from 'node:path';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+
+export default async function convertJSONToCSV({
+  filepathJSON, send = () => { }, delimiter = ';',
+}) {
+  if (!filepathJSON) return null;
+  const rows = JSON.parse(await readFile(filepathJSON) || '{}');
+  const values = rows.map((row) => Object.values(row).map((el) => `${el};`));
+  values.unshift(Object.keys(rows[0]).map((el) => `${el};`));
+
+  send('Конвертація успішно завершена. Формування файлу...');
+  await mkdir(path.dirname(filepathJSON), { recursive: true });
+  await writeFile(filepathJSON.replace('.json', '.csv'), `\ufeff${values.join('\n').replace(/;,/g, delimiter)}`, 'utf8');
+  send('Файл успішно сформовано. Оновіть сторінку або натисніть кнопку ще раз для завантаження. ', 1);
+  return { message: 'Файл успішно сформовано. Натистіть кнопку ще раз для завантаження даних', status: 200 };
+}

package/server/routes/dataset/utils/convertJSONToXls.js

@@ -0,0 +1,49 @@
+import path from 'path';
+import {
+  mkdir, readFile, writeFile,
+} from 'fs/promises';
+
+import { logger } from '@opengis/fastify-table/utils.js';
+
+import { grpc } from '@opengis/fastify-file/utils.js';
+
+const { jsonToXls } = grpc();
+
+export default async function convertJSONToXls({
+  filepathJSON, colmodel, domain, source, send = () => { },
+}) {
+  if (!filepathJSON) return null;
+
+  const rows = JSON.parse(await readFile(filepathJSON) || '{}');
+
+  if (!rows?.length) {
+    return { message: 'empty rows', status: 400 };
+  }
+
+  send('Конвертація файлу...');
+  try {
+    const { result } = await jsonToXls({
+      json: JSON.stringify(rows),
+      header: source,
+      subheader: `Завантажено з порталу ${domain} - ${new Date().toLocaleDateString()}. Всього: ${rows.length}`,
+      colmodel: JSON.stringify(colmodel),
+    });
+    send('Конвертація успішно завершена. Формування файлу...');
+    await mkdir(path.dirname(filepathJSON), { recursive: true });
+    await writeFile(filepathJSON.replace('.json', '.xlsx'), result, 'base64');
+    send('Файл успішно сформовано. Оновіть сторінку або натисніть кнопку ще раз для завантаження. ', 1);
+    return { message: 'Файл успішно сформовано. Натистіть кнопку ще раз для завантаження даних', status: 200 };
+  }
+  catch (err) {
+    send(`jsonToXLS err: ${err.toString()}`, 1);
+    logger.error({
+      name: 'export/table',
+      filepathJSON,
+      colmodel,
+      domain,
+      rows: rows.length,
+      error: err.toString(),
+    });
+    return { error: err.toString(), status: 500 };
+  }
+}

package/server/routes/dataset/utils/createTableQuery.js

@@ -0,0 +1,59 @@
+import { randomBytes, createHash } from 'node:crypto';
+
+const schema = 'data_user';
+
+const columnType = {
+  text: 'text',
+  select: 'text',
+  date: 'date',
+  'yes/no': 'boolean',
+  badge: 'text',
+  number: 'numeric',
+  tags: 'text[]',
+  geom: 'geom',
+};
+
+export default function createTable(columns, name) {
+  const tableName = randomBytes(64).toString('hex').substring(0, 24).replace(/^\d+/, '');
+  const table = `${schema}.${tableName}`;
+  const pkey = tableName.concat('_id');
+
+  columns?.forEach?.((el, i) => Object.assign(el, {
+    name: `col_${i}`, // el.name
+    type: columnType[el.format || 'text'] || 'text',
+  }));
+
+  const clsQuery = columns
+    ?.filter?.(col => col?.format === 'select' && col.data?.length)
+    ?.map(col => {
+      const data = JSON.stringify(col.data).replace(/'/g, "''");
+      Object.assign(col, { data: createHash('md5').update([tableName, col.name].join()).digest('hex') });
+      return `insert into admin.cls(clsid,name,type,module) values('${col.data}','${col.data}','json', '${table}');
+      insert into admin.cls(code,name,parent,icon,data,module) 
+      select value->>'id',value->>'text','${col.data}',value->>'icon',value->>'data', '${table}' 
+      from json_array_elements('${data}'::json)`;
+    })
+    ?.join(';');
+
+  const createQuery = `create table if not exists ${table} (
+  ${pkey} text not null default public.uuid_generate_v4(), 
+  geom public.geometry, ${columns ? `
+  ${columns?.map?.((el) => `${el.name} ${el.type}`).join(', ')},` : ''} 
+  cdate timestamp without time zone not null default now(), 
+  editor_date timestamp without time zone, 
+  uid text, 
+  editor_id text, 
+  files json, 
+  constraint ${table.replace(/\./g, '_')}_constraint_pkey PRIMARY KEY (${pkey}) )`;
+
+  const commentQuery = columns
+    ?.filter?.((el) => el.title)
+    ?.map((el) => `comment on column ${table}.${el.name} is '${el.title}'`)
+    ?.join(';');
+
+  return {
+    table,
+    pkey,
+    sql: [createQuery, commentQuery, (name ? `comment on table ${table} is '${name}'` : undefined), clsQuery].filter((el) => el).join(';'),
+  };
+}

package/server/routes/dataset/utils/datasetForms.js

@@ -0,0 +1 @@
+export default {};

package/server/routes/dataset/utils/descriptionList.js

@@ -0,0 +1,46 @@
+import { handlebarsSync, handlebars } from '@opengis/fastify-table/utils.js'
+
+function format(d, key, data) {
+    if (!key?.includes) return '';
+    if (d === true) return 'так';
+    if (d === false) return 'ні'
+
+    if (key.includes('{{')) {
+        return handlebarsSync.compile(key)(data);
+    }
+    if (!d) return '-';
+    return d;
+}
+export default async function descriptionList(data, opt) {
+    const { hash } = opt;
+
+    // no data
+    if (hash.nodata && !data) {
+        const noDataText = typeof hash.nodata == 'string' ? hash.nodata : 'no data';
+        return noDataText
+    }
+    if (!data) return 'empty data'
+    if (!hash.columns.split) return 'columns empty' + JSON.stringify(hash.columns)
+    const keys = hash.columns.split(hash.divider || '|').map(el => hash.comma ? el.trim().replace(new RegExp(hash.comma || '#', 'g'), ',') : el.trim());
+
+    const result = [];
+
+    for (let i = 0; i < keys.length; i += 2) {
+        const name = keys[i];
+        const nameHBS = name.includes('{{') ? handlebarsSync.compile(name)({ ...data, hash }) : false
+
+        if (!nameHBS && name.includes('{{')) continue;
+
+        const key = keys[i + 1];
+        const d1 = ['{{format', '{{select', '{{badge', '{{ifCond'].filter(el => key?.includes?.(el)).length ? await handlebars.compile(key)(data) || '-' : null
+        if (d1 || data[key]) {
+            result.push(`<div class="flex py-[16px] text-[14px] border-b border-[#E5E7EB">
+            <div class="text-[#6B7280] dark:text-white  font-[600] w-[50%]">${nameHBS || name}</div>
+            <div class="font-[400] text-black dark:text-[#bdbdbd]  w-[50%]">${d1 || format(data[key], key, data)}</div>
+            </div>
+            `);
+        }
+
+    }
+    return '<div class="w-full">' + result.join('') + '</div>';
+}