@opengis/bi 1.0.13 → 1.0.14

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

@@ -1,11 +1,22 @@
-import dataUpdate from '@opengis/fastify-table/crud/funcs/dataUpdate.js';
-export default async function widgetEdit({ pg = {}, funcs = {}, body = {}, params = {} }) {
+import { dataUpdate } from '@opengis/fastify-table/utils.js';
+
+import { yamlSafe } from '../../../../utils.js';
+
+export default async function widgetEdit({
+  pg = {},
+  funcs = {},
+  body = {},
+  params = {},
+}) {
   const { widget: widgetName, name: dashboardName } = params;
-  const tableName = body.table_name;
+  const data = body.yml ? yamlSafe.load(body.yml) : body;
+  const tableName =
+    data.data?.table || data?.table || data.table_name || body.table_name;
+
   if (!widgetName || !dashboardName) {
     return {
       message: 'not enough params: dashboard and widget name',
-      status: 400
+      status: 400,
     };
   }
 
@@ -17,23 +28,33 @@ export default async function widgetEdit({ pg = {}, funcs = {}, body = {}, param
         [dashboardName, widgetName]
       )
       .then((res1) => res1.rows?.[0] || {});
-    const checkTable = await pg.query(`select * from bi.widget where $1 in (table_name)`, [
-      tableName
-    ]);
     const { widget_id: widgetId, dashboard_id: dashboardId } = row || {};
-    if (!checkTable.rows.length) return { message: 'bad params', status: 401 };
+
+    // const checkTable = await pg.query(
+    //   `select * from bi.widget where $1 in (table_name)`,
+    //   [tableName]
+    // );
+    // if (!checkTable.rows.length) {
+    //   return { message: 'bad params', status: 401 };
+    // }
+
+    if (!tableName || !pg.pk?.[tableName]) {
+      return { message: 'bad params: table', status: 400 };
+    }
 
     if (!widgetId) {
       return { message: `widget not found ${widgetName}`, status: 404 };
     }
 
-    const res = await funcs.dataUpdate({
+    const widgetData = { ...data, data };
+    if (body?.yml) Object.assign(widgetData, { yml: body.yml });
+    await funcs.dataUpdate({
       table: 'bi.widget',
       id: widgetId,
-      data: body
+      data: widgetData,
     });
 
-    //\====================
+    // \====================
     const currentDashboard = await pg
       .query(
         `select * from  bi.dashboard 
@@ -68,13 +89,13 @@ export default async function widgetEdit({ pg = {}, funcs = {}, body = {}, param
     const res1 = await dataUpdate({
       table: 'bi.dashboard',
       id: dashboardId,
-      data: bodyDashboard
+      data: bodyDashboard,
     });
 
     return {
       message: `Edited widget ${widgetName}`,
       status: 200,
-      rows: res1
+      rows: res1,
     };
   } catch (err) {
     return { error: err.toString(), status: 500 };

package/server/routes/edit/index.mjs

@@ -1,27 +1,31 @@
-import widgetAdd from '../edit/controllers/widget.add.js';
-import widgetEdit from '../edit/controllers/widget.edit.js';
-import widgetDel from '../edit/controllers/widget.del.js';
-import dashboardEdit from '../edit/controllers/dashboard.edit.js';
-import dashboardAdd from '../edit/controllers/dashboard.add.js';
+/* eslint-disable import/extensions */
+import widgetAdd from './controllers/widget.add.js';
+import widgetEdit from './controllers/widget.edit.js';
+import widgetDel from './controllers/widget.del.js';
+import dashboardEdit from './controllers/dashboard.edit.js';
+import dashboardAdd from './controllers/dashboard.add.js';
 
 const biSchema = {
   querystring: {
     widget: { type: 'string', pattern: '^([\\d\\w]+)$' },
     dashboard: { type: 'string', pattern: '^([\\d\\w]+)$' },
     list: { type: 'string', pattern: '^([\\d])$' },
-    sql: { type: 'string', pattern: '^([\\d])$' }
+    sql: { type: 'string', pattern: '^([\\d])$' },
   },
   params: {
     name: { type: 'string', pattern: '^([\\d\\w]+)$' },
-    widget: { type: 'string', pattern: '^([\\d\\w]+)$' }
+    widget: { type: 'string', pattern: '^([\\d\\w]+)$' },
   },
 };
 
-
 export default async function route(fastify) {
   fastify.post(`/bi-dashboard/:name`, { schema: biSchema }, widgetAdd);
   fastify.put(`/bi-dashboard/:name/:widget`, { schema: biSchema }, widgetEdit);
-  fastify.delete(`/bi-dashboard/:name/:widget`, { schema: biSchema }, widgetDel);
+  fastify.delete(
+    `/bi-dashboard/:name/:widget`,
+    { schema: biSchema },
+    widgetDel
+  );
   fastify.post(`/bi-dashboard`, { schema: biSchema }, dashboardAdd);
   fastify.put(`/bi-dashboard/:name`, { schema: biSchema }, dashboardEdit);
-}
+}

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

@@ -1,75 +1,104 @@
-
 import { getWidget } from '../../../../utils.js';
 
-export default async function cluster({
-    pg, funcs, query = {}, log,
-}) {
-    const {
-        widget, filter, dashboard, search,
-    } = query;
-
-    if (!widget) {
-        return { message: 'not enough params: widget', status: 400 };
-    }
-
-    const { data } = await getWidget({ dashboard, widget })
+export default async function cluster({ pg, funcs, query = {}, log }) {
+  const { widget, filter, dashboard, search } = query;
 
-    try {
+  if (!widget) {
+    return { message: 'not enough params: widget', status: 400 };
+  }
 
-        const pkey = pg.pk?.[data?.table];
+  const { data } = await getWidget({ dashboard, widget });
 
-        if (!pkey) {
-            return { message: `invalid ${widget ? 'widget' : 'dashboard'}: table pk not found (${data?.table})`, status: 400 };
-        }
+  try {
+    const pkey = pg.pk?.[data?.table];
 
-        // data param 
-        const { table, query: where = '1=1', metrics = [], cluster, clusterTable = {} } = data;
-
-        if (!cluster) {
-            return { message: `invalid ${widget ? 'widget' : 'dashboard'}: cluster column not specified`, status: 400 };
-        }
-
-        if (!metrics.length) {
-            return { message: `invalid ${widget ? 'widget' : 'dashboard'}: metric columns not found`, status: 400 };
-        }
-
-        if (!clusterTable?.name) {
-            return { message: 'not enough widget params: clusterTable name', status: 400 };
-        }
+    if (!pkey) {
+      return {
+        message: `invalid ${widget ? 'widget' : 'dashboard'}: table pk not found (${data?.table})`,
+        status: 400,
+      };
+    }
 
-        if (clusterTable?.name && !pg.pk?.[clusterTable?.name]) {
-            return { message: 'invalid widget params: clusterTable pkey not found', status: 404 };
-        }
+    // data param
+    const {
+      table,
+      query: where = '1=1',
+      metrics = [],
+      cluster,
+      clusterTable = {},
+    } = data;
+
+    if (!cluster) {
+      return {
+        message: `invalid ${widget ? 'widget' : 'dashboard'}: cluster column not specified`,
+        status: 400,
+      };
+    }
 
-        const { total = 0 } = pg.pk?.[table]
-            ? await pg.queryCache(`select oid::regclass as table, reltuples AS total from pg_class`)
-                .then((res) => res.rows?.find((row) => row.table === table))
-            : {};
+    if (!metrics.length) {
+      return {
+        message: `invalid ${widget ? 'widget' : 'dashboard'}: metric columns not found`,
+        status: 400,
+      };
+    }
 
-        const { bbox } = await pg.query(`select st_asgeojson(box2d(geom))::json as bbox from ${table} where ${where || '1=1'}`).then((res1) => res1.rows?.[0] || {});
+    if (!clusterTable?.name) {
+      return {
+        message: 'not enough widget params: clusterTable name',
+        status: 400,
+      };
+    }
 
-        // get sql
-        const { optimizedSQL } = filter || search
-            ? await funcs.getFilterSQL({ pg, table, filter, search })
-            : {};
+    if (clusterTable?.name && !pg.pk?.[clusterTable?.name]) {
+      return {
+        message: 'invalid widget params: clusterTable pkey not found',
+        status: 404,
+      };
+    }
 
-        const q = `select "${cluster}" as name, sum("${metrics[0]}")::float as metric 
+    const { total = 0 } = pg.pk?.[table]
+      ? await pg
+          .queryCache(
+            `select oid::regclass as table, reltuples AS total from pg_class`
+          )
+          .then((res) => res.rows?.find((row) => row.table === table))
+      : {};
+
+    const { bbox } = await pg
+      .query(
+        `select st_asgeojson(box2d(geom))::json as bbox from ${table} where ${where || '1=1'}`
+      )
+      .then((res1) => res1.rows?.[0] || {});
+
+    // get sql
+    const { optimizedSQL } =
+      filter || search
+        ? await funcs.getFilterSQL({ pg, table, filter, search })
+        : {};
+
+    const q = `select "${cluster}" as name, sum("${metrics[0]}")::float as metric 
         from ${optimizedSQL ? `(${optimizedSQL})` : table} q 
         left join lateral (select "${pg.pk?.[clusterTable?.name]}" as id from ${clusterTable?.name} where ${clusterTable?.title}=q."${cluster}" limit 1)b on 1=1
         where ${where} group by ${cluster}, b.id`;
 
-        if (query.sql === '1') return q;
-
-        // auto Index
-        //  funcs.autoIndex({ table, columns: (metrics || []).concat([cluster]) });
-
-        const { rows = [] } = await pg.query(q);
-        const vals = rows.map(el => el.metric - 0).sort((a, b) => a - b);
-        const len = vals.length;
-        const sizes = [vals[0], vals[Math.floor(len / 4)], vals[Math.floor(len / 2)], vals[Math.floor(len * 0.75)], vals[len - 1]]
-        return { sizes, rows, bbox, count: rows.length, total };
-    } catch (err) {
-        log.error('bi/cluster', { error: err.toString(), query });
-        return { error: err.toString(), status: 500 };
-    }
-}
+    if (query.sql === '1') return q;
+
+    // auto Index
+    //  funcs.autoIndex({ table, columns: (metrics || []).concat([cluster]) });
+
+    const { rows = [] } = await pg.query(q);
+    const vals = rows.map((el) => el.metric - 0).sort((a, b) => a - b);
+    const len = vals.length;
+    const sizes = [
+      vals[0],
+      vals[Math.floor(len / 4)],
+      vals[Math.floor(len / 2)],
+      vals[Math.floor(len * 0.75)],
+      vals[len - 1],
+    ];
+    return { sizes, rows, bbox, count: rows.length, total };
+  } catch (err) {
+    log.error('bi/cluster', { error: err.toString(), query });
+    return { error: err.toString(), status: 500 };
+  }
+}

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

@@ -11,81 +11,148 @@ const mercator = new Sphericalmercator({ size: 256 });
 const clusterExists = {};
 
 export default async function clusterVtile(req, reply) {
-    const {
-        pg, funcs, params = {}, query = {}, log,
-    } = req;
-    const { z, y } = params;
-    const x = params.x?.split('.')[0] - 0;
-
-    if (!x || !y || !z) {
-        return { message: 'not enough params: xyz', status: 400 };
+  const { pg, funcs, params = {}, query = {}, log } = req;
+  const { z, y } = params;
+  const x = params.x?.split('.')[0] - 0;
+
+  if (!x || !y || !z) {
+    return { message: 'not enough params: xyz', status: 400 };
+  }
+
+  const { widget, filter, dashboard, search, clusterZoom, nocache, pointZoom } =
+    query;
+
+  if (!widget) {
+    return { message: 'not enough params: widget', status: 400 };
+  }
+
+  const { data } = await getWidget({ dashboard, widget });
+
+  const headers = {
+    'Content-Type': 'application/x-protobuf',
+    'Cache-Control':
+      nocache || query.sql ? 'no-cache' : 'public, max-age=86400',
+  };
+
+  const hash = [pointZoom, filter].filter((el) => el).join();
+
+  const root = funcs.getFolder(req);
+  const file = path.join(
+    root,
+    `/map/vtile/${widget}/${hash ? `${createHash('sha1').update(hash).digest('base64')}/` : ''}${z}/${x}/${y}.mvt`
+  );
+
+  try {
+    if (!data?.table) {
+      return {
+        message: `invalid ${widget ? 'widget' : 'dashboard'}: table not specified`,
+        status: 400,
+      };
     }
 
-    const {
-        widget, filter, dashboard, search, clusterZoom, nocache, pointZoom,
-    } = query;
+    const pkey = pg.pk?.[data?.table];
 
-    if (!widget) {
-        return { message: 'not enough params: widget', status: 400 };
+    if (!pkey) {
+      return {
+        message: `invalid ${widget ? 'widget' : 'dashboard'}: table pk not found (${data?.table})`,
+        status: 400,
+      };
     }
 
+    // data param
+    const {
+      table,
+      query: where = '1=1',
+      metrics = [],
+      cluster,
+      clusterTable = {},
+    } = data;
+    if (!clusterTable?.name) {
+      Object.assign(clusterTable, {
+        name: 'bi.cluster',
+        title: 'title',
+        query: `type='${data.cluster}'`,
+      });
+    }
 
-    const { data } = await getWidget({ dashboard, widget })
-
-
-    const headers = {
-        'Content-Type': 'application/x-protobuf',
-        'Cache-Control': nocache || query.sql
-            ? 'no-cache'
-            : 'public, max-age=86400',
-    };
-
-    const hash = [pointZoom, filter].filter((el) => el).join();
-
-    const root = funcs.getFolder(req);
-    const file = path.join(root, `/map/vtile/${widget}/${hash ? `${createHash('sha1').update(hash).digest('base64')}/` : ''}${z}/${x}/${y}.mvt`);
-
-    try {
-
-
-        if (!data?.table) {
-            return { message: `invalid ${widget ? 'widget' : 'dashboard'}: table not specified`, status: 400 };
-        }
-
-        const pkey = pg.pk?.[data?.table];
-
-        if (!pkey) {
-            return { message: `invalid ${widget ? 'widget' : 'dashboard'}: table pk not found (${data?.table})`, status: 400 };
+    if (cluster && !clusterExists[data.cluster]) {
+      const res = await fetch(
+        `https://cdn.softpro.ua/data/bi/${data.cluster}-ua.geojson`
+      );
+      if (res?.status !== 200) {
+        return {
+          message: `cluster file not found: ${cluster}-ua.json`,
+          status: 404,
+        };
+      }
+      try {
+        const geojson = await res.json();
+
+        const features = geojson?.features?.filter(
+          (el, idx, arr) =>
+            el?.geometry &&
+            arr
+              .map((item) => item.properties.name)
+              .indexOf(el.properties.name) === idx
+        ); // unique
+        if (!features?.length) {
+          return {
+            message: `cluster file empty: ${cluster}-ua.json`,
+            status: 400,
+          };
         }
-
-        // data param 
-        const { table, query: where = '1=1', metrics = [], cluster, clusterTable = {} } = data;
-        if (!clusterTable?.name) {
-            Object.assign(data, { clusterTable: { name: 'bi.cluster', title, query: `type='${data.cluster}'` } });
-        }
-
-        if (!clusterExists[data?.cluster]) {
-            // const res = await fetch('https://cdn.softpro.ua/data/bi/region-ua.json');
-            // if (res?.status !== 200) {
-            // }
-            // await pg.query(`insert into bi.cluster (title,type,geom) values()`);
-            // clusterExists[data?.cluster] = 1;
+        const { count = 0 } = await pg
+          .query(`select count(*)::int from bi.cluster where type=$1`, [
+            cluster,
+          ])
+          .then((res1) => res1.rows?.[0] || {});
+        if (count !== features?.length) {
+          // await pg.query(`delete from bi.cluster where type=$1`, [cluster]);
+          const values = features
+            ?.map(
+              (el) =>
+                `('${el.properties.name?.replace(/'/g, "''") || ''}', '${cluster}', ST_GeomFromGeoJSON('${JSON.stringify(el.geometry)}')::geometry)`
+            )
+            .join(',');
+          const { rowCount } = await pg.query(
+            `insert into bi.cluster (title,type,geom) values ${values} on conflict(title,type) do update set geom=excluded.geom`
+          );
+          log.info('bi/clusterVtile', { cluster, rowCount });
         }
+        clusterExists[cluster] = 1;
+      } catch (err) {
+        log.error('bi/clusterVtile', {
+          error: err.toString(),
+          filename: `${cluster}-ua.json`,
+        });
+        return {
+          message: `cluster file import error: ${cluster}-ua.json`,
+          status: 500,
+        };
+      }
+    }
 
-        if (!cluster) {
-            return { message: `invalid ${widget ? 'widget' : 'dashboard'}: cluster column not specified`, status: 400 };
-        }
+    if (!cluster) {
+      return {
+        message: `invalid ${widget ? 'widget' : 'dashboard'}: cluster column not specified`,
+        status: 400,
+      };
+    }
 
-        if (!metrics.length) {
-            return { message: `invalid ${widget ? 'widget' : 'dashboard'}: metric columns not found`, status: 400 };
-        }
+    if (!metrics.length) {
+      return {
+        message: `invalid ${widget ? 'widget' : 'dashboard'}: metric columns not found`,
+        status: 400,
+      };
+    }
 
-        // get sql
-        const { optimizedSQL } = filter || search
-            ? await funcs.getFilterSQL({ pg, table, filter, search })
-            : {};
+    // get sql
+    const { optimizedSQL } =
+      filter || search
+        ? await funcs.getFilterSQL({ pg, table, filter, search })
+        : {};
 
-        const q = `select "${cluster}" as name, sum("${metrics[0]}")::float as metric, b.* 
+    const q = `select "${cluster}" as name, sum("${metrics[0]}")::float as metric, b.* 
         from ${optimizedSQL ? `(${optimizedSQL})` : table} q 
             left join lateral (select "${pg.pk?.[clusterTable?.name]}" as id,
                 ${clusterTable?.geom || 'geom'} as geom from ${clusterTable?.name} 
@@ -94,14 +161,17 @@ export default async function clusterVtile(req, reply) {
         where ${where} group by 
         ${cluster}, b.id, b.${clusterTable?.geom || 'geom'}`;
 
-        if (query.sql === '1') return q;
+    if (query.sql === '1') return q;
 
-        const geomCol = parseInt(z, 10) < parseInt(pointZoom, 10) ? `ST_Centroid(${clusterTable?.geom || data?.geom || 'geom'})` : clusterTable?.geom || data?.geom || 'geom';
+    const geomCol =
+      parseInt(z, 10) < parseInt(pointZoom, 10)
+        ? `ST_Centroid(${clusterTable?.geom || data?.geom || 'geom'})`
+        : clusterTable?.geom || data?.geom || 'geom';
 
-        const bbox = mercator.bbox(+y, +x, +z, false/* , '900913' */);
-        const bbox2d = `'BOX(${bbox[0]} ${bbox[1]},${bbox[2]} ${bbox[3]})'::box2d`;
+    const bbox = mercator.bbox(+y, +x, +z, false /* , '900913' */);
+    const bbox2d = `'BOX(${bbox[0]} ${bbox[1]},${bbox[2]} ${bbox[3]})'::box2d`;
 
-        const q1 = `SELECT ST_AsMVT(q, 'bi', 4096, 'geom','row') as tile
+    const q1 = `SELECT ST_AsMVT(q, 'bi', 4096, 'geom','row') as tile
             FROM (
                 SELECT  
                 floor(random() * 100000 + 1)::int + row_number() over() as row,
@@ -119,25 +189,25 @@ export default async function clusterVtile(req, reply) {
                 limit 3000)q
             ) q`;
 
-        if (query.sql === '2') return q1;
+    if (query.sql === '2') return q1;
 
-        // auto Index
-        funcs.autoIndex({ table, columns: (metrics || []).concat([cluster]) });
+    // auto Index
+    funcs.autoIndex({ table, columns: (metrics || []).concat([cluster]) });
 
-        const { rows = [] } = await pg.query(q1);
+    const { rows = [] } = await pg.query(q1);
 
-        if (query.sql === '3') return rows.map((el) => el.tile);
+    if (query.sql === '3') return rows.map((el) => el.tile);
 
-        const buffer = Buffer.concat(rows.map((el) => Buffer.from(el.tile)));
+    const buffer = Buffer.concat(rows.map((el) => Buffer.from(el.tile)));
 
-        if (!nocache) {
-            await mkdir(path.dirname(file), { recursive: true });
-            await writeFile(file, buffer, 'binary');
-        }
-
-        return reply.headers(headers).send(buffer);
-    } catch (err) {
-        log.error('bi/clusterVtile', { error: err.toString(), query, params });
-        return { error: err.toString(), status: 500 };
+    if (!nocache) {
+      await mkdir(path.dirname(file), { recursive: true });
+      await writeFile(file, buffer, 'binary');
     }
-}
+
+    return reply.headers(headers).send(buffer);
+  } catch (err) {
+    log.error('bi/clusterVtile', { error: err.toString(), query, params });
+    return { error: err.toString(), status: 500 };
+  }
+}