@opengis/gis 0.2.21 → 0.2.23

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.23",
   "type": "module",
   "author": "Softpro",
   "main": "./dist/index.js",
@@ -46,7 +46,7 @@
   },
   "devDependencies": {
     "@opengis/core": "^0.0.23",
-    "@opengis/fastify-table": "^2.0.114",
+    "@opengis/fastify-table": "^2.0.116",
     "@opengis/filter": "^0.1.25",
     "@opengis/form": "^0.0.91",
     "@opengis/table": "^0.0.27",
@@ -66,4 +66,4 @@
     "vue-router": "4.5.1",
     "vuedraggable": "^4.1.0"
   }
-}
+}

package/server/routes/gis/index.mjs

@@ -30,32 +30,35 @@ const mapInfoPointSchema = {
   },
 };
 
+const params = { config: { package: 'gis' } };
+const publicParams = { config: { policy: 'L0', package: 'gis' } };
+
 async function route(app) {
-  app.put('/insert-columns/:token', insertColumns);
-  app.put('/insert-filters/:token', insertFilters);
-  app.get('/gis-registry/:slug', { config: { policy: ['public'] } }, gisRegistry);
-  app.get('/gis-registry/:slug/:objectId', { config: { policy: ['public'] } }, gisRegistry);
-  app.get('/gis-registry', { config: { policy: ['public'] } }, gisRegistryList);
-  app.post('/gis-registry', { config: { policy: ['public'] } }, addGisRegistry);
-  app.put('/gis-registry/:slug', { config: { policy: ['public'] } }, addGisRegistry);
-  app.delete('/gis-registry/:slug', { config: { policy: ['public'] } }, deleteGisRegistry);
-  app.get('/map-registry/:slug/:id', { config: { policy: ['public'] } }, mapRegistry);
+  app.put('/insert-columns/:token', params, insertColumns);
+  app.put('/insert-filters/:token', params, insertFilters);
+  app.get('/gis-registry/:slug', publicParams, gisRegistry);
+  app.get('/gis-registry/:slug/:objectId', publicParams, gisRegistry);
+  app.get('/gis-registry', publicParams, gisRegistryList);
+  app.post('/gis-registry', publicParams, addGisRegistry);
+  app.put('/gis-registry/:slug', publicParams, addGisRegistry);
+  app.delete('/gis-registry/:slug', publicParams, deleteGisRegistry);
+  app.get('/map-registry/:slug/:id', publicParams, mapRegistry);
 
-  app.get('/xml/:id', { config: { policy: ['public'] } }, metadataXML);
+  app.get('/xml/:id', publicParams, metadataXML);
 
-  app.get('/get-layer-geom/:id', { config: { policy: ['public'] } }, getLayerGeom);
+  app.get('/get-layer-geom/:id', publicParams, getLayerGeom);
 
-  app.get('/gis-export/:type/:slug', { config: { policy: ['public'] } }, gisExport);
+  app.get('/gis-export/:type/:slug', publicParams, gisExport);
 
-  app.get('/gis-service/:id?', { config: { policy: ['public'] } }, getServices);
-  app.get('/gis-service/:id/:col', { config: { policy: ['public'] } }, getServicesCol);
-  app.post('/gis-service/:id?', { config: { policy: ['public'] } }, addService);
-  app.put('/gis-service/:id', { config: { policy: ['public'] } }, addService);
-  app.delete('/gis-service/:id', { config: { policy: ['public'] } }, deleteService);
-  app.get('/legend-auto/:id', { config: { policy: ['public'] } }, legendAuto);
+  app.get('/gis-service/:id?', publicParams, getServices);
+  app.get('/gis-service/:id/:col', publicParams, getServicesCol);
+  app.post('/gis-service/:id?', publicParams, addService);
+  app.put('/gis-service/:id', publicParams, addService);
+  app.delete('/gis-service/:id', publicParams, deleteService);
+  app.get('/legend-auto/:id', publicParams, legendAuto);
 
-  app.get('/map-info-point', { config: { policy: ['public'] }, schema: mapInfoPointSchema }, mapInfoPoint);
+  app.get('/map-info-point', { ...publicParams, schema: mapInfoPointSchema }, mapInfoPoint);
 
-  app.get('/dashboard', { config: { policy: ['public'] } }, getDashboard);
+  app.get('/dashboard', publicParams, getDashboard);
 }
 export default route;

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