@opengis/gis 0.2.0 → 0.2.1

package/module/test/cls/ts.temp_status.json

@@ -0,0 +1,18 @@
+[
+    {
+        "id": "1",
+        "text": "Демонтована"
+    },
+    {
+        "id": "2",
+        "text": "Підлягає демонтажу у зв’язку з анулюванням паспорту прив'язки"
+    },
+    {
+        "id": "3",
+        "text": "Підлягає демонтажу у зв’язку з самовільним встановленням ТС"
+    },
+    {
+        "id": "4",
+        "text": "Підлягає демонтажу у зв’язку завершенням терміну дії паспорту прив’язки"
+    }
+]

package/module/test/cls/ts.temp_type.json

@@ -0,0 +1,10 @@
+[
+    {
+        "id": "1",
+        "text": "Тимчасова споруда з паспортом прив’язки"
+    },
+    {
+        "id": "2",
+        "text": "Самовільно встановлена"
+    }
+]

package/module/test/map/bp_myo.json

@@ -1,13 +1,17 @@
 {
     "history": true,
     "name": "Буд. паспорти та Містобудівні умови й обмеження",
-    "height": "calc(100vh - 65px)",   
-    "center": [    
+    "height": "calc(100vh - 65px)",
+    "center": [
         34.65450,
-        48.51174    
-    ], 
+        48.51174
+    ],
     "zoom": 11,
     "widgets":[
+        {
+            "type": "search",
+            "position": "top-left"
+        },
         {
             "type": "info",
             "position": "top-left",
@@ -32,6 +36,6 @@
     "old":["bp","3c95e341465d"],
     "layers": [
         "3c95e341465d",
-        "dbcb186818e3"        
+        "dbcb186818e3"
     ]
-}
+}

package/module/test/select/address_id.json

@@ -0,0 +1,3 @@
+{
+    "extra": true
+}

package/module/test/select/address_id.sql

@@ -0,0 +1,8 @@
+SELECT addr_id,
+coalesce(c.name , ' ')  || ' ' ||  (select name from data_address.street where str_id=a.parent limit 1) || 
+coalesce(', ' ||addr_num,'')
+FROM data_address.address a 
+left join data_address.street b on a.parent=b.str_id
+left join admin.cls c on c.parent='str_type' and c.code=b.type::text
+order by
+b.name

package/module/test/table/data_bp_myo.bp.table.json

@@ -0,0 +1,123 @@
+{
+  "key": "bp_id",
+  "table": "data_bp_myo.bp",
+  "actions": [
+    "add",
+    "edit",
+    "del"
+  ],
+  "controls": [
+    "search",
+    "list",
+    "add"
+  ],
+  "access": "user",
+  "order": "cdate desc",
+  "meta": {
+    "title": "bp_code",
+    "search": "bp_code,bp_number,bp_reg_num,bp_issued_name,bp_customer_name,bp_object_name"
+  },
+  "title": "Будівельні паспорти",
+  "form": "data_bp_myo.bp.form",
+  "columns": [
+    {
+      "ua": "Реєстраційний номер МБК",
+      "name": "bp_number",
+      "width": 100,
+      "format": "text"
+    },
+    {
+      "ua": "Реєстраційний номер в ЄДЕССБ",
+      "meta": "title",
+      "name": "bp_code",
+      "hidden": true,
+      "format": "text"
+    },
+    {
+      "ua": "Реєстраційний номер",
+      "name": "bp_reg_num",
+      "width": 100,
+      "format": "text"
+    },
+    {
+      "ua": "Назва об’єкта будівництва",
+      "name": "bp_object_name",
+      "width": 300,
+      "format": "text"
+    },
+    {
+      "ua": "Адреса",
+      "name": "address",
+      "width": 300,
+      "format": "text"
+    },
+    {
+      "ua": "Вид будівництва",
+      "name": "bp_build_type",
+      "data": "bp_build_type",
+      "width": 150,
+      "format": "badge"
+    },
+    {
+      "ua": "Дата видачі",
+      "name": "bp_issued_date",
+      "width": 100,
+      "format": "date"
+    },
+    {
+      "ua": "Статус реєстрації",
+      "name": "bp_doc_status",
+      "data": "doc_status",
+      "width": 150,
+      "hidden": true,
+      "format": "badge"
+    },
+    {
+      "ua": "Назва органу, що видав",
+      "name": "bp_issued_name",
+      "width": 300,
+      "hidden": true,
+      "format": "text"
+    },
+    {
+      "ua": "Замовник",
+      "name": "bp_customer_name",
+      "width": 300,
+      "format": "text"
+    },
+    {
+      "ua": "Кадастрові номери",
+      "name": "land_number",
+      "format": "slot",
+      "hidden": true,
+      "slot": {
+        "content": "<p v-for=\"item in data?.land_number\">{{item}}</p>"
+      }
+    },
+    {
+      "ua": "Версія документу",
+      "name": "obj_version",
+      "format": "text",
+      "hidden": true
+    }
+  ],
+  "filterList": [
+    {
+      "ua": "Вид будівництва",
+      "name": "bp_build_type",
+      "data": "bp_build_type",
+      "type": "Check"
+    },
+    {
+      "ua": "Дата видачі",
+      "name": "bp_issued_date",
+      "type": "Date"
+    },
+    {
+      "ua": "Статус документа",
+      "name": "bp_doc_status",
+      "data": "doc_status",
+      "type": "Check"
+    }
+  ]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengis/gis",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "type": "module",
   "author": "Softpro",
   "main": "./dist/index.js",
@@ -35,16 +35,16 @@
     "carto": "0.16.3"
   },
   "peerDependencies": {
-    "@opengis/fastify-table": "^2.0.13"
+    "@opengis/fastify-table": "^2.0.23"
   },
   "resolutions": {
     "rollup": "4.30.0"
   },
   "devDependencies": {
     "@opengis/core": "^0.0.23",
-    "@opengis/fastify-table": "^2.0.13",
+    "@opengis/fastify-table": "^2.0.23",
     "@opengis/filter": "^0.1.7",
-    "@opengis/form": "^0.0.28",
+    "@opengis/form": "^0.0.42",
     "@opengis/table": "^0.0.27",
     "@vitejs/plugin-vue": "^5.2.3",
     "axios": "^1.11.0",

package/server/migrations/ogc.sql

@@ -0,0 +1,107 @@
+CREATE TABLE if not exists gis.ogc_service
+(
+  ogc_service_id text NOT NULL DEFAULT admin.next_id(),
+  name text, -- Назва
+  service text, -- TMS/WMS/WFS
+  url text, -- Шлях
+  enabled boolean, -- Опис
+  geom geometry, -- Баунд
+  updated_by text,
+  updated_at timestamp without time zone,
+  created_at timestamp without time zone DEFAULT date_trunc('minutes'::text, now()),
+  created_by text,
+  group_id text, -- Ідентифікатор групи
+  ispublic boolean DEFAULT false, -- Чи є сервіс публічним
+  service_id text DEFAULT admin.next_id(), -- ID
+  srid text, -- srid
+  info text,
+  scheme text, -- Схема
+  category text, -- Категорія
+  attribution text, -- Атрибуція
+  editor_id text,
+  editor_date timestamp without time zone,
+  cdate timestamp without time zone DEFAULT date_trunc('minutes'::text, now()),
+  uid text,
+  files json,
+  access_level text DEFAULT 'public'::text, -- Рівень доступу (public, user, admin)
+  sub_layers text, -- Під шари (Для WMS)
+  isadmin boolean DEFAULT false, -- Ознака доступу лише для адмін частини порталу
+  user_group_id text, -- Група користувачів
+  url_list text[], -- URL List
+  table_name text, -- Таблиця на клік (інтерактивний шар)
+  setting json, -- Додаткові налаштування
+  CONSTRAINT ogc_service_pkey PRIMARY KEY (ogc_service_id),
+  CONSTRAINT gis_ogc_service_group_id_fkey FOREIGN KEY (group_id)
+      REFERENCES gis.group_list (group_id) MATCH SIMPLE
+      ON UPDATE NO ACTION ON DELETE NO ACTION
+);
+
+COMMENT ON TABLE gis.ogc_service IS 'Сервіси';
+
+COMMENT ON COLUMN gis.ogc_service.name IS 'Назва';
+COMMENT ON COLUMN gis.ogc_service.service IS 'TMS/WMS/WFS';
+COMMENT ON COLUMN gis.ogc_service.url IS 'Шлях';
+COMMENT ON COLUMN gis.ogc_service.enabled IS 'Опис';
+COMMENT ON COLUMN gis.ogc_service.geom IS 'Баунд';
+COMMENT ON COLUMN gis.ogc_service.group_id IS 'Ідентифікатор групи';
+COMMENT ON COLUMN gis.ogc_service.ispublic IS 'Чи є сервіс публічним';
+COMMENT ON COLUMN gis.ogc_service.service_id IS 'ID';
+COMMENT ON COLUMN gis.ogc_service.srid IS 'srid';
+COMMENT ON COLUMN gis.ogc_service.scheme IS 'Схема';
+COMMENT ON COLUMN gis.ogc_service.category IS 'Категорія';
+COMMENT ON COLUMN gis.ogc_service.attribution IS 'Атрибуція';
+COMMENT ON COLUMN gis.ogc_service.access_level IS 'Рівень доступу (public, user, admin)';
+COMMENT ON COLUMN gis.ogc_service.sub_layers IS 'Під шари (Для WMS)';
+COMMENT ON COLUMN gis.ogc_service.isadmin IS 'Ознака доступу лише для адмін частини порталу';
+COMMENT ON COLUMN gis.ogc_service.user_group_id IS 'Група користувачів';
+COMMENT ON COLUMN gis.ogc_service.url_list IS 'URL List';
+COMMENT ON COLUMN gis.ogc_service.table_name IS 'Таблиця на клік (інтерактивний шар)';
+COMMENT ON COLUMN gis.ogc_service.setting IS 'Додаткові налаштування';
+
+CREATE INDEX if not exists gis_ogc_service_category_trgm_idx
+  ON gis.ogc_service
+  USING gin
+  (category COLLATE pg_catalog."default" gin_trgm_ops);
+
+CREATE INDEX if not exists gis_ogc_service_enabled_btree_idx
+  ON gis.ogc_service
+  USING btree
+  (enabled);
+
+CREATE INDEX if not exists gis_ogc_service_isadmin_btree_idx
+  ON gis.ogc_service
+  USING btree
+  (ispublic);
+
+CREATE INDEX if not exists gis_ogc_service_ispublic_btree_idx
+  ON gis.ogc_service
+  USING btree
+  (ispublic);
+
+CREATE INDEX if not exists gis_ogc_service_name_gin_idx
+  ON gis.ogc_service
+  USING gin
+  (name COLLATE pg_catalog."default" gin_trgm_ops);
+
+CREATE INDEX if not exists gis_ogc_service_name_gin_idx_lower
+  ON gis.ogc_service
+  USING gin
+  (lower(name) COLLATE pg_catalog."default" gin_trgm_ops);
+
+CREATE INDEX if not exists gis_ogc_service_name_trgm_idx
+  ON gis.ogc_service
+  USING gin
+  (name COLLATE pg_catalog."default" gin_trgm_ops);
+
+CREATE INDEX if not exists gis_ogc_service_service_btree_idx
+  ON gis.ogc_service
+  USING btree
+  (service COLLATE pg_catalog."default");
+
+CREATE INDEX if not exists gis_ogc_service_srid_btree_idx
+  ON gis.ogc_service
+  USING btree
+  (srid COLLATE pg_catalog."default");
+
+alter table gis.ogc_service add column if not exists html text;
+comment on column gis.ogc_service.html is 'HTML картки';

package/server/routes/gis/index.mjs

@@ -1,5 +1,3 @@
-import fp from 'fastify-plugin';
-
 import insertColumns from './registers/insert.columns.js';
 import insertFilters from './registers/insert.filters.js';
 import metadataXML from './metadata/metadataXML.js';
@@ -16,6 +14,20 @@ import addGisRegistry from './registers/add.registry.js';
 import deleteGisRegistry from './registers/del.registry.js';
 import getServicesCol from './services/get.services.col.js';
 import legendAuto from './services/legend.auto.js';
+import mapInfoPoint from './ogc/map.info.point.js';
+
+const mapInfoPointSchema = {
+  querystring: {
+    type: 'object',
+    properties: {
+      x: { type: 'number' },
+      y: { type: 'number' },
+      layers: { type: 'string' },
+      index: { type: 'number', minimum: 0 }
+    },
+    required: ['x', 'y', 'layers']
+  }
+};
 
 async function route(app) {
   app.put('/insert-columns/:token', insertColumns);
@@ -40,6 +52,8 @@ async function route(app) {
   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('/map-info-point', { config: { policy: ['public'] }, schema: mapInfoPointSchema }, mapInfoPoint);
 }
 
 export default route;

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