@opengis/gis 0.1.82 → 0.2.1

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,31 +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('/gis-icon/*', { config: { policy }, schema: {} }, markerIconApi);
-  app.get('/icon/*', { config: { policy }, schema: {} }, markerIconApi);
-  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,67 @@
+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' }
+    }
+
+    const totals = pg.queryCache ? await pg.queryCache(`select json_object_agg(oid::regclass, reltuples) from pg_class`)
+        .then(el => el.rows?.[0]?.json_object_agg || {}) : {};
+
+    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, *, st_asgeojson(bbox)::json as bbox, st_asgeojson(center)::json as center from gis.services where service_id=$1', [layer]).then(el => el.rows?.[0]);
+                Object.assign(serviceData, { count: totals[serviceData.source_path || ''] || 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 });
+    }
+
+    return reply.status(200).send({
+        rows,
+        fields,
+    });
+}

package/server/routes/map/vtile1.js

@@ -4,9 +4,11 @@ const headers = {
 };
 import Sphericalmercator from '@mapbox/sphericalmercator';
 const mercator = new Sphericalmercator({ size: 256 });
-import { getTemplate, getMeta, getFilterSQL } from '@opengis/fastify-table/utils.js';
+import { getColumnCLS, getTemplate, getMeta, getFilterSQL } from '@opengis/fastify-table/utils.js';
 import yaml from 'js-yaml';
 
+const propsCache = {};
+
 export default async function vtile({ params = {}, query, pg, user }, reply) {
     const { y, z } = params;
     const x = params.x.split('.')[0] - 0;
@@ -22,10 +24,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 || yaml.load(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
@@ -47,6 +57,32 @@ export default async function vtile({ params = {}, query, pg, user }, reply) {
         return el.type?.[0] === '_' ? `${el.name}[1] as ${el.name}` : `${el.name}${['int4'].includes(el.type) ? '::text' : ''}`;
     });
 
+    const obj = (data1.attributes || []).concat(data1.card || []).concat(data1.popup || []).filter(el => el.data).reduce((acc, curr) => ({ ...acc, [curr.name]: curr.data }), {});
+
+    const propsWithCls = propsCache[layer] ?? await Promise.all(props.map(async (key, idx) => {
+        const { name, type, sql } = getColumnCLS(table, key) || {};
+        if (name && type === 'cls') {
+            return `(select name from admin.cls where parent='${name}' and code::text="${key}"::text limit 1) as "${key}_text","${key}"::text`;
+        }
+        if (type === 'select' && sql) {
+            const { fields = [] } = await pg.query(sql + ' limit 0');
+            return `(select "${fields[1].name}" from (${sql})s${idx} where "${fields[0].name}"="${key}" limit 1) as "${key}_text","${key}"::text`
+        }
+
+        if (obj[key]) {
+            const clsdata = await pg.query('select name, type, data as sql from admin.cls where name=$1', [obj[key]]).then(el => el.rows?.[0] || {});
+            if (clsdata.name && clsdata.type === 'json') {
+                return `(select name from admin.cls where parent='${clsdata.name}' and code::text="${key}"::text limit 1) as "${key}_text","${key}"::text`;
+            }
+            if (clsdata.type === 'sql' && clsdata.sql) {
+                const { fields = [] } = await pg.query(clsdata.sql + ' limit 0');
+                return `(select "${fields[1].name}" from (${clsdata.sql})s${idx} where "${fields[0].name}"="${key}" limit 1) as "${key}_text","${key}"::text`
+            }
+        }
+        return `"${key}"::text`;
+    }));
+    if (!propsCache[layer]) { propsCache[layer] = propsWithCls; }
+
     const geomCol = (style?.type === 'point' ? `ST_Centroid(${geom})` : null)
         || (parseInt(z, 10) < parseInt(query.pointZoom || style?.pointZoom || style?.iconZoom || '0', 10) ? `ST_Centroid(${geom})` : geom);
 
@@ -82,7 +118,7 @@ export default async function vtile({ params = {}, query, pg, user }, reply) {
 
                         floor(random() * 100000 + 1)::int + row_number() over() as row,
 
-                        ${props?.length ? `${props.map(el => `"${el}"::text`).join(',')},` : ''}
+                        ${props?.length ? `${propsWithCls.join(',')},` : ''}
 
                         ${pkey} as  id, 
                         ST_AsMVTGeom(st_transform(${geomCol},3857),ST_TileEnvelope(${z},${y},${x})::box2d,4096,256,false) geom

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,
+    });
+}