@opengis/gis 0.2.0 → 0.2.1

package/server/routes/gis/services/get.services.col.js

@@ -1,24 +1,32 @@
-import { getMeta, pgClients, yml2json } from "@opengis/fastify-table/utils.js";
-
-
+import { metaFormat, pgClients } from "@opengis/fastify-table/utils.js";
 
 export default async function getServicesCol({ params = {}, pg = pgClients.client }, reply) {
-
-
     const row = await pg.query(`
            SELECT 
-               service_id, source_path
+               service_id, source_path, attributes
            FROM gis.services where ${params.id ? 'service_id=$1' : '1=1'}
        `, [params.id].filter(Boolean)).then(el => el.rows[0] || {});
 
-    if (!row.source_path) return { status: 404, message: 'source not found' }
+    if (!row.source_path) {
+        return reply.status(404).send({ code: 404, message: 'source not found' });
+    }
+
     const fields = await pg.query(` SELECT *  FROM ${row.source_path} limit 0`).then(el => el.fields);
     const field = fields.find(el => el.name == params.col);
-    if (!field) return {
-        status: 404, message: { error: 'col not  found', fields }
+
+    if (!field) {
+        return reply.status(404).send({ message: { error: 'column not found', fields }, code: 404 });
     }
 
-    const rows = await pg.query(`SELECT ${params.col} as id, count(*) FROM ${row.source_path} where ${params.col} is not null group by ${params.col}  order by count(*) desc limit 10`).then(el => el.rows);
+    const rows = await pg.query(`SELECT ${params.col}::text as id, ${params.col}, count(*) FROM ${row.source_path} 
+        where ${params.col} is not null group by ${params.col} order by count(*) desc limit 10`
+    ).then(el => el.rows || []);
+
+    const cls = row.attributes?.filter?.((col) => col.name && col.data && ["select", "badge", "tags"].includes(col.format)).reduce((acc, curr) => ({ ...acc, [curr.name]: curr.data }), {}) || {};
+
+    await metaFormat({ rows, table: row.source_path, cls });
+
+    const rows1 = rows.map(row => ({ ...row[`${params.col}_data`], ...row, [`${params.col}_data`]: undefined, [params.col]: undefined }));
 
-    return { rows, field, fields }
+    return reply.status(200).send({ rows: rows1, field, fields });
 }

package/server/routes/gis/services/get.services.js

@@ -1,7 +1,5 @@
 import { dataUpdate, getMeta, pgClients, yml2json } from "@opengis/fastify-table/utils.js";
 
-const table = 'gis.services';
-
 const columnType = {
     text: 'text',
     date: 'date',
@@ -13,22 +11,34 @@ const columnType = {
 };
 
 export default async function getServices({ params = {}, pg = pgClients.client }, reply) {
-
-
     const rows = await pg.query(`
         SELECT 
-            service_id, service_key, name, description, keywords, category, holder, group_id, service_type, 
+            service_id, service_key, name, description, keywords, category, holder, group_id, b.group_name, service_type, 
             source_type, service_url, source_path, query, geom_type, geometry_column, sql_list, attributes, filters, 
             popup, style, legend, card, srid, bbox::box2d as extent, st_asgeojson(bbox)::json as bbox, st_asgeojson(center)::json as center, is_active as enabled, is_public, is_active, is_downloadable, metadata, 
             metadata_url, thumbnail_url, created_by, updated_by, updated_at, created_at, template 
-        FROM gis.services where ${params.id ? 'service_id=$1' : '1=1'}
+        FROM gis.services a
+        left join lateral (select group_name from gis.group_list where group_id=a.group_id)b on 1=1
+        where ${params.id ? 'service_id=$1' : '1=1'}
     `, [params.id].filter(Boolean)).then(el => el.rows || []);
 
-    if (params.id && rows[0]?.template) {
+    if (params.id && !rows.length) {
+        return reply.status(404).send('service 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 html = await pg.query('select body from admin.templates where template_id=$1', [params.id]).then(el => el.rows?.[0]?.body);
         Object.assign(rows[0], { html });
     }
 
+    rows.filter(row => row.source_path).forEach(row => {
+        Object.assign(row, { count: totals[row.source_path] || 0 });
+    });
+
     const { columns = [] } = await getMeta({ pg, table: rows[0].source_path }) || {};
 
     const fields = columns.map(({ name, dataTypeID, title }) => ({ name, type: columnType[pg.pgType?.[dataTypeID] || 'text'], label: title || name }));
@@ -43,17 +53,20 @@ export default async function getServices({ params = {}, pg = pgClients.client }
         Object.assign(row, { center: centers[row.service_id] });
     }));
 
-    rows.forEach(row => Object.assign(row, { style: row.style ? yml2json(row.style) : undefined }));
-    rows.forEach(row => Object.assign(row, { center: row.center?.coordinates }));
+    rows.forEach(row => Object.assign(row, {
+        center: row.center?.coordinates,
+        style: row.style ? yml2json(row.style) : undefined
+    }));
     rows.filter(row => row.extent).forEach(row => Object.assign(row, {
         extent: row.extent.match(/BOX\(([^)]+)\)/)?.[1]
             ?.replace?.(/ /g, ",")
             ?.split?.(",")
     }));
 
-    if (params.id && !rows.length) {
-        return reply.status(404).send('service not found');
-    }
+
+    rows.filter(row => row.filters).forEach(row => Object.assign(row, {
+        filters: row.filters.map(filter => ({ ...filter, api: '/api/suggest/' + row.source_path + ':' + filter.name + (filter.data && filter.name !== filter.data ? `?sel=${filter.data}` : '') }))
+    }));
 
     if (params.id) {
         return reply.status(200).send({ ...rows[0], fields });

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

@@ -10,15 +10,27 @@ export default async function layerList({
     }
 
     const q = `
-    select service_id as id, name, category, style, bbox::box2d as extent, st_asgeojson(bbox)::json as geom, null as url, coalesce(service_type, 'vtile') as service from gis.services where is_active and ${!user.uid ? 'is_public' : '1=1'}
+    select service_id as id, name, category, style, bbox::box2d as extent, st_asgeojson(bbox)::json as geom, null as url, coalesce(service_type, 'vtile') as service, group_id,
+        popup, card, filters, style, source_path
+    from gis.services where is_active and ${!user.uid ? 'is_public' : '1=1'}
     union all 
-    select ogc_service_id as id, name, category, null as style, geom::box2d as extent, st_asgeojson(geom)::json as geom, url, 'ogc' as service from gis.ogc_service where enabled and ${!user.uid ? 'ispublic' : '1=1'}
+    select ogc_service_id as id, name, category, null as style, geom::box2d as extent, st_asgeojson(geom)::json as geom, url, 'ogc' as service, group_id,
+        null as popup, null as card, null as filters, null as style, table_name as source_path
+    from gis.ogc_service where enabled and ${!user.uid ? 'ispublic' : '1=1'}
     `;
 
     if (user.uid && sql) return q;
 
     const rows = await pg.query(q).then(el => el.rows || []);
 
+    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 || {}) : {};
+    rows.filter(row => row.source_path).forEach(row => Object.assign(row, { count: totals[row.source_path] || 0 }));
+
+    const groupIds = rows.map(el => el.group_id).filter(Boolean);
+    const groupNames = groupIds.length ? await pg.query('select json_object_agg(group_id,group_name) from gis.group_list where group_id=any($1)', [groupIds]).then(el => el.rows?.[0]?.json_object_agg || {}) : {};
+    rows.filter(el => el.group_id).forEach(row => Object.assign(row, { group_name: groupNames[row.group_id] }));
+
     if (!rows.length) {
         return reply.status(200).send([]);
     }

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

@@ -1,4 +1,4 @@
-import { config, getMeta, getFilterSQL, getTemplate, metaFormat, pgClients } from '@opengis/fastify-table/utils.js';
+import { getMeta, getFilterSQL, getTemplate, metaFormat, pgClients, yml2json } from '@opengis/fastify-table/utils.js';
 
 const layerMetaColumns = ['id', 'name', 'label', 'source', 'table', 'pk', 'geomColumn', 'srid', 'cls', 'htmls'];
 
@@ -22,10 +22,19 @@ export default async function mapFeaturesPoint({ pg = pgClients.client, params =
 
     const index = loadTemplate?.find?.(el => el[0].split('.').shift() === 'index')?.[1];
 
-    const layers = !index
+    const layers1 = !index
         ? loadTemplate?.layers
         : loadTemplate?.filter?.(el => el[0].split('.').shift() !== 'index')?.map(el => ({ ...el[1], id: el[0].replace('.yml', '').replace('.json', '') }));
 
+    const serviceLayers = await Promise.all(layers1.filter(el => typeof el === 'string').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]);
+        serviceData.style = yml2json(serviceData.style);
+        return { ...serviceData, id: layer, visible: true };
+    }));
+
+    const layers = layers1.filter(el => el && typeof el === 'object').concat(serviceLayers);
+
     if (!layers?.length) {
         return reply.status(404).send('map layers not found');
     }

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

@@ -1,10 +1,7 @@
-import { pgClients, getTemplate, handlebars } from "@opengis/fastify-table/utils.js";
-import { attachClassifiers } from '../../gis/registers/funcs/classifiers.js';
-
-const pg = pgClients.client;
+import { pgClients, getTemplate, handlebars, metaFormat } from "@opengis/fastify-table/utils.js";
 
 export default async function mapFormat(req, reply) {
-    const { query } = req;
+    const { pg = pgClients.client, query = {} } = req;
     const { layer, id, map } = query;
     const time = Date.now();
 
@@ -65,30 +62,30 @@ export default async function mapFormat(req, reply) {
     const excluded = ["created_by", "created_at", "updated_by", "geom", "id", "uid", "updated_at", "cdate", "editor_date", "editor_id"];
     const filteredColumns = columnNames.filter(name => !excluded.includes(name));
 
-    const {
-        rows: [row]
-    } = await pg.query(
+    const rows = await pg.query(
         `SELECT ${pk} as "id", geom::json, ${filteredColumns.map(n => `"${n}"`).join(", ")} FROM ${source_path} WHERE ${pk} = $1`,
         [id]
-    );
+    ).then(el => el.rows || []);
 
-    if (!row) return reply.status(404).send('object not found');
+    if (!rows.length) return reply.status(404).send('object not found');
 
     const classifiers = columns
         .filter(col => col.data && ["select", "badge", "tags"].includes(col.format))
-        .map(col => ({ name: col.name, classifier: col.data }));
+        .reduce((acc, curr) => ({ ...acc, [curr.name]: curr.data }), {});
+
+    await metaFormat({ rows, table: source_path, cls: classifiers, sufix: false });
+    const fullRow = rows[0];
 
-    const fullRow = await attachClassifiers(row, classifiers);
     const result = [];
     for await (const col of columns) {
         if (excluded.includes(col.name)) continue;
         if (col.hidden_card === true) continue;
 
-        const name =  col.label || 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' } });
@@ -98,12 +95,12 @@ export default async function mapFormat(req, reply) {
         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 htmlTemplate = pg?.pk?.['admin.template']
-        ? await pg.query('select body from admin.templates where name=$1 limit 1').then(el => el.rows?.[0]?.body)
+        ? await pg.query('select body from admin.templates where name=$1 limit 1', [template || id]).then(el => el.rows?.[0]?.body)
         : null;
 
     const html1 = await handlebars.compile(htmlTemplate || 'template not found')(fullRow);

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

@@ -80,7 +80,7 @@ export default async function vtile({ pg = pgClients.client, params = {}, query
         return reply.status(404).send('layer table not found');
     }
 
-    const cls = await getColumnCLS(table);
+    const cls = getColumnCLS(table);
 
     const meta = await getMeta({ pg, table });
     const { columns = [] } = meta || {};

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

@@ -19,30 +19,34 @@ export default async function getMap({ params = {}, pg = pgClients.client }, rep
 
     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 && !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 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]);
+                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 { ...serviceData, id: layer, visible: true };
             }));
-            return { ...rows[0],...obj, layers };
+            return { ...rows[0], ...obj, layers };
         }
 
         return reply.status(200).send({ ...rows[0], ...loadTemplate });
@@ -56,9 +60,7 @@ export default async function getMap({ params = {}, pg = pgClients.client }, rep
         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

@@ -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;
@@ -55,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);
 
@@ -90,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