@opengis/bi 1.0.21 → 1.0.22

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

@@ -0,0 +1,58 @@
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { rm, mkdir, writeFile } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+
+import { config, logger } from '@opengis/fastify-table/utils.js';
+
+export default async function downloadRemoteFile({
+  rootDir, url, table,
+}) {
+  if (!rootDir) {
+    return { error: 'param rootDir is required', status: 400 };
+  }
+  if (!url) {
+    return { error: 'param url is required', status: 400 };
+  }
+  if (!table) {
+    return { error: 'param table is required', status: 400 };
+  }
+
+  try {
+    const response = await fetch(url);
+
+    if (response?.status !== 200) {
+      return { message: 'file not found', status: response?.status };
+    }
+
+    const arrayBuffer = await response.arrayBuffer();
+    const buffer = Buffer.from(arrayBuffer);
+
+    const contentType = response.headers.get('Content-Type');
+
+    // eslint-disable-next-line newline-per-chained-call
+    const extName = contentType === 'text/plain' ? path.extname(url) : `.${response.headers.get('Content-Type')?.split(';')?.shift()?.split('/')?.pop()?.replace(/\+|\-|\./g, '')}`; // path.extname(url)
+
+    const filePath = `/files/tmp/${createHash('md5').update([url, table].join()).digest('hex')}${extName}`;
+    const fullPath = path.join(rootDir, filePath);
+
+    if (config?.local) {
+      console.log(url, fullPath, existsSync(fullPath));
+    }
+
+    await mkdir(path.dirname(fullPath), { recursive: true });
+
+    if (existsSync(fullPath) && config?.local) {
+      await rm(fullPath);
+    }
+
+    if (!existsSync(fullPath)) {
+      await writeFile(fullPath, buffer);
+    }
+    return { filePath };
+  }
+  catch (err) {
+    logger.file('dataset/create/error', { url, error: err.toString() });
+    return { error: err.toString(), status: 500 };
+  }
+}

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

@@ -0,0 +1,46 @@
+import { pgClients } from '@opengis/fastify-table/utils.js';
+
+import insertDataQuery from './insertDataQuery.js';
+
+const insertDataset = `insert into bi.dataset 
+(name, table_name, dataset_file_path, column_list, pk, data_source, uid)
+values($1,$2,$3,$4,$5,$6,$7) returning dataset_id`;
+
+const updateAppeal = 'update datasets_appeal.appeal set dataset_id=$1, data_key=$2 where ap_id=$3';
+
+export default async function executeQuery({
+  sql, data, name, id, table, relPath, columns, pkey, source, user, url, dataKey,
+}) {
+  const client = await pgClients.client.connect();
+  try {
+    await client.query('BEGIN');
+
+    // create table
+    await client.query(sql);
+
+    // insert data
+    if (data) {
+      const insertData = insertDataQuery(columns, data, table);
+      await client.query(insertData);
+    }
+
+    // create dataset
+    const args = [name || id, table, relPath, columns ? JSON.stringify(columns) : null, pkey, JSON.stringify({ type: source, appeal: id, url }), user?.uid];
+    const datasetId = await client.query(insertDataset, args).then(el => el.rows?.[0]?.dataset_id);
+
+    if (id) {
+      // update appeal for public only, admin w/o appeal
+      await client.query(updateAppeal, [datasetId, dataKey, id]);
+    }
+
+    await client.query('COMMIT');
+    return { datasetId };
+  }
+  catch (err) {
+    await client.query('ROLLBACK');
+    return { error: err.toString(), status: 500 };
+  }
+  finally {
+    client.release();
+  }
+}

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

