@opengis/gis 0.1.81 → 0.2.0

package/server/routes/gis/services/legend.auto.js

@@ -0,0 +1,78 @@
+import { dataUpdate, getMeta, getSelectVal, yml2json } from "@opengis/fastify-table/utils.js";
+
+export default async function legendAuto({ params = {}, query = {}, user = {}, pg = pgClients.client }, reply) {
+    if (!params.id) {
+        return reply.status(400).send({ error: "not enough params: id", code: 400 });
+    }
+
+    const service = await pg.query(`SELECT source_path as table, style, legend as dblegend FROM gis.services where service_id=$1`, [params.id]).then(el => el.rows?.[0]);
+
+    if (!service) {
+        return reply.status(404).send({ error: "Service not found", code: 404 });
+    }
+
+    const { style, dblegend, table } = service;
+
+    if (!table) {
+        return reply.status(400).send({ error: "service table not specified", code: 400 });
+    }
+
+    if (dblegend && !query.nocache) {
+        return reply.status(400).send({ error: "legend already exists", code: 400 });
+    }
+
+    if (!style) {
+        return reply.status(400).send({ error: "empty service style", code: 400 });
+    }
+
+    const { colorAttr, iconAttr } = yml2json(style);
+
+    if (!colorAttr && !iconAttr) {
+        return reply.status(400).send({ error: "colorAttr / iconAttr not specified", code: 400 });
+    }
+
+    const { columns = [] } = await getMeta({ pg, table });
+
+    const attr = columns.find(col => col.name === (colorAttr || iconAttr));
+
+    if (!attr?.name) {
+        return reply.status(404).send({ error: "attribute column not found", code: 404 });
+    }
+
+    const values = await pg.query(`select array_agg(distinct "${attr.name}") from ${table}`).then(el => el.rows?.[0]?.array_agg || []);
+    const arr = await getSelectVal({ pg, name: `${table}.${attr.name}`, table, values, ar: true });
+
+    const colors = {
+        1: "#FFCF1F1F",
+        2: "#FF1FCF2D",
+        3: "#FF1F77CF"
+    };
+
+    const colorKeys = Object.keys(colors).map(Number);
+
+    const legend = arr
+        ? arr.map((el, idx) => ({
+            name: el.id,
+            label: el.text,
+            icon: iconAttr ? el.icon : undefined,
+            color: colorAttr ? (el.color || colors[colorKeys[idx % colorKeys.length]]) : undefined,
+        }))
+        : values.map((el, idx) => ({
+            name: el,
+            label: el,
+            icon: undefined,
+            color: colorAttr ? (colors[colorKeys[idx % colorKeys.length]]) : undefined,
+        }));
+
+    const res = await dataUpdate({
+        pg,
+        table: 'gis.services',
+        id: params.id,
+        data: {
+            legend
+        },
+        uid: user.uid,
+    });
+
+    return reply.status(200).send(res);
+}

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

@@ -37,9 +37,9 @@ export default async function mapFormat(req, reply) {
         }
     }
 
-    let source_path, attributes, tpl, cardInterface;
+    let source_path, tpl, cardInterface, card, template;
     if (service) {
-        ({ source_path, attributes, interface: cardInterface } = service);
+        ({ source_path, interface: cardInterface, card, template } = service);
     } else {
         // git
         tpl = await getTemplate('map', map);
@@ -48,11 +48,12 @@ export default async function mapFormat(req, reply) {
             return reply.status(404).send('template not found');
         };
         source_path = matchedLayer.source_path;
-        attributes = matchedLayer.card;
+        card = matchedLayer.card;
+        template = matchedLayer.template;
 
     }
 
-    const columns = attributes;
+    const columns = card;
     if (!source_path) return reply.status(404).send('missing source_path');
 
     const pk = pg.pk?.[source_path];
