@opengis/bi 1.0.23 → 1.0.25

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

@@ -0,0 +1,52 @@
+import { dataDelete, pgClients } from '@opengis/fastify-table/utils.js';
+
+/**
+ * Видалення набору даних
+ *
+ * @method DELETE
+ * @summary Видалення набору даних
+ * @priority 4
+ * @alias deleteDataset
+ * @type api
+ * @tag bi
+ * @param {Object} query.id Dataset ID
+ * @errors 400,500
+ * @returns {Number} status Номер помилки
+ * @returns {String} error Опис помилки
+ * @returns {Object} rows Масив з колонками таблиці
+ */
+
+export default async function deleteDataset({
+    pg = pgClients.client, query = {}, user = {},
+}) {
+    if (!user?.uid) {
+        return { message: 'access restricted', status: 403 };
+    }
+
+    if (!query?.id) {
+        return { message: 'not enough params: id', status: 404 };
+    }
+
+    const dataset = await pg.query('select dataset_id as id, table_name as table from bi.dataset where dataset_id=$1', [query.id])
+        .then(el => el.rows[0] || {});
+
+    if (!dataset.id) {
+        return { message: 'dataset not found', status: 404 };
+    }
+
+    const table = dataset.table && pg.pk[dataset.table] ? dataset.table : dataset.table?.replace(/"/g, '');
+
+    const dropTable = table && pg.pk?.[table] && table.startsWith('data_user.');
+    if (dropTable) {
+        await pg.query(`drop table if exists ${table}`);
+    }
+
+    await dataDelete({
+        pg,
+        table: 'bi.dataset',
+        id: dataset.id,
+        uid: user.uid,
+    });
+
+    return { message: { id: dataset?.id, table: dropTable ? dataset.table : undefined }, status: 200 };
+}

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

@@ -20,7 +20,7 @@ const columnTypeMatch = {
  * @alias editDataset
  * @type api
  * @tag bi
- * @param {Object} params.id Dashboard ID
+ * @param {Object} query.id Видалення ID
  * @errors 400,500
  * @returns {Number} status Номер помилки
  * @returns {String} error Опис помилки
@@ -70,6 +70,7 @@ export default async function editDataset(req) {
     }));
 
   await dataUpdate({
+    pg,
     table: 'bi.dataset',
     data: { column_list: columns },
     id: dataset.id,

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

@@ -1,7 +1,9 @@
+import { pgClients } from "@opengis/fastify-table/utils.js";
+
 import getTableData from "../utils/getTableData.js";
 import getLayersData from "../utils/getLayersData.js";
 
-export default async function gisFormat({ query = {}, pg }) {
+export default async function gisFormat({ query = {}, pg = pgClients.client }) {
   const time = [Date.now()];
   const { layer, table, id, lat, lng } = query;
 

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

@@ -33,6 +33,7 @@ export default async function datasetDataInsert({
   }
 
   const res = await dataInsert({
+    pg,
     table: add,
     data: body,
     uid: user?.uid,

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

@@ -1,69 +1,68 @@
 import {
-    config, pgClients, getMeta, setToken, getToken,
+  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,
+  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 
+  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);
+
+  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;
+  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

@@ -32,6 +32,7 @@ export default async function datasetDataUpdate({
   }
 
   const res = await dataUpdate({
+    pg,
     id: tokenData?.id || params?.object_id,
     table,
     data: body,

package/server/routes/dataset/index.mjs

@@ -3,6 +3,7 @@ import dbTablePreview from './controllers/dbTablePreview.js';
 
 import createDatasetPost from './controllers/createDatasetPost.js';
 import editDataset from './controllers/editDataset.js';
+import deleteDataset from './controllers/deleteDataset.js';
 import datasetData from './controllers/data.js';
 import datasetFormData from './controllers/table.js';
 import datasetDataInsert from './controllers/insert.js';
@@ -15,106 +16,117 @@ 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
 
+const policy = ['public'];
+
 export default async function route(fastify, opts) {
   fastify.route({
     method: 'GET',
     url: '/bi-db-list',
     schema: {},
+    config: { policy },
     handler: biDbList,
   });
   fastify.route({
     method: 'GET',
     url: '/bi-datasets',
     schema: {},
+    config: { policy },
     handler: biDatasetList,
   });
   fastify.route({
     method: 'GET',
     url: '/gis-format',
-    config: { policy: ['site'] },
+    config: { policy },
     handler: format,
   });
   fastify.route({
     method: 'GET',
     url: '/db-tables',
     schema: {},
-    config: { policy: ['site'] },
+    config: { policy },
     handler: dbTables,
   });
   fastify.route({
     method: 'GET',
     url: '/db-tables/:name',
     schema: {},
-    config: { policy: ['site'] },
+    config: { policy },
     handler: dbTablePreview,
   });
   fastify.route({
     method: 'POST',
     url: '/dataset',
     schema: {},
-    config: { policy: ['site'] },
+    config: { policy },
     handler: createDatasetPost,
   });
   fastify.route({
     method: 'PUT',
     url: '/dataset',
     schema: {},
-    config: { policy: ['site'] },
+    config: { policy },
     handler: editDataset,
   });
+  fastify.route({
+    method: 'DELETE',
+    url: '/dataset',
+    schema: {},
+    config: { policy },
+    handler: deleteDataset,
+  });
   fastify.route({
     method: 'GET',
     url: '/dataset-data/:id',
     schema: {},
-    config: { policy: ['site'] },
+    config: { policy },
     handler: datasetData,
   });
   fastify.route({
     method: 'GET',
     url: '/dataset-data/:id/:object_id',
     schema: {},
-    config: { policy: ['site'] },
+    config: { policy },
     handler: datasetFormData,
   });
   fastify.route({
     method: 'POST',
     url: '/dataset-data/:id',
     schema: {},
-    config: { policy: ['site'] },
+    config: { policy },
     handler: datasetDataInsert,
   });
   fastify.route({
     method: 'PUT',
     url: '/dataset-data/:id/:object_id?',
     schema: {},
-    config: { policy: ['site'] },
+    config: { policy },
     handler: datasetDataUpdate,
   });
   fastify.route({
     method: 'DELETE',
     url: '/dataset-data/:id/:object_id?',
     schema: {},
-    config: { policy: ['site'] },
+    config: { policy },
     handler: datasetDataDelete,
   });
   fastify.route({
     method: 'GET',
     url: '/dataset-form/:id',
     schema: {},
-    config: { policy: ['site'] },
+    config: { policy },
     handler: datasetForm,
   });
   fastify.route({
     method: 'GET',
     url: '/dataset-export/:id',
     schema: {},
-    config: { policy: ['site'] },
+    config: { policy },
     handler: datasetDataExport,
   });
   fastify.route({
     method: 'POST',
     url: '/dataset-comment/:id',
-    config: { policy: ['site'] },
+    config: { policy },
     handler: datasetEditComment,
   });
 }

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

@@ -36,7 +36,7 @@ export default function createTable(columns, name) {
     ?.join(';');
 
   const createQuery = `create table if not exists ${table} (
-  ${pkey} text not null default public.uuid_generate_v4(), 
+  ${pkey} text not null default encode(public.gen_random_bytes(6), 'hex'), 
   geom public.geometry, ${columns ? `
   ${columns?.map?.((el) => `${el.name} ${el.type}`).join(', ')},` : ''} 
   cdate timestamp without time zone not null default now(), 

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

@@ -9,9 +9,9 @@ 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,
+  pg = pgClients.client, sql, data, name, id, table, relPath, columns, pkey, source, user, url, dataKey,
 }) {
-  const client = await pgClients.client.connect();
+  const client = await pg.connect();
   try {
     await client.query('BEGIN');
 

package/server/routes/edit/controllers/dashboard.add.js

@@ -1,26 +1,36 @@
-import { dataInsert } from "@opengis/fastify-table/utils.js";
+import { pgClients, dataInsert, getPGAsync } from "@opengis/fastify-table/utils.js";
 
-export default async function widgetAdd({ pg, body }) {
-  try {
-    const time = Date.now();
-    const tableName = body.table_name;
-    const checkTable = await pg.query(
-      `select * from bi.dashboard where $1 in (table_name)`,
-      [tableName]
-    );
-    if (!checkTable.rows.length) return { message: 'bad params', status: 401 };
-    const res = await dataInsert({
-      table: 'bi.dashboard',
-      data: body,
-    });
+export default async function dashboardAdd(req, reply) {
+  const {
+    pg = pgClients.client,
+    body = {},
+  } = req;
+  const time = Date.now();
 
-    return {
-      time: Date.now() - time,
-      id: res.rows?.[0].dashboard_id,
-      title: res.rows?.[0].title,
-      name: res.rows?.[0].name,
-    };
-  } catch (err) {
-    return { error: err.toString(), status: 500 };
+  if (body?.db) {
+    try {
+      const pg1 = await getPGAsync(body.db);
+      await pg1.query('select 1');
+    } catch (err) {
+      return reply.status(400).send('Некоректна база даних');
+    }
   }
+
+  const res = await dataInsert({
+    pg,
+    table: 'bi.dashboard',
+    data: body,
+  }).then(el => el.rows?.[0] || {});
+
+  if (res.dashboard_id && body.dataset) {
+    await pg.query(`update bi.dataset set dashboard_list=coalesce(dashboard_list, '{}'::text[]) || array[$1]
+    where dataset_id=$2`, [res.dashboard_id, body.dataset]);
+  }
+
+  return {
+    time: Date.now() - time,
+    id: res.dashboard_id,
+    title: res.title,
+    name: res.name,
+  };
 }

package/server/routes/edit/controllers/dashboard.delete.js

@@ -0,0 +1,39 @@
+import path from 'node:path';
+import { existsSync, readdirSync } from 'node:fs';
+
+import { pgClients, dataDelete } from '@opengis/fastify-table/utils.js';
+
+const cwd = process.cwd();
+const dashboardDir = path.join(cwd, 'server/templates/dashboard');
+
+export default async function dashboardDelete({ pg = pgClients.client, params = {}, user }, reply) {
+  if (!params?.id) {
+    return reply.status(400).send('not enough params: id');
+  }
+
+  const dirContent = existsSync(dashboardDir)
+    ? readdirSync(dashboardDir)
+    : [];
+
+  if (dirContent.includes(params.id)) {
+    return reply.status(403).send(`access restricted: ${params.id}`);
+  }
+
+  const { rowCount = 0 } = pg.pk?.['bi.dashboard']
+    ? await pg.query('select * from bi.dashboard where $1 in (dashboard_id,name)', [params.id])
+    : {};
+
+  if (rowCount === 0) {
+    return reply.status(404).send(`not found ${params.id}`);
+  }
+
+  await pg.query(`delete from bi.widget where $1 in (dashboard_id)`, [params.id]);
+  await dataDelete({
+    pg,
+    table: 'bi.dashboard',
+    id: params.id,
+    uid: user?.uid,
+  });
+
+  return reply.status(200).send('successfully deleted');
+}

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

@@ -1,46 +1,61 @@
-import { dataUpdate } from "@opengis/fastify-table/utils.js";
-
-export default async function dashboardEdit(
-  { pg, params = {}, body = {} },
-  reply
-) {
-  try {
-    if (!params.name) {
-      return {
-        message: 'not enough params: dashboard name required',
-        status: 400,
-      };
+import { dataUpdate, pgClients, getPGAsync } from "@opengis/fastify-table/utils.js";
+
+export default async function dashboardEdit({
+  pg = pgClients.client, params = {}, body = {},
+}, reply) {
+  const { name: dashboardName } = params;
+  const { panels, widgets, table_name: tableName } = body;
+
+  if (body?.db) {
+    try {
+      const pg1 = await getPGAsync(body.db);
+      await pg1.query('select 1');
+    } catch (err) {
+      return reply.status(400).send('Некоректна база даних');
     }
-    const tableName = body.table_name;
-    const checkTable = await pg.query(
-      `select * from bi.dashboard where $1 in (table_name)`,
-      [tableName]
-    );
-    if (!checkTable.rows.length) return { message: 'bad params', status: 401 };
-    const { name: dashboardName } = params;
-    const row = await pg
-      .query(
-        `select dashboard_id from bi.dashboard where $1 in (dashboard_id, name)`,
-        [dashboardName]
-      )
-      .then((res1) => res1.rows?.[0] || {});
-    const { dashboard_id: dashboardId } = row;
-
-    const res = await dataUpdate({
-      table: 'bi.dashboard',
-      id: dashboardId,
-      data: body,
+  }
+
+  if (!dashboardName) {
+    return reply.status(400).send('not enough params: name');
+  }
+
+  if (!tableName) {
+    return reply.status(400).send('not enough params: table_name');
+  }
+
+  const row = await pg.query('select dashboard_id, widgets, panels from bi.dashboard where $1 in (dashboard_id, name)', [dashboardName])
+    .then(el => el.rows?.[0] || {});
+  const { dashboard_id: dashboardId } = row;
+
+  if (!dashboardId) {
+    return reply.status(400).send('dashboard not found');
+  }
+
+  if (panels?.length && !widgets?.length) {
+    row.widgets.forEach((el) => {
+      const { title } = panels?.find?.(item => item.widget === el.name) || {};
+      if (el.data) {
+        // console.log('el.title', el.title, 'title', title);
+        el.data.title = title;
+      }
     });
-    if (!Object.keys(res)?.length) {
-      return { message: 'not found data', status: 404 };
-    }
+    Object.assign(body, { widgets: row.widgets });
+  }
+
+  const res = await dataUpdate({
+    pg,
+    table: 'bi.dashboard',
+    id: dashboardId,
+    data: body,
+  });
 
-    return {
-      message: `updated ${dashboardName}`,
-      status: 200,
-      rows: res,
-    };
-  } catch (err) {
-    return reply.status(500).send(err.toString());
+  if (!Object.keys(res)?.length) {
+    return reply.status(404).send('not found data');
   }
+
+  return {
+    message: `updated ${dashboardName}`,
+    status: 200,
+    rows: res,
+  };
 }