@@ -0,0 +1,107 @@
+import descriptionList from "./descriptionList.js";
+import metaFormat from "./metaFormat.js";
+
+async function getDataByLatLng({ pg, layer, table, id, lat, lng, time = [] }) {
+    // const rclient = getRedis();
+    // const redisKey = `${pg.options.database}:gis-format:${layer}:${lat}:${lng}`;
+    // const cacheData = await rclient.get(redisKey);
+    // if (cacheData && !config.local) return JSON.parse(cacheData);
+
+    const { rows: styles = [] } = await pg.query(`select style_id as id, dataset 
+    from gis.style where style_id=any($1::text[])
+      union all
+    select dataset_id as id, json_build_array(json_build_object('pk', pk, 'table', table_name, 'query', query, 'card', setting->>'card', 'columns', column_list)) as dataset 
+    from bi.dataset a where dataset_id=any($1::text[])`, [layer.split(',')]);
+    time.push(Date.now());
+
+    if (!styles?.length) {
+        return { message: `style not found: ${layer}`, status: 400 };
+    }
+
+    const { srids } = await pg.queryCache?.('select json_agg(srid) as srids from spatial_ref_sys').then((res1) => res1.rows?.[0] || {}) || {};
+
+    const layers = styles.reduce((acc, curr) => {
+        curr.dataset?.filter((el) => el.table && (el.pk || pg.pk?.[el.table]))
+            ?.forEach((el) => acc.push({
+                layer: curr.id,
+                pk: el.pk || pg.pk?.[el.table],
+                key: el.key,
+                table: el.table,
+                query: el.query,
+                template: el.card,
+                column_list: el.column_list,
+                columns: el.columns || el.column_list?.map((el) => el.name)?.join(','),
+                srid: el.srid || '4326',
+                geom: el.geom || 'geom',
+                step: srids?.includes(el.srid - 0) && el.srid !== '4326' ? 10 : 0.0002,
+            }));
+        return acc;
+    }, [])
+        .filter((el) => el.pk && el.layer)
+        .filter((el) => table ? el.table === table : true);
+
+    if (!layers.length) {
+        return { message: 'data not found', status: 404 };
+    }
+
+    const point = `srid=4326;point(${lng} ${lat})`;
+
+    // ${el.columns?.split?.filter?.((el) => el) ? `,${el.columns?.split?.filter?.((el) => el) || ''}` : ''}
+
+    const q = layers.map((el) => `select ${el.pk}, '${el.layer}' as layer,
+    row_to_json(t) as data,
+    st_asgeojson(${el.geom})::json as geom from ${el.table} t 
+    where ${el.query || '1=1'} and ${id ? `${el.pk}::text='${id.replace(/'/g, "''")}'` : '1=1'}
+    and case
+      when ST_GeometryType(geom) in ('ST_Polygon','ST_MultiPolygon')
+      then st_intersects(geom,st_buffer('${point}',${el.step}))
+  
+      when ST_GeometryType(geom) in ('ST_Line','ST_MultiLineString')
+      then st_distance(geom,'${point}') < ${el.step}
+    else false end`).join(' union all ');
+
+    // if (config.local && config.debug) console.log(q);
+    const { rows: objects = [] } = await pg.query(q) || {};
+    time.push(Date.now());
+
+    const rows = objects.map((row) => {
+        const layerData = layers.find((el) => el.layer === row?.layer) || {};
+        const rowData = layerData?.columns?.split?.filter?.((el) => el) ? layerData?.columns?.split?.filter?.((el) => el).reduce((acc, curr) => Object.assign(acc, { [curr]: row.data?.[curr] }), {}) : row.data;
+        return {
+            ...rowData,
+            ...row,
+            ...layerData,
+            data: undefined,
+            id: layerData.pk ? row?.[layerData.pk] : undefined,
+            geom: row.geom,
+        };
+    });
+
+    const { pk, layer: layerId, card, template } = rows[0] || {};
+
+    const dataset = layers.find((el) => el.layer === rows?.[0]?.layer) || {};
+
+    const columnList = (dataset.column_list || dataset.columns)?.reduce?.((acc, curr) => Object.assign(acc, { [curr.name]: curr.title || curr.ua || curr.name }), {}) || {};
+
+    const columns = card
+        ? Object.keys(card).map(el => `${el}| ${card[el]}`).join('|')
+        : Object.keys(columnList)?.map((key) => `${columnList[key]}| ${key}`).join('|');
+
+    const html = columns && rows?.[0] ? await descriptionList(rows[0], { hash: { columns } }) : undefined;
+    time.push(Date.now());
+
+    await Promise.all(rows.map(async () => {
+        const layerData = layers.find((el) => el.layer === rows?.[0]?.layer) || {};
+        const columns = layerData.column_list || layerData.columns;
+        if (columns?.length && Array.isArray(columns)) {
+            await metaFormat({ rows, columns });
+        }
+    }));
+    time.push(Date.now());
+
+    const resp = { id: rows?.[0]?.[pk], layers: layerId, template, data: rows?.[0], rows, html };
+
+    // await rclient.set(redisKey, JSON.stringify(resp), 'EX', 5 * 60);
+    return resp;
+}
+export default getDataByLatLng

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

@@ -0,0 +1,47 @@
+import { handlebars } from "@opengis/fastify-table/utils.js";
+
+import descriptionList from "./descriptionList.js";
+// import metaFormat from "./metaFormat.js";
+
+async function getDataById({ pg, table, id, time = [] }) {
+    const dataset = await pg.query(`select dataset_id as id, pk, query, table_name, column_list, setting
+    from bi.dataset where dataset_id=$1`, [table]).then((res) => res.rows[0] || {});
+    time.push(Date.now());
+
+    if (!dataset?.id) {
+        return { message: `dataset not found: ${table}`, status: 400 };
+    }
+
+    if (!dataset?.table_name) {
+        return { message: 'invalid dataset: empty params table', status: 400 };
+    }
+
+    const pk = dataset.pk || pg.pk?.[dataset.table_name];
+
+    const { rows = [] } = pk ? await pg.query(`select *, ${pk}, geom::json from ${dataset.table_name} where ${dataset.query || '1=1'} and ${pk}=$1`, [id]) || {} : {};
+    if (pk) rows.forEach((row) => Object.assign(row, { id: row?.[pk] }));
+    time.push(Date.now());
+
+    // sql columns
+    const sql = `select attname as name, pg_catalog.col_description(attrelid,attnum) as title, atttypid::regtype as type from  pg_catalog.pg_attribute a 
+                        where attrelid='${dataset.table_name}'::regclass and attnum>0 
+                        and attname not in ('editor_id','editor_date','cdate','geom','id','uid','cdate')
+                        and atttypid::regtype not in ('json','geometry')`;
+
+    // card or auto
+    const type = dataset.setting?.card_type || 'auto';
+    const list = dataset.setting?.card_list || [];
+    const { rows: all } = await pg.query(sql).then(el => el);
+    const columns = all.filter(el => type === 'list' ? list.includes(el.name) : true)
+        .map(el => `${el.title || el.name}| ${el.name}`).join('|')
+
+
+    const { body } = type === 'html' && dataset?.setting?.card ? await pg.query(`select body->>'body' as body from admin.doc_template where title=$1`, [dataset?.setting?.card]).then(el => el.rows[0] || {}) : {}
+
+    const html = body ? await handlebars.compile(body)(rows[0]) : await descriptionList(rows[0], { hash: { columns } });
+    time.push(Date.now());
+
+
+    return { id: rows?.[0]?.id, template: dataset?.setting?.card, rows, html, body };
+}
+export default getDataById

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

@@ -0,0 +1,12 @@
+export default function insertDataQuery(columns, data, table) {
+  const columnList = columns?.map((el) => el.name)?.join(',');
+  const features = data?.features || [];
+  if (!features?.length) return null;
+
+  const insertData = `INSERT into ${table} (geom ${columns?.length ? ','.concat(columnList) : ''}) SELECT public.ST_GeomFromGeoJSON((features->>'geometry')::json) AS geom 
+        ${columns?.length ? ','.concat(columns?.map((el) => `features->'properties'->>'${el.title}'`)?.join(',')) : ''} FROM 
+        (SELECT json_array_elements('${JSON.stringify(features).replace(/'/g, "''")}'::json) AS features)q`;
+
+  // console.log(insertData);
+  return insertData;
+}

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

