@opengis/gis 0.1.82 → 0.2.1

package/server/routes/gis/ogc/map.info.point.js

@@ -0,0 +1,120 @@
+import { pgClients, handlebars, getMeta, getTemplate, getFilterSQL } from "@opengis/fastify-table/utils.js";
+
+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 mapInfoPoint(req, reply) {
+    const { pg = pgClients.client, query = {} } = req;
+    const { x, y, layers, index = 0 } = query;
+    const time = Date.now();
+
+    if (!x || !y || !layers) {
+        return reply.status(400).send('not enough query params: x, y, layers are required');
+    }
+
+    const rows = pg?.pk?.['gis.ogc_service'] ? await pg.query(`select * from gis.ogc_service WHERE enabled and table_name is not null and ogc_service_id = any($1)`, [layers.split(',')]).then(el => el.rows || []) : [];
+
+    if (!rows.length) {
+        return reply.status(404).send('layers not found');
+    }
+
+    const point = `srid=4326;point(${x} ${y})`; // 30, 50
+
+    const srids = pg.queryCache ? await pg.queryCache('select json_agg(srid) as srids from spatial_ref_sys').then(el => el.rows?.[0]?.srids || {}) : {};
+
+    await Promise.all(rows.map(async (layer, idx) => {
+        const { table_name: source, ogc_service_id: layerId } = layer;
+        const loadTable = await getTemplate('table', source);
+        const meta = await getMeta({ pg, table: loadTable?.table || source });
+        const { geom = 'geom' } = meta || {};
+        const { table = source, columns = meta?.columns } = loadTable || {};
+        const { srid, x } = await pg.query(`select st_srid(${geom}) as srid, st_x(st_pointonsurface(${geom})) as x from ${table} where geom is not null limit 1`).then(el => el.rows?.[0] || {});
+
+        const cls = columns
+            ?.filter(el => el.name && el.data)
+            ?.reduce?.((acc, curr) => ({ ...acc, [curr.name]: curr.data }), {});
+
+        const pk = pg.pk?.[table] || loadTable?.key;
+
+        const { optimizedSQL } = await getFilterSQL({ pg, table: source, query: layer?.query });
+
+        Object.assign(layer, {
+            layer: (layerId || idx.toString())?.replace?.(/'/g, "''"),
+            table,
+            pk,
+            cls,
+            geomColumn: srid === 4326 ? geom : `st_transform(${geom},4326)`,
+            optimizedSQL,
+            srid,
+            step: srids?.includes?.(srid - 0) && srid !== 4326 && x > 100 ? 10 : 0.0002,
+        });
+    }));
+
+    const unique = rows.filter((el, idx, arr) => el.table && arr.map((item) => item.table).indexOf(el.table) === idx);
+
+    const qList = unique.map((el) => ({
+        query: `select ${el.pk}::text as pk, '${el.layer}' as layer, '${el.table}' as table,
+    row_to_json(t) as data, 
+    st_distance(${el.geomColumn},'${point.replace(/'/g, "''")}') as distance,
+    st_asgeojson(${el.geomColumn})::json as geom from (${el.optimizedSQL}) t 
+    where 1=1`,
+        queryCount: `select 1 from (${el.optimizedSQL})t where 1=1`,
+        /*where: `case
+                    when ST_GeometryType(${el.geomColumn}) in ('ST_Polygon','ST_MultiPolygon')
+                    then st_intersects(${el.geomColumn},st_buffer('${point.replace(/'/g, "''")}',${el.step}))
+                
+                    when ST_GeometryType(${el.geomColumn}) in ('ST_Line','ST_MultiLineString', 'ST_MultiPoint', 'ST_Point')
+                    then st_distance(${el.geomColumn},'${point.replace(/'/g, "''")}') < ${el.step}
+                    else false
+                end`,*/
+        where: `${el.geomColumn} && '${point.replace(/'/g, "''")}'`
+    }));
+
+    const q = qList.map(el => el.query + ' and ' + el.where).join(' union all ').concat(` order by distance limit 1 offset ${Math.max(+index || 0, 0)}`);
+
+    const qCount = qList.map(el => el.queryCount + ' and ' + el.where).join(' union all ');
+
+    if (query.sql === '1') return q;
+    if (query.sql === '2') return qCount;
+
+    const count = await pg.query(qCount).then(el => el.rowCount);
+
+    const row = await pg.query(q).then(el => el.rows?.[0]);
+
+    if (!row) {
+        return reply.status(404).send('object not found');
+    }
+
+    const { columns = [] } = await getMeta({ pg, table: row.table }) || {};
+    const fields = columns.map(({ name, dataTypeID, title }) => ({ name, type: columnType[pg.pgType?.[dataTypeID] || 'text'], label: title || name }));
+
+    const htmlTemplate = pg?.pk?.['admin.template'] && row.layer && false
+        ? await pg.query('select body from admin.templates where name=$1 limit 1', [row.layer]).then(el => el.rows?.[0]?.body)
+        : rows.find(el => el.ogc_service_id === row.layer)?.html;
+
+    const html = await handlebars.compile(htmlTemplate || 'template not found')(row.data);
+
+    const res = {
+        time: Date.now() - time,
+        index,
+        count,
+        data: {
+            layer: row.layer,
+            geom: row.geom,
+            id: row.pk,
+            distance: row.distance,
+            data: row.data,
+        },
+        fields,
+        html
+    };
+
+    return res;
+}

package/server/routes/gis/registers/funcs/classifiers.js

@@ -5,11 +5,13 @@ export async function attachClassifiers(rowOrRows, classifiers, table) {
 
     const list = getTemplates(['cls', 'select']);
 
+    // classifiers as object
     if (table) {
         await Promise.all(rows.map(async row => {
-            await Promise.all(Object.keys(row).filter(key => list.map(el => el[0]).includes(`${table}.${key}`)).map(async key => {
-                const arr = await getSelectVal({ name: `${table}.${key}`, values: [row[key]], ar: true });
-                const val = arr?.find?.(el => el.id === row[key]);
+            await Promise.all(Object.keys(row).filter(key => classifiers?.[key] || list.map(el => el[0]).includes(`${table}.${key}`) || list.map(el => el[0]).includes(key)).map(async key => {
+                const clsAsColumn = list.map(el => el[0]).includes(key);
+                const arr = await getSelectVal({ name: classifiers?.[key] || (clsAsColumn ? key : `${table}.${key}`), values: [row[key]], ar: true });
+                const val = arr?.find?.(el => el.id && el.id.toString() === row[key].toString());
                 if (val?.text) { row[`${key}_data`] = val; }
                 row[key] = val?.text || val || row[key]; // for frontend
                 row[`${key}_text`] = val?.text || val || row[key]; // legacy?
@@ -18,6 +20,7 @@ export async function attachClassifiers(rowOrRows, classifiers, table) {
         return rowOrRows;
     }
 
+    // classifiers as array of objects
     await Promise.all(rows.map(async row => {
         (classifiers || []).filter(item => item.classifier && item.name && row[item.name]).map(async ({ name, classifier }) => {
             const arr = await getSelectVal({ name: classifier, values: [row[name]], ar: true });

package/server/routes/gis/registers/funcs/handleRegistryRequest.js

@@ -1,6 +1,6 @@
-import { attachClassifiers, populateFilterOptions } from './classifiers.js';
+import { populateFilterOptions } from './classifiers.js';
 import { extractVisibleColumns } from './columns.js';
-import { getMeta, getFilterSQL } from "@opengis/fastify-table/utils.js";
+import { getMeta, getFilterSQL, metaFormat } from "@opengis/fastify-table/utils.js";
 
 const columnType = {
     text: 'text',
@@ -12,11 +12,11 @@ const columnType = {
     'timestamp with time zone': 'date',
 };
 
-export async function handleRegistryRequest({ settings, query, object_id, offset = 0, limit = 16, page = 1, pg }) {
+export async function handleRegistryRequest({ settings, query, object_id, offset = 0, limit = 16, page = 1, pg, sql }) {
     const { name, table_name, description, card, columns, filters, query: whereQuery, order, pk, register_id, is_files, view } = settings;
     const parsedColumns = Array.isArray(columns) ? columns : JSON.parse(columns);
     const filtersParsed = Array.isArray(filters) ? filters : JSON.parse(filters);
-    const activeFilters = (filtersParsed || []).filter((f) => f.disabled !== true);
+    const activeFilters = (filtersParsed || []).filter((f) => f.disabled !== true).map(el => ({ ...el, id: el.name || el.id, type: el.type, api: '/api/suggest/' + table_name + ':' + el.name + (el.data ? `?sel=${el.data}` : '') }));
     const { columns: fields1, geom } = await getMeta({ pg, table: table_name });
 
     const fields = fields1?.map?.(({ name, dataTypeID, title }) => ({ name, type: columnType[pg.pgType?.[dataTypeID] || 'text'] || 'text', label: title || name }));
@@ -34,7 +34,7 @@ export async function handleRegistryRequest({ settings, query, object_id, offset
 
     const classifiers = visibleColumns
         .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 }), {});
 
     if (object_id) {
         const sql = `
@@ -42,17 +42,13 @@ export async function handleRegistryRequest({ settings, query, object_id, offset
             FROM ${table_name}
             WHERE ${pk} = $1
         `;
-        const {
-            rows: [row],
-        } = await pg.query(sql, [object_id]);
+        const rows = await pg.query(sql, [object_id]).then(el => el.rows || []);
+        if (!rows.length) throw new Error('Object not found');
 
-        //if (!row) return reply.code(404).send({ message: 'Object not found', status: 404 });
-        if (!row) throw new Error('Object not found');
-
-        await attachClassifiers(row, classifiers, table_name);
+        await metaFormat({ rows, table: table_name, cls: classifiers, sufix: true });
 
         return {
-            row,
+            row: rows[0],
             card,
             d: 1,
             columns: visibleColumns,
@@ -68,8 +64,7 @@ export async function handleRegistryRequest({ settings, query, object_id, offset
             table: table_name,
             search: search,
             filter: filter,
-            filterList: filters,
-            json: 1
+            filterList: activeFilters,
         })
         : { q: '1=1' };
 
@@ -81,15 +76,13 @@ export async function handleRegistryRequest({ settings, query, object_id, offset
 
     const sqlSelect = `SELECT "${pk}" as id ${selectColumns.length ? `, ${selectColumns.join(", ")}` : ''} ${geom ? `, st_asgeojson(${geom})::json as geom` : ''} ${sqlBase}`;
     const dataQuery = `${sqlSelect} ${sqlOrder} ${sqlLimit}`;
-    const totalQuery = `SELECT COUNT(*) ${sqlBase}`;
 
-    const [dataRes, countRes] = await Promise.all([
-        pg.query(dataQuery, [limit, offset]),
-        pg.query(totalQuery),
-    ]);
+    if (sql) return dataQuery;
+
+    const rows = await pg.query(dataQuery, [limit, offset]).then(el => el.rows || []);
+    const total = await pg.query(`SELECT COUNT(*) ${sqlBase}`).then(el => +(el.rows[0]?.count || 0));
 
-    const rows = await attachClassifiers(dataRes.rows, classifiers, table_name);
-    const total = parseInt(countRes.rows[0]?.count || 0, 10);
+    await metaFormat({ rows, table: table_name, cls: classifiers, sufix: true });
 
     const listConfig = {};
 

package/server/routes/gis/registers/gis.registry.js

@@ -9,6 +9,7 @@ export default async function gisRegistry({
     pg = pgClients.client, params = {}, query = {},
 }) {
     const { slug, objectId } = params;
+    const { sql } = query;
 
     const limit = Math.min(query.limit || defaultLimit, maxLimit);
     const offset = query.page && query.page > 0 && !objectId ? (query.page - 1) * limit : 0;
@@ -26,12 +27,12 @@ export default async function gisRegistry({
     );
 
     if (registry) {
-        return handleRegistryRequest({ settings: registry, query, object_id: objectId, offset, limit, page: query.page, pg });
+        return handleRegistryRequest({ settings: registry, query, object_id: objectId, offset, limit, page: query.page, pg, sql });
     }
 
     const registryTemplate = await getTemplate('registry', slug);
     //if (!registryTemplate) return reply.code(404).send({ message: 'Template not found', status: 404 });
     if (!registryTemplate) throw new Error('Template not found');
 
-    return handleRegistryRequest({ settings: registryTemplate, query, object_id: objectId, offset, limit, page: query.page, pg });
+    return handleRegistryRequest({ settings: registryTemplate, query, object_id: objectId, offset, limit, page: query.page, pg, sql });
 }

package/server/routes/gis/services/add.service.js

@@ -1,7 +1,7 @@
 import { dataDelete, dataInsert, dataUpdate, pgClients } from "@opengis/fastify-table/utils.js";
 
-async function updateTemplate(client, body, name, uid, id) {
-    if (!body || !name || !id) return;
+async function updateTemplate(client, body, uid, id) {
+    if (!body || !id) return;
 
     await dataDelete({
         pg: client,
@@ -13,7 +13,7 @@ async function updateTemplate(client, body, name, uid, id) {
         pg: client,
         id,
         table: 'admin.templates',
-        data: { body, name },
+        data: { body, name: id },
         uid,
     }).then(el => el.rowCount);
     return rowCount;
@@ -39,7 +39,7 @@ export default async function addService({
                 data: body,
                 uid,
             });
-            const istemplate = await updateTemplate(client, body.html, body.template, uid, rows[0]?.service_id);
+            const istemplate = await updateTemplate(client, body.html, uid, rows[0]?.service_id);
             await client.query('commit');
             return reply.status(200).send(rows[0]);
         }
@@ -52,7 +52,7 @@ export default async function addService({
             data: body,
             uid,
         });
-        const istemplate = await updateTemplate(client, body.html, body.template, uid, params.id);
+        const istemplate = await updateTemplate(client, body.html, uid, params.id);
         await client.query('commit');
         return reply.status(200).send(row);
 

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,24 +11,38 @@ const columnType = {
 };
 
 export default async function getServices({ 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 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 }));
+
     const noCenterIds = rows.filter(row => !row.center && row.bbox).map(row => row.service_id);
 
     const centers = noCenterIds.length ? await pg.query(`SELECT json_object_agg(service_id, st_pointonsurface(bbox)::json) FROM gis.services where service_id=any($1)`, [noCenterIds].filter(Boolean)).then(el => el.rows?.[0]?.json_object_agg || {}) : {};
@@ -41,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/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/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,46 +62,45 @@ 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.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 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 || {};