@opengis/gis 0.2.21 → 0.2.22

package/module/gis/form/gis.cartocss.form.json

@@ -0,0 +1,46 @@
+{
+    "schema": {
+        "name": {
+            "ua": "Назва",
+            "col": 12,
+            "type": "Text",
+            "validators": [
+                "required"
+            ]
+        },
+        "group_id": {
+            "type": "Autocomplete",
+            "data": "gis.group_list",
+            "col": 6,
+            "ua": "Група"
+        },
+        "cartocss_key": {
+            "ua": "Унікальний ключ",
+            "col": 6,
+            "type": "Text",
+            "validators": [
+                "required"
+            ]
+        },
+        "description": {
+            "ua": "Опис",
+            "col": 12,
+            "type": "TextArea",
+            "validators": [
+                "required"
+            ]
+        },
+        "is_public": {
+            "ua": "Чи є карта публічною?",
+            "col": 6,
+            "type": "Switcher",
+            "data": "yes_no"
+        },
+        "enabled": {
+            "ua": "Чи включена карта?",
+            "col": 6,
+            "type": "Switcher",
+            "data": "yes_no"
+        }
+    }
+}

package/module/gis/table/gis.cartocss.table.json

@@ -0,0 +1,61 @@
+{
+    "key": "cartocss_id",
+    "table": "gis.cartocss",
+    "form": "gis.cartocss.form",
+    "meta": {
+        "title": "name",
+        "search": "name,description"
+    },
+    "card": true,
+    "order": "created_at desc",
+    "columns": [
+        {
+            "ua": "Назва",
+            "name": "name",
+            "format": "text"
+        },
+        {
+            "ua": "Опис",
+            "name": "description",
+            "format": "text"
+        },
+        {
+            "ua": "Група",
+            "name": "group_id",
+            "data": "gis.group_list",
+            "format": "select"
+        },
+        {
+            "ua": "On/Off",
+            "name": "enabled",
+            "data": "yes_no",
+            "format": "badge"
+        },
+        {
+            "ua": "Чи публічний",
+            "name": "is_public",
+            "data": "yes_no",
+            "format": "badge"
+        }
+    ],
+    "filterList": [
+        {
+            "ua": "Група",
+            "name": "group_id",
+            "data": "gis.group_list",
+            "type": "Check"
+        },
+        {
+            "ua": "On/Off",
+            "name": "enabled",
+            "data": "yes_no",
+            "type": "Check"
+        },
+        {
+            "ua": "Чи публічний",
+            "name": "is_public",
+            "data": "yes_no",
+            "type": "Check"
+        }
+    ]
+}

package/module/gis/table/gis.rasters.table.json

@@ -41,7 +41,7 @@
       "format": "badge"
     },
     {
-      "ua": "Is public",
+      "ua": "Чи публічний",
       "name": "is_public",
       "data": "yes_no",
       "format": "badge"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengis/gis",
-  "version": "0.2.21",
+  "version": "0.2.22",
   "type": "module",
   "author": "Softpro",
   "main": "./dist/index.js",
@@ -66,4 +66,4 @@
     "vue-router": "4.5.1",
     "vuedraggable": "^4.1.0"
   }
-}
+}

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

@@ -12,8 +12,8 @@ const columnType = {
     'timestamp with time zone': 'date',
 };
 