@@ -0,0 +1,24 @@
+import { getSelectVal } from '@opengis/fastify-table/utils.js';
+
+export default async function metaFormat({ rows, columns }) {
+  const selectCols = columns?.filter?.((el) => el.data);
+  if (!selectCols?.length) return rows;
+
+  await Promise.all(selectCols.map(async (attr) => {
+    const values = [...new Set(rows?.map((el) => el[attr.name]).flat())].filter((el) => (typeof el === 'boolean' ? true : el));
+    if (!values.length) return null;
+
+    const cls = await getSelectVal({ name: attr.data, values });
+    if (!cls) return null;
+
+    rows.forEach(el => {
+      const val = el[attr.name]?.map?.(c => cls[c.toString()] || cls[c] || c) || cls[el[attr.name]?.toString()] || cls[el[attr.name]] || el[attr.name];
+      if (!val) return;
+      Object.assign(el, { [val?.color ? `${attr.name}_data` : `${attr.name}_text`]: (val.color ? val : val.text || val) });
+    });
+
+    return null;
+  }));
+
+  return rows;
+}

package/server/routes/edit/controllers/widget.edit.js

@@ -5,7 +5,8 @@ import { getWidget, yamlSafe } from '../../../../utils.js';
 export default async function widgetEdit({ pg, body, params, }) {
   const { widget: widgetName, name: dashboardName } = params;
   const data = body.yml && !body.style ? yamlSafe.load(body.yml) : body;
-
+  const yml = body.yml ?? yamlSafe.dump(body.data);
+  console.log(body.data, data, body.yml, yml);
 
 
   if (!widgetName || !dashboardName) {
@@ -15,8 +16,8 @@ export default async function widgetEdit({ pg, body, params, }) {
     };
   }
 
-  const { widget_id: widgetId } = await pg.query(
-    `select a.widget_id , b.dashboard_id from bi.widget a, bi.dashboard b
+  const { widget_id: widgetId, dashboard_id: dashboardId, widgets } = await pg.query(
+    `select a.widget_id , b.dashboard_id, b.widgets from bi.widget a, bi.dashboard b
     where $2 in (a.widget_id, a.name) and $1 in (b.dashboard_id, b.name) order by 1,2`,
     [dashboardName, widgetName]).then(res1 => res1.rows?.[0] || {});
 
@@ -35,8 +36,8 @@ export default async function widgetEdit({ pg, body, params, }) {
     return { message: 'bad params: table ' + tableName, status: 400 };
   }
 
-  if (body.yml) {
-    Object.assign(widgetData, { yml: body.yml })
+  if (yml) {
+    Object.assign(widgetData, { yml })
   }
 
   Object.assign(widgetData, { table_name: tableName });
@@ -47,6 +48,23 @@ export default async function widgetEdit({ pg, body, params, }) {
     data: widgetData,
   });
 
+  const idx = widgets.findIndex(el => el.name === widgetName);
+  if (widgetData.hasOwnProperty('data')) {
+    widgets[idx].data = widgetData.data
+  }
+  if (widgetData.hasOwnProperty('yml')) {
+    widgets[idx].yml = widgetData.yml;
+  }
+  if (widgetData.hasOwnProperty('style')) {
+    widgets[idx].style = widgetData.style;
+  }
+
+  await dataUpdate({
+    table: 'bi.dashboard',
+    id: dashboardId,
+    data: { widgets },
+  });
+
   return {
     message: rows,
     status: 200,

package/server/routes/map/controllers/heatmap.js

@@ -0,0 +1,118 @@
+import path from 'node:path';
+import { createHash } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { readFile, writeFile, mkdir, stat } from 'node:fs/promises';
+
+import { pgClients, getFilterSQL, getPGAsync, getMeta, getFolder } from '@opengis/fastify-table/utils.js';
+
+import { getWidget } from '../../../../utils.js';
+
+const hourMs = 3.6e6;
+const maxLimit = 2500;
+
+export default async function heatmap(req, reply) {
+    const { query = {}, user = {} } = req;
+
+    const { widget, dashboard, filter, search, size = 0.1 } = query;
+
+    if (query.size && (+query.size || 0) <= 0) {
+        return { message: 'param size is invalid', status: 400 };
+    }
+
+    if (!dashboard || !widget) {
+        return { message: 'not enough params: dashboard / widget', status: 400 };
+    }
+
+    const { data } = await getWidget({ widget, dashboard });
+
+    if (!data?.table) {
+        return { message: 'widget not found: ' + widget, status: 400 };
+    }
+
+    const limit = Math.min(+query.limit || maxLimit, maxLimit);
+    const hash = [search, filter, limit].filter((el) => el).join();
+
+    const root = getFolder(req, 'local');
+    const file = path.join(
+        root,
+        `/map/geojson/heatmap/${data.table}/${hash ? `${createHash('sha1').update(hash).digest('base64')}/` : ''}.geojson`
+    );
+
+    if (existsSync(file) && !query.nocache && !query.sql) {
+        const timeNow = Date.now();
+        const stats = await stat(file);
+        const birthTime = new Date(stats.birthtime).getTime();
+        if (!(birthTime - timeNow > hourMs * 24)) {
+            const geojson = JSON.parse((await readFile(file, 'utf-8')) || {});
+            return geojson;
+        }
+    }
+
+    const pg = data.db ? await getPGAsync(data.db) : pgClients.client;
+
+    if (!pg.pk?.[data.table]) {
+        return { message: `table not found: ${data.table}`, status: 404 };
+    }
+
+    const metric = query.metric || data.metrics?.[0]?.name || (Array.isArray(data.metrics) ? data.metrics?.[0] : data.metrics);
+
+    const operator = metric
+        ? (['sum', 'min', 'max', 'avg'].find(el => el === query.operator) || 'sum')
+        : undefined;
+
+    const aggregator = metric
+        ? `${operator}(${metric})`
+        : 'count(*)';
+
+    const { geom, columns } = await getMeta({ pg, table: data.table });
+
+    const { dataTypeID } = columns.find(col => col.name === metric) || {};
+
+    if (metric && !dataTypeID) {
+        return { message: `metric column not found: ${metric}`, status: 404 };
+    }
+
+    if (!['integer', 'numeric', 'double precision'].includes(pg.pgType[dataTypeID])) {
+        return { message: `metric column invalid type: ${metric} (${pg.pgType[dataTypeID]})`, status: 404 };
+    }
+
+    if (!geom) {
+        return { message: `geometry column not found: ${data.table}`, status: 404 };
+    }
+
+    const { optimizedSQL = `select * from ${data.table} where 1=1` } = hash ? await getFilterSQL({ pg, table: data.table, filter, search }) : {};
+
+    const subQuery = `SELECT ${aggregator} AS metric, hex.geom FROM (
+        SELECT ST_SetSRID( (ST_HexagonGrid(${size}, ST_Extent(q.${geom})) ).geom, 4326 ) as geom FROM ( ${optimizedSQL})q
+    )hex
+    LEFT JOIN ( ${optimizedSQL} )pts
+    ON ST_Within(pts.${geom}, hex.geom)
+
+    JOIN ( SELECT ST_ConvexHull(ST_Collect(${geom})) AS mask FROM ( ${optimizedSQL} )q )point_mask
+    ON ST_Intersects(hex.geom, point_mask.mask)
+
+    WHERE 1=1 /*and pts.${geom} is not null AND st_srid(pts.${geom}) > 0*/
+    GROUP BY hex.geom
+    limit ${limit}`;
+
+    if (query.sql === '1' && user?.user_type?.includes('admin')) return subQuery;
+
+    const q = `SELECT 'FeatureCollection' As type, json_agg(f) As features FROM ( 
+      SELECT
+        'Feature' As type,
+        row_number() over() as id,
+        st_asgeojson(geom, 6, 0)::json as geometry,
+        json_build_object( 'metric', metric ) as properties
+      from (${subQuery})sq
+    )f`;
+
+    if (query.sql === '2' && user?.user_type?.includes('admin')) return q;
+
+    const geojson = await pg.query(q)
+        .then(el => el.rows?.[0] || {});
+
+    await mkdir(path.dirname(file), { recursive: true });
+    await writeFile(file, JSON.stringify(geojson));
+
+    return geojson;
+}

package/server/routes/map/index.mjs

@@ -4,6 +4,7 @@ import vtile from './controllers/vtile.js';
 
 import cluster from './controllers/cluster.js';
 import clusterVtile from './controllers/clusterVtile.js';
+import heatmap from './controllers/heatmap.js';
 
 const biSchema = {
   querystring: {
@@ -22,4 +23,5 @@ export default async function route(fastify, opts) {
   fastify.get('/bi-vtile/:z/:y/:x', { schema: biSchema }, vtile);
   fastify.get('/bi-cluster', { schema: biSchema }, cluster);
   fastify.get('/bi-cluster-vtile/:z/:y/:x', { schema: biSchema }, clusterVtile);
+  fastify.get('/bi-heatmap', {}, heatmap);
 }

package/server/utils/getWidget.js

@@ -1,5 +1,7 @@
 import { getTemplate, pgClients } from '@opengis/fastify-table/utils.js';
 
+import mdToHTML from '../helpers/mdToHTML.js';
+
 const pg = pgClients.client;
 
 async function getWidget({ dashboard, widget }) {
@@ -33,7 +35,8 @@ async function getWidget({ dashboard, widget }) {
     ? dashboardData?.find((el) => el[2] === (widget || 'index'))?.[1]
     : await getTemplate('widget', widget);
   if (typeof widgetData === 'string') {
-    return { source: widgetData, status: 200 };
+    const html = mdToHTML(widgetData);
+    return { source: html, status: 200 };
   }
   if (!id && !dashboardData && !widgetData) {
     return { message: `not found ${widget} ${dashboard}`, status: 404 };
@@ -65,7 +68,7 @@ async function getWidget({ dashboard, widget }) {
       widgetData?.table_name ||
       dashboardIndex?.table ||
       dashboardIndex?.table_name,
-    db: dashboardIndex?.db || pgClients.client?.options?.database,
+    db: dashboardIndex?.db || widgetData?.db || pgClients.client?.options?.database,
   });
   const main = { ...(dashboardIndex || {}), ...widgetData, ...data, ...data?.data || {} };
 

package/server/routes/dataset/controllers/bi.dataset.add.js

@@ -1,86 +0,0 @@
-import { randomBytes } from 'node:crypto';
-
-import { dataInsert, getPG, pgClients, initPG } from '@opengis/fastify-table/utils.js';
-
-import createTableFunc from './util/create.table.js';
-import prepareData from './util/prepare.data.js';
-
-async function updatePGMeta(pg, table) {
-  if (!pg.tlist) await initPG(pg);
-  if (!pg.tlist.includes(table)) {
-    const { pks } = await pg.query(`SELECT json_object_agg(c.conrelid::regclass, a.attname) as pks FROM pg_constraint c 
-      left join pg_attribute a on c.conrelid=a.attrelid and a.attnum = c.conkey[1] WHERE c.contype='p'::"char"`).then(el => el.rows[0]) || {};
-      pg.pk[table] = pks[table];
-      pg.tlist.push(table);
-  }
-}
-
-/**
- * Додавання нового набору даних BI
- *
- * @method POST
- * @summary Додавання нового набору даних BI
- * @priority 4
- * @alias biDatasetAdd
- * @type api
- * @tag bi
- * @param {Object} params.id Dashboard ID
- * @errors 400,500
- * @returns {Number} status Номер помилки
- * @returns {String} error Опис помилки
- * @returns {Object} rows Масив з колонками таблиці
- */
-
-export default async function biDatasetAdd(req) {
-  const { body = {}, session = {} } = req;
-  const { uid } = session?.passport?.user || {};
-
-  if (!uid) {
-    return { message: 'access restricted', status: 403 };
-  }
-
-  if (body.table_name) {
-    const result = await dataInsert({
-      table: 'bi.dataset',
-      data: { ...body, source_type: 'db' },
-      uid,
-    }).then(el => el.rows?.[0]);
-
-    const pg = body.db ? getPG({ db: body.db }) : pgClients.client;
-    await updatePGMeta(pg,body.table_name);
-
-    return { message: { id: result?.dataset_id, action: 'assign', table: body.table_name }, status: 200 };
-  }
-
-  if (!Array.isArray(body.data) && body.data?.features?.[0]?.type !== 'Feature' && !body.file_path) {
-    return { message: 'body data param is invalid', status: 400 };
-  }
-
-  const tableName = randomBytes(64).toString('hex').substring(0, 24).replace(/^\d+/, '');
-  const pkey = tableName.concat('_id');
-  const table = `bi_data.${tableName}`;
-  const { columns, insertData } = await prepareData({ table, file_path: body.file_path, data: body?.data });
-  const createTable = createTableFunc({ table, pkey, columns, name: body.name });
-
-  const q = ['create extension if not exists postgis;create schema if not exists bi_data', createTable, insertData].join(';');
-  
-  const pg = body.db ? getPG({ db: body.db }) : pgClients.client;
-  if (!pg.pk) await initPG(pg);
-  
-  const results = await pg.query(q);
-
-  const result = await dataInsert({
-    table: 'bi.dataset',
-    data: { ...body, table_name: table, source_type: body.data ? 'user' : 'file' },
-    uid,
-  }).then(el => el.rows?.[0]);
-
-  await updatePGMeta(pg,table);
-
-  return {
-    message: {
-      id: result?.dataset_id, action: 'import', total: results?.find((el) => el.command === 'INSERT')?.rowCount, table,
-    },
-    status: 200,
-  };
-};

package/server/routes/dataset/controllers/bi.dataset.data.add.js

@@ -1,49 +0,0 @@
-import { dataInsert, getPG, initPG, pgClients } from "@opengis/fastify-table/utils.js";
-
-/**
- * Внесення даних до набору BI
- *
- * @method POST
- * @summary Внесення даних до набору BI
- * @priority 4
- * @alias biDatasetDataAdd
- * @type api
- * @tag bi
- * @param {Object} params.id Dataset ID
- * @errors 400,500
- * @returns {Number} status Номер помилки
- * @returns {String} error Опис помилки
- * @returns {Object} rows Масив з колонками таблиці
- */
-
-export default async function biDatasetDataAdd(req) {
-    const { params = {}, session = {}, body = {} } = req;
-    const { uid } = session?.passport?.user || {};
-
-    if (!uid) {
-        return { message: 'access restricted', status: 403 };
-    }
-
-    if (!params?.id) {
-        return { message: 'not enough params: id', status: 400 };
-    }
-
-    const { id, table, db } = await pgClients.client.query('select db, dataset_id as id, table_name as table from bi.dataset where dataset_id=$1', [params.id])
-        .then(el => el.rows[0]);
-
-    if (!id) {
-        return { message: 'dataset not found', status: 404 };
-    }
-    
-    const pg = db ? getPG({ db }) : pgClients.client;
-    if (!pg.pk) await initPG(pg);
-
-    const result = await dataInsert({
-        pg,
-        table,
-        data: body,
-        uid,
-    }).then(el => el.rows[0]);
-
-    return { id, action: 'insert', result };
-};