@@ -83,32 +84,40 @@ export default async function mapFormat(req, reply) {
         if (excluded.includes(col.name)) continue;
         if (col.hidden_card === true) continue;
 
-        const name = col.ua || col.name;
+        const name =  col.label || col.ua || col.name;
         let value;
         value = fullRow[`${col.name}_data`]?.text
             || fullRow[`${col.name}_text`]
-            || fullRow[col.name]
-            || '-';
+            || fullRow[col.name]            ;
 
         if (col.format === 'date' && fullRow[col.name]) {
             // const dt = formatDate(fullRow[col.name], { hash: { format: 'dd.mm.yy' } });
             const dt = await handlebars.compile(`{{formatDate "${fullRow[col.name]}"}}`)({ format: 'dd.mm.yy' });
             value = dt;
         }
-
+        if (!value) continue;
         result.push(`<div class="grid grid-cols-1 gap-1 py-3 sm:grid-cols-3 sm:gap-4 even:bg-gray-50 text-[12px]">
             <dt class="text-gray-900">${name}</dt>
-            <dd class="text-gray-700 sm:col-span-2">${value}</dd>
+            <dd class="text-gray-700 sm:col-span-2">${value|| '-'}</dd>
         </div>`);
     }
 
-    const html = `<dl class="divide-y divide-gray-100 py-[5px]">${result.join('')}</dl>`;
+    const htmlTemplate = pg?.pk?.['admin.template']
+        ? await pg.query('select body from admin.templates where name=$1 limit 1').then(el => el.rows?.[0]?.body)
+        : null;
+
+    const html1 = await handlebars.compile(htmlTemplate || 'template not found')(fullRow);
+
+    const html = template
+        ? html1
+        : `<dl class="divide-y divide-gray-100 py-[5px]">${result.join('')}</dl>`;
 
     const res = {
         time: Date.now() - time,
         id,
         rows: fullRow,
         columns,
+        template,
         html
     };
     if (service) {

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

@@ -31,7 +31,8 @@ export default async function markerIconApi(req, reply) {
   const iconPath = path.join(fileIconDir, params?.data);
 
   if (fs.existsSync(iconPath)) {
-    return fs.createReadStream(iconPath);
+    const buffer = fs.readFileSync(iconPath); // works for small files same as stream, but also unit-test-friendly
+    return reply.type('image/png').send(buffer);
   }
 
   await downloadImage(`https://data.softpro.ua/api-user/marker/${params.data}`, iconPath).catch(err => {

package/server/routes/map/index.mjs

@@ -13,10 +13,18 @@ import mapFormat from './controllers/mapFormat.js';
 import maps from './controllers/maps.js';
 import markerIconApi from './controllers/marker_icon.js';
 
+import getMap from './maps/get.map.js';
+import addMap from './maps/add.map.js';
+import delMap from './maps/del.map.js';
+
+import getWidget from './widgets/get.widget.js';
+import addWidget from './widgets/add.widget.js';
+import delWidget from './widgets/del.widget.js';
+
 const schemaInfo = {
   type: 'object',
   properties: {
-    params: {
+    publicParams: {
       slug: {
         type: 'string',
       },
@@ -37,29 +45,42 @@ const schemaInfo = {
   },
 };
 
-const policy = ['public'];
+const publicParams = { config: { policy: 'L0' }, schema: schemaInfo }; // * L0 === public
+const privilegedParams = { config: { policy: 'L1', role: 'admin' }, schema: schemaInfo }; // ? just auth or admin
 
 export default async function route(app) {
-  app.get('/maps', { config: { policy }, schema: schemaInfo }, maps);
-  app.get('/map/:slug', { config: { policy }, schema: schemaInfo }, map);
-  app.get('/map-tiles/:slug/:z/:y/:x', { config: { policy }, schema: schemaInfo }, mapTiles);
-  app.get('/map-features/:slug/:id', { config: { policy }, schema: schemaInfo }, mapFeatures);
-  app.get('/map-features-point/:slug', { config: { policy }, schema: schemaInfo }, mapFeatures);
+  app.get('/gis-map/:id?', publicParams, getMap);
+  app.post('/gis-map/:id?', privilegedParams, addMap);
+  app.put('/gis-map/:id', privilegedParams, addMap);
+  app.delete('/gis-map/:id', privilegedParams, delMap);
+
+  app.get('/gis-widget/:map/:id?', publicParams, getWidget);
+  app.post('/gis-widget/:map/:id?', privilegedParams, addWidget);
+  app.put('/gis-widget/:map/:id', privilegedParams, addWidget);
+  app.delete('/gis-widget/:map/:id', privilegedParams, delWidget);
+
+  app.get('/maps', publicParams, maps);
+  app.get('/map/:slug', publicParams, map);
+  app.get('/map-tiles/:slug/:z/:y/:x', publicParams, mapTiles);
+  app.get('/map-features/:slug/:id', publicParams, mapFeatures);
+  app.get('/map-features-point/:slug', publicParams, mapFeatures);
 
-  app.get('/map-catalog', { config: { policy }, schema: schemaInfo }, mapCatalog);
-  app.get('/map-catalog/:service/:attr', { config: { policy }, schema: schemaInfo }, mapCatalogAttribute);
-  app.get('/layer-rtile/:id/:z/:y/:x', { config: { policy }, schema: {} }, rtile);
-  app.get('/layer-vtile/:id/:z/:y/:x', { config: { policy }, schema: schemaInfo }, vtile);
+  app.get('/map-catalog', publicParams, mapCatalog);
+  app.get('/map-catalog/:service/:attr', publicParams, mapCatalogAttribute);
+  app.get('/layer-rtile/:id/:z/:y/:x', publicParams, rtile);
+  app.get('/layer-vtile/:id/:z/:y/:x', publicParams, vtile);
 
   if (!app.hasRoute({ method: 'GET', url: '/api/vtile/:layer/:lang/:z/:y/:x', })) {
     console.log("\x1b[34m%s\x1b[0m", 'add vtile from gis');
-    app.get('/vtile/:layer/:lang/:z/:y/:x', { config: { policy }, schema: schemaInfo }, vtile1);
+    app.get('/vtile/:layer/:lang/:z/:y/:x', publicParams, vtile1);
   }
   if (!app.hasRoute({ method: 'GET', url: '/api/gis-layer-list', })) {
     console.log("\x1b[34m%s\x1b[0m", 'add gis-layer-list from gis');
-    app.get('/gis-layer-list', { config: { policy }, }, layerList);
+    app.get('/gis-layer-list', publicParams, layerList);
   }
 
-  app.get('/marker-icon/*', { config: { policy }, schema: {} }, markerIconApi);
-  app.get('/map-format', { config: { policy }, schema: {} }, mapFormat);
+  app.get('/gis-icon/*', publicParams, markerIconApi);
+  app.get('/icon/*', publicParams, markerIconApi);
+  app.get('/marker-icon/*', publicParams, markerIconApi);
+  app.get('/map-format', publicParams, mapFormat);
 }

package/server/routes/map/maps/add.map.js

@@ -0,0 +1,42 @@
+import { dataInsert, dataUpdate, pgClients } from "@opengis/fastify-table/utils.js";
+export default async function addMap({
+    method, params = {}, body, pg = pgClients.client, user = {},
+}, reply) {
+    const { uid } = user;
+
+    if (!uid) {
+        return reply.status(401).send('unauthorized');
+    }
+
+    if (method === 'POST') {
+        if (!body?.name) {
+            return reply.status(400).send('not enough body params: name');
+        }
+
+        if (!body?.map_key) {
+            return reply.status(400).send('not enough body params: map_key');
+        }
+
+        const { rows = [] } = await dataInsert({
+            pg,
+            id: params.id,
+            table: 'gis.maps',
+            data: body,
+            uid,
+        });
+        return reply.status(200).send(rows[0]);
+    }
+
+    if (!params.id) {
+        return reply.status(400).send('not enough params: id');
+    }
+
+    const row = await dataUpdate({
+        pg,
+        id: params.id,
+        table: 'gis.maps',
+        data: body,
+        uid,
+    });
+    return reply.status(200).send(row);
+}

package/server/routes/map/maps/del.map.js

@@ -0,0 +1,19 @@
+import { dataDelete, pgClients } from "@opengis/fastify-table/utils.js";
+
+export default async function delMap({
+    params = {}, pg = pgClients.client, user = {},
+}, reply) {
+    const { uid } = user;
+
+    if (!uid) {
+        return reply.status(401).send('unauthorized');
+    }
+
+    const row = await dataDelete({
+        pg,
+        id: params.id,
+        table: 'gis.maps',
+        uid,
+    });
+    return reply.status(200).send(row);
+}

package/server/routes/map/maps/get.map.js

@@ -0,0 +1,65 @@
+import path from 'node:path';
+import yaml from 'js-yaml';
+import { getMeta, getTemplate, pgClients, getTemplates, getTemplateSync } from "@opengis/fastify-table/utils.js";
+
+const table = 'gis.maps';
+
+const columnType = {
+    text: 'text',
+    date: 'date',
+    bool: 'yes/no',
+    numeric: 'number',
+    integer: 'number',
+    'timestamp without time zone': 'date',
+    'timestamp with time zone': 'date',
+};
+
+export default async function getMap({ params = {}, pg = pgClients.client }, reply) {
+    const { columns = [] } = await getMeta({ pg, table }) || {};
+
+    const fields = columns.map(({ name, dataTypeID, title }) => ({ name, type: columnType[pg.pgType?.[dataTypeID] || 'text'], label: title || name }));
+    const mapList = getTemplates('map').map(el => el[0]);
+    
+    const rows = pg.pk?.['gis.maps'] ? await pg.query(
+        `SELECT map_id as id, * FROM gis.maps where ${params.id ? 'map_id=$1' : '1=1'}`,
+        [params.id].filter(Boolean),
+    ).then(el => el.rows || []) : [];
+
+    if (params.id && !mapList.includes(params.id) && !rows[0]) { 
+        return { status: 404, message: 'map not found'}
+    }
+    
+    if (params.id) {
+        const map = rows[0] || {};
+        const loadTemplate = await getTemplate('map',  params.id) || await getTemplate('map',  map.map_key);       
+        
+        const obj = loadTemplate;
+
+        if (Array.isArray(obj?.layers) && typeof obj?.layers?.[0] === 'string') {
+            const layers = await Promise.all(obj.layers.map(async (layer) => {
+                const layerData = await getTemplate('layer', layer);
+                const serviceData = layerData || await pg.query('select service_id as id, * from gis.services where service_id=$1', [layer]).then(el => el.rows?.[0]);
+                serviceData.style = yaml.load(serviceData.style);
+                return { ...serviceData, id: layer,visible:true };
+            }));
+            return { ...rows[0],...obj, layers };
+        }
+
+        return reply.status(200).send({ ...rows[0], ...loadTemplate });
+    }
+
+    if (params.id && !rows.length) {
+        return reply.status(404).send('map not found');
+    }
+
+    if (params.id) {
+        return reply.status(200).send({ ...rows[0], fields });
+    }
+
+    maps.filter(el => Object.keys(el).length > 1).forEach(el => rows.push(el));    
+    return reply.status(200).send({
+        template,
+        rows,
+        fields,
+    });
+}

package/server/routes/map/vtile1.js

@@ -5,6 +5,7 @@ const headers = {
 import Sphericalmercator from '@mapbox/sphericalmercator';
 const mercator = new Sphericalmercator({ size: 256 });
 import { getTemplate, getMeta, getFilterSQL } from '@opengis/fastify-table/utils.js';
+import yaml from 'js-yaml';
 
 export default async function vtile({ params = {}, query, pg, user }, reply) {
     const { y, z } = params;
@@ -21,10 +22,18 @@ export default async function vtile({ params = {}, query, pg, user }, reply) {
     const mapData = map ? await getTemplate('map', map) : {};
     const mapStyle = mapData?.widgets?.find?.(el => el.type === 'attribute')?.config?.layer?.style;
 
-    const geom = data1?.geometry_column || 'geom';
-    const table = data?.table_name || data1?.source_path;
-    const style = mapStyle || data?.style || data1?.style;
-    const filterList = data?.filter_list || data1?.filters;
+    const geom = data?.geometry_column
+        || data1?.geometry_column
+        || 'geom';
+    const table = data?.source_path
+        || data?.table_name
+        || data1?.source_path;
+    const style = mapStyle
+        || data?.style
+        || (data1?.style ? yaml.load(data1?.style) : null);
+    const filterList = data?.filters
+        || data?.filter_list
+        || data1?.filters;
     const layerQuery = data?.query || data1?.query;
 
     // bbox

package/server/routes/map/widgets/add.widget.js

@@ -0,0 +1,39 @@
+import { dataInsert, dataUpdate, pgClients } from "@opengis/fastify-table/utils.js";
+export default async function addWidget({
+    method, params = {}, body, pg = pgClients.client, user = {},
+}, reply) {
+    const { uid } = user;
+
+    if (!uid) {
+        return reply.status(401).send('unauthorized');
+    }
+
+    if (!params.map) {
+        return reply.status(400).send('not enough params: map id');
+    }
+
+    if (method === 'PUT' && !params.id) {
+        return reply.status(400).send('not enough params: id');
+    }
+
+    if (method === 'POST') {
+        Object.assign(body, { map_id: params.map });
+        const { rows = [] } = await dataInsert({
+            pg,
+            id: params.id,
+            table: 'gis.widgets',
+            data: body,
+            uid,
+        });
+        return reply.status(200).send(rows[0]);
+    }
+
+    const row = await dataUpdate({
+        pg,
+        id: params.id,
+        table: 'gis.widgets',
+        data: body,
+        uid,
+    });
+    return reply.status(200).send(row);
+}

package/server/routes/map/widgets/del.widget.js

@@ -0,0 +1,23 @@
+import { dataDelete, pgClients } from "@opengis/fastify-table/utils.js";
+
+export default async function delWidget({
+    params = {}, pg = pgClients.client, user = {},
+}, reply) {
+    const { uid } = user;
+
+    if (!uid) {
+        return reply.status(401).send('unauthorized');
+    }
+
+    if (!params.map) {
+        return reply.status(400).send('not enough params: map id');
+    }
+
+    const row = await dataDelete({
+        pg,
+        id: params.id,
+        table: 'gis.widgets',
+        uid,
+    });
+    return reply.status(200).send(row);
+}

package/server/routes/map/widgets/get.widget.js

@@ -0,0 +1,41 @@
+import { getMeta, pgClients } from "@opengis/fastify-table/utils.js";
+
+const table = 'gis.widgets';
+
+const columnType = {
+    text: 'text',
+    date: 'date',
+    bool: 'yes/no',
+    numeric: 'number',
+    integer: 'number',
+    'timestamp without time zone': 'date',
+    'timestamp with time zone': 'date',
+};
+
+export default async function getWidget({ params = {}, pg = pgClients.client }, reply) {
+    if (!params.map) {
+        return reply.status(400).send('not enough params: map id');
+    }
+
+    const { columns = [] } = await getMeta({ pg, table }) || {};
+
+    const fields = columns.map(({ name, dataTypeID, title }) => ({ name, type: columnType[pg.pgType?.[dataTypeID] || 'text'], label: title || name }));
+
+    const rows = pg.pk?.['gis.maps'] && pg.pk?.['gis.widgets'] ? await pg.query(
+        `SELECT widget_id as id, * FROM gis.widgets where map_id=$1 and ${params.id ? 'widget_id=$2' : '1=1'}`,
+        [params.map, params.id].filter(Boolean),
+    ).then(el => el.rows || []) : [];
+
+    if (params.id && !rows.length) {
+        return reply.status(404).send('widget not found');
+    }
+
+    if (params.id) {
+        return reply.status(200).send({ ...rows[0], fields });
+    }
+
+    return reply.status(200).send({
+        rows,
+        fields,
+    });
+}