-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;
+export async function handleRegistryRequest({ settings, query, object_id, is_downloadable, register_key, is_map, is_register, service_id, is_files, offset = 0, limit = 16, page = 1, pg, sql }) {
+    const { name, table_name, description, card, columns, filters, query: whereQuery, order, pk, register_id, 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).map(el => ({ ...el, id: el.name || el.id, type: el.type, api: '/api/suggest/' + table_name + ':' + el.name + (el.data ? `?sel=${el.data}` : '') }));
@@ -52,9 +52,14 @@ export async function handleRegistryRequest({ settings, query, object_id, offset
             card,
             d: 1,
             columns: visibleColumns,
+            is_downloadable,
+            register_key,
             register_id,
+            service_id,
             name,
             is_files,
+            is_map,
+            is_register,
         };
     }
 
@@ -106,15 +111,21 @@ export async function handleRegistryRequest({ settings, query, object_id, offset
         name,
         card,
         table_name,
+        register_key,
         description,
         rows,
         total,
+        service_id,
         columns: visibleColumns,
         filters: activeFilters,
         fields,
         limit,
         page,
         view,
+        is_downloadable,
+        is_map,
+        is_register,
+        is_files,
         config: {
             listConfig
         }

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

@@ -20,19 +20,51 @@ export default async function gisRegistry({
     const {
         rows: [registry],
     } = await pg.query(
-        `SELECT register_id, name, description, card, table_name, columns, filters, query, "order", pk, register_key, is_files, view
+        `SELECT register_id, name, description, card, table_name,
+            columns, filters, query, "order", pk, register_key, 
+            is_files, view, is_downloadable, is_map, is_register, service_id
         FROM gis.registers
         WHERE  $1 in (register_key,register_id)`,
         [slug]
     );
 
     if (registry) {
-        return handleRegistryRequest({ settings: registry, query, object_id: objectId, offset, limit, page: query.page, pg, sql });
+        return handleRegistryRequest({
+            settings: registry,
+            query,
+            is_downloadable: registry.is_downloadable,
+            register_key: registry.register_key,
+            object_id: objectId,
+            is_map: registry.is_map,
+            is_register: registry.is_register,
+            is_files: registry.is_files,
+            service_id: registry.service_id,
+            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, sql });
+    return handleRegistryRequest({
+        settings: registryTemplate,
+        query,
+        object_id: objectId,
+        register_key: registry.register_key,
+        is_downloadable: registry?.is_downloadable || registryTemplate?.is_downloadable,
+        is_map: registryTemplate.is_map,
+        is_register: registryTemplate.is_register,
+        is_files: registryTemplate.is_files,
+        service_id: registryTemplate.service_id,
+        offset,
+        limit,
+        page: query.page,
+        pg,
+        sql
+    });
 }

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

@@ -0,0 +1,187 @@
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import {
+    readFile, stat, mkdir, writeFile,
+} from 'node:fs/promises';
+
+import {
+    pgClients, getMeta,
+} from '@opengis/fastify-table/utils.js';
+
+import rootFolder from '../../../plugins/mapnik/funcs/rootFolder.mjs';
+
+const systemColumns = ['uid', 'cdate', 'editor_id', 'editor_date', 'created_by', 'created_at', 'updated_by', 'updated_at'];
+
+/**
+ * Повертає GeoJSON для сервісу на основі налаштувань з gis.services
+ * 
+ * @method GET
+ * @param {string} params.layer - service_id
+ * @param {string} query.sql - повернути SQL запит замість даних
+ * @param {boolean} query.nocache - не використовувати кеш
+ */
+export default async function geojson({
+    pg = pgClients.client, params = {}, query = {}, unittest,
+}, reply) {
+    const { layer } = params;
+    const { sql, nocache, srid, type, extent } = query;
+
+    if (!layer) {
+        return reply.status(400).send('not enough params: layer (service_id)');
+    }
+
+    const serviceId = layer.replace('.json', '');
+
+    if (!pg.pk?.['gis.services']) {
+        return reply.status(404).send('services table not found');
+    }
+
+    const service = await pg.query(
+        `select 
+            source_path, 
+            query, 
+            geometry_column, 
+            attributes,
+            srid,
+            is_public,
+            is_active,
+            geom_type
+        from gis.services 
+        where service_id = $1 and is_active = true and is_public = true`,
+        [serviceId],
+    ).then(el => el.rows?.[0]);
+
+    if (!service) {
+        return reply.status(404).send('service not found or not available');
+    }
+
+    const {
+        source_path: source,
+        query: serviceQuery,
+        geometry_column: gc,
+        attributes,
+        srid: serviceSrid,
+        geom_type: geomType,
+    } = service;
+
+    if (!source) {
+        return reply.status(400).send('invalid service source path');
+    }
+
+    const table = source;
+
+    if (!pg.pk?.[table]?.length) {
+        return reply.status(404).send('layer table not found');
+    }
+
+    const meta = await getMeta({ pg, table });
+    const { columns = [] } = meta || {};
+
+    const geom = gc || meta?.geom || 'geom';
+    const pk = pg.pk?.[table] || columns[0]?.name;
+
+    let attributeColumns = [];
+    if (attributes && Array.isArray(attributes)) {
+        attributeColumns = attributes
+            .filter(attr => attr.name && !systemColumns.includes(attr.name))
+            .map(attr => attr.name);
+    }
+
+    const columnsFiltered = attributeColumns.length > 0
+        ? columns.filter(col => attributeColumns.includes(col.name) && !systemColumns.includes(col.name))
+        : [];
+
+    const props = columnsFiltered.map(el =>
+        `"${el.name}"${['int4'].includes(el.type) ? '::text' : ''}`
+    ).join(', ');
+
+    const geometryType = (geomType || 'point').toLowerCase();
+    const limit = geometryType === 'point' ? 40000 : 2500;
+    const cacheHash = createHash('md5')
+        .update([serviceId, serviceQuery, srid, type, extent].filter(el => el).join('-'))
+        .digest('hex');
+
+    const today = new Date().toISOString().split('T')[0];
+    const filepath = path.join(
+        rootFolder,
+        `/geojson/${serviceId}/${today}/${cacheHash}.json`,
+    );
+
+    if (existsSync(filepath) && !nocache && !sql && !unittest) {
+        const { birthtimeMs = Date.now() } = await stat(filepath);
+        const ageInMs = Date.now() - birthtimeMs;
+        if (ageInMs < 86400000) {
+            const content = await readFile(filepath, 'utf8');
+            return reply
+                .status(200)
+                .header('Content-Type', 'application/json')
+                .header('Cache-Control', 'public, max-age=86400')
+                .send(content);
+        }
+    }
+
+    const targetSrid = srid || serviceSrid || 4326;
+    const useCentroid = type === 'centroid';
+
+    let geomExpression = geom;
+
+    if (useCentroid) {
+        geomExpression = `st_centroid(${geomExpression})`;
+    }
+
+    if (targetSrid !== 4326) {
+        geomExpression = `st_transform(${geomExpression}, 4326)`;
+    } else if (serviceSrid && serviceSrid !== 4326) {
+        geomExpression = `st_transform(${geomExpression}, 4326)`;
+    }
+
+    const quotedTable = table.split('.').map(el => `"${el}"`).join('.');
+    const quotedGeom = `"${geom}"`;
+
+    const geomFinal = `st_force2d(${geomExpression.replace(new RegExp(`(\\b)${geom}(\\b)`, 'g'), `$1${quotedGeom}$2`)})`;
+    const q = `
+        SELECT 'FeatureCollection' As type, 
+               json_agg(f) As features
+        FROM (
+            SELECT 'Feature' As type,
+                   row_number() over() as id,
+                   st_asgeojson(${geomFinal}, 6, 0)::json as geometry,
+                   (select row_to_json(tc) from (
+                       select "${pk}" as id ${props ? ', ' + props : ''}
+                   ) tc) as properties
+            FROM ${quotedTable}
+            WHERE ${serviceQuery || '1=1'}
+              AND ${quotedGeom} is not null
+              AND st_srid(${quotedGeom}) > 0
+              ${extent ? `AND ${quotedGeom} && 'BOX(${extent.split(',').reduce((p, el, i) => p + el + (i % 2 ? ',' : ' '), '')})'::box2d` : ''}
+            LIMIT ${limit}
+        ) f
+    `;
+
+    if (sql === '1') return q;
+    if (sql === '2') return filepath.replace(/\\/g, '/');
+
+    try {
+        const result = await pg.query(q);
+        const geojsonData = result.rows[0] || { type: 'FeatureCollection', features: [] };
+
+        geojsonData.service_id = serviceId;
+        geojsonData.count = geojsonData.features?.length || 0;
+
+        const jsonString = JSON.stringify(geojsonData);
+
+        if (!nocache && !unittest) {
+            await mkdir(path.dirname(filepath), { recursive: true });
+            await writeFile(filepath, jsonString, 'utf8');
+        }
+
+        return reply
+            .status(200)
+            .header('Content-Type', 'application/json')
+            .header('Cache-Control', nocache ? 'no-cache' : 'public, max-age=86400')
+            .send(jsonString);
+    } catch (err) {
+        return reply.status(500).send({ error: err.message });
+    }
+}

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

@@ -0,0 +1,205 @@
+import path from 'node:path';
+import { existsSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import {
+    readFile, stat, mkdir, writeFile,
+} from 'node:fs/promises';
+
+import {
+    pgClients, getMeta, metaFormat,
+} from '@opengis/fastify-table/utils.js';
+
+import rootFolder from '../../../plugins/mapnik/funcs/rootFolder.mjs';
+
+const systemColumns = ['uid', 'cdate', 'editor_id', 'editor_date', 'created_by', 'created_at', 'updated_by', 'updated_at', 'geom'];
+
+/**
+ * Повертає JSON дані для реєстру на основі налаштувань з gis.registers
+ * 
+ * @method GET
+ * @param {string} params.layer - register_id
+ * @param {string} query.page - номер сторінки (default: 1)
+ * @param {string} query.limit - кількість записів на сторінку (default: 100)
+ * @param {string} query.where - додаткова WHERE умова
+ * @param {string} query.sql - повернути SQL запит замість даних
+ * @param {boolean} query.nocache - не використовувати кеш
+ */
+export default async function jsonData({
+    pg = pgClients.client, params = {}, query = {}, unittest,
+}, reply) {
+    const { layer } = params;
+    const {
+        page = 1,
+        limit = 100,
+        where,
+        sql,
+        nocache
+    } = query;
+
+    if (!layer) {
+        return reply.status(400).send('not enough params: layer (register_id)');
+    }
+
+    const registerId = layer.replace('.json', '');
+    const pageNum = parseInt(page, 10) || 1;
+    const limitNum = Math.min(parseInt(limit, 10) || 100, 1000); // max 1000
+    const offset = (pageNum - 1) * limitNum;
+
+    if (!pg.pk?.['gis.registers']) {
+        return reply.status(404).send('registers table not found');
+    }
+
+    const register = await pg.query(
+        `select 
+            table_name,
+            pk,
+            query,
+            columns,
+            is_public,
+            is_active,
+            "order"
+        from gis.registers 
+        where register_id = $1 and is_active = true and is_public = true`,
+        [registerId],
+    ).then(el => el.rows?.[0]);
+
+    if (!register) {
+        return reply.status(404).send('register not found or not available');
+    }
+
+    const {
+        table_name: table,
+        pk,
+        query: registerQuery,
+        columns,
+        order: orderBy,
+    } = register;
+
+    if (!table) {
+        return reply.status(400).send('invalid register table_name');
+    }
+
+    if (!pg.pk?.[table]?.length) {
+        return reply.status(404).send('table not found');
+    }
+
+    const meta = await getMeta({ pg, table });
+    const { columns: metaColumns = [] } = meta || {};
+
+    let attributeColumns = [];
+    if (columns && Array.isArray(columns)) {
+        attributeColumns = columns
+            .filter(col => col.name && !systemColumns.includes(col.name))
+            .map(col => col.name);
+    }
+
+    const columnsFiltered = attributeColumns.length > 0
+        ? metaColumns.filter(col => attributeColumns.includes(col.name) && !systemColumns.includes(col.name))
+        : metaColumns.filter(col => !systemColumns.includes(col.name));
+
+    const props = columnsFiltered.map(el =>
+        `"${el.name}"${['int4'].includes(el.type) ? '::text' : ''}`
+    ).join(', ');
+
+    if (!props) {
+        return reply.status(400).send('no columns to select');
+    }
+
+    const cacheHash = createHash('md5')
+        .update([registerId, where, registerQuery, pageNum, limitNum].filter(el => el).join('-'))
+        .digest('hex');
+
+    const today = new Date().toISOString().split('T')[0];
+    const filepath = path.join(
+        rootFolder,
+        `/json/${registerId}/${today}/${cacheHash}.json`,
+    );
+
+    if (existsSync(filepath) && !nocache && !sql && !unittest) {
+        const { birthtimeMs = Date.now() } = await stat(filepath);
+        const ageInMs = Date.now() - birthtimeMs;
+        if (ageInMs < 86400000) {
+            const content = await readFile(filepath, 'utf8');
+            return reply
+                .status(200)
+                .header('Content-Type', 'application/json')
+                .header('Cache-Control', 'public, max-age=86400')
+                .send(content);
+        }
+    }
+
+    const whereConditions = [
+        registerQuery || '1=1',
+        where || 'true',
+    ].join(' AND ');
+
+    const quotedTable = table.split('.').map(el => `"${el}"`).join('.');
+
+    const countQuery = `
+        SELECT COUNT(*) as total
+        FROM ${quotedTable}
+        WHERE ${whereConditions}
+    `;
+
+    const dataQuery = `
+        SELECT "${pk}" as id ${props ? ', ' + props : ''}
+        FROM ${quotedTable}
+        WHERE ${whereConditions}
+        ${orderBy ? `ORDER BY ${orderBy}` : ''}
+        LIMIT ${limitNum}
+        OFFSET ${offset}
+    `;
+
+    if (sql === '1') return { countQuery, dataQuery };
+    if (sql === '2') return filepath.replace(/\\/g, '/');
+
+    try {
+        const [countResult, dataResult] = await Promise.all([
+            pg.query(countQuery),
+            pg.query(dataQuery),
+        ]);
+
+        const total = parseInt(countResult.rows[0]?.total || 0, 10);
+        const rows = dataResult.rows || [];
+
+        // Обробка класифікаторів
+        if (columns && Array.isArray(columns)) {
+            const classifiers = columns
+                .filter(col => col.data && ['select', 'badge', 'tags', 'integer', 'text', 'text[]'].includes(col.format))
+                .reduce((acc, curr) => ({ ...acc, [curr.name]: curr.data }), {});
+
+            if (Object.keys(classifiers).length > 0) {
+                await metaFormat({
+                    rows,
+                    table,
+                    cls: classifiers,
+                    suffix: true,
+                });
+            }
+        }
+
+        const result = {
+            register_id: registerId,
+            total,
+            page: pageNum,
+            limit: limitNum,
+            pages: Math.ceil(total / limitNum),
+            data: rows,
+        };
+
+        const jsonString = JSON.stringify(result);
+
+        if (!nocache && !unittest) {
+            await mkdir(path.dirname(filepath), { recursive: true });
+            await writeFile(filepath, jsonString, 'utf8');
+        }
+
+        return reply
+            .status(200)
+            .header('Content-Type', 'application/json')
+            .header('Cache-Control', nocache ? 'no-cache' : 'public, max-age=86400')
+            .send(jsonString);
+    } catch (err) {
+        return reply.status(500).send({ error: err.message });
+    }
+}

package/server/routes/map/index.mjs

@@ -7,6 +7,8 @@ import mapCatalogAttribute from './controllers/mapCatalogAttribute.js';
 import rtile from './controllers/rtile.js';
 import vtile from './controllers/vtile.js';
 import vtile1 from './vtile1.js';
+import geojson from './controllers/geojson.js';
+import jsonData from './controllers/jsonData.js';
 import layerList from './controllers/layerList.js';
 
 import mapFormat from './controllers/mapFormat.js';
@@ -108,6 +110,17 @@ export default async function route(app) {
     console.log('\x1b[34m%s\x1b[0m', 'add vtile from gis');
     app.get('/vtile/:layer/:lang/:z/:y/:x', publicParams, vtile1);
   }
+
+  if (!app.hasRoute({ method: 'GET', url: '/api/geojson/:layer' })) {
+    console.log('\x1b[34m%s\x1b[0m', 'add geojson from gis');
+    app.get('/geojson/:layer', publicParams, geojson);
+  }
+
+  if (!app.hasRoute({ method: 'GET', url: '/api/json/:layer' })) {
+    console.log('\x1b[34m%s\x1b[0m', 'add json from gis');
+    app.get('/json/:layer', publicParams, jsonData);
+  }
+
   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', publicParams, layerList);

package/server/routes/map/vtile1.js

@@ -107,7 +107,8 @@ export default async function vtile({
   }[z] || 0.0005;
 
   const types = { point: 'ST_Point' /* ,ST_MultiPoint */, polygon: 'ST_Polygon,ST_MultiPolygon' };
-  const queryMode = ((clusterZoom - z) > 2 ? 1 : null) || ((clusterZoom - z) > 0 ? 2 : null) || 3;
+  const clusterZoom1 = style?.clusterZoom || clusterZoom;
+  const queryMode = ((clusterZoom1 - z) > 2 ? 1 : null) || ((clusterZoom1 - z) > 0 ? 2 : null) || 3;
   // console.log(z, clusterZoom, queryMode);
   const props1 = props.filter((el, idx, arr) => idx === arr.findIndex(item => item.name === el.name));
   const q = {
@@ -120,11 +121,10 @@ export default async function vtile({
                 )q`,
     2: `SELECT ST_AsMVT(q, '${layer}', 4096, 'geom','row') as tile
             FROM (
-                SELECT floor(random() * 100000 + 1)::int +row_number() over() as row, count(*) as point_count,
-                ${props?.length ? `${props1.map(prop => `case when count(*)=1 then min(${prop.name.replace(/'/g, "''")}) else null end as "${prop.name.replace(/'/g, "''")}"`).join(',')},` : ''}
+                SELECT floor(random() * 100000 + 1)::int +row_number() over() as row, count(*) as point_count,                
                 ST_AsMVTGeom(st_transform(st_centroid(ST_Union(geom)),3857),ST_TileEnvelope(${z},${y},${x})::box2d,4096,256,false) as geom
                 FROM (
-                SELECT ${props?.length ? `${props1.map(prop => prop.name).join(',')},` : ''} geom, ST_ClusterDBSCAN(geom,${koef},1) OVER () AS cluster 
+                SELECT geom, ST_ClusterDBSCAN(geom,${koef},1) OVER () AS cluster 
                 FROM ${table} where ${layerQuery || 'true'} and ${filterData?.q || 'true'} and ${geom} && ${bbox2d}  ) j
                 WHERE cluster IS NOT NULL
                 GROUP BY cluster