@opengis/gis 0.1.77 → 0.1.79

package/server/routes/gis/index.mjs

@@ -12,12 +12,18 @@ import getServices from './services/get.services.js';
 import deleteService from './services/del.service.js';
 import addService from './services/add.service.js';
 
+import addGisRegistry from './registers/add.registry.js';
+import deleteGisRegistry from './registers/del.registry.js';
+
 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.get('/xml/:id', { config: { policy: ['public'] } }, metadataXML);

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

@@ -0,0 +1,36 @@
+import { dataInsert, dataUpdate, pgClients } from "@opengis/fastify-table/utils.js";
+
+export default async function addGisRegistry({
+    method, params = {}, body, pg = pgClients.client, user = {},
+}, reply) {
+    if (method === 'POST') {
+
+        if (!body?.register_key) {
+            return reply.status(400).send('not enough body params: register_key');
+        }
+
+        const { rows = [] } = await dataInsert({
+            pg,
+            table: 'gis.registers',
+            data: body,
+            uid: user?.uid,
+        });
+        return reply.status(200).send(rows[0]);
+    }
+
+    if (!params.slug) {
+        return reply.status(400).send('not enough params: slug');
+    }
+
+    const id = await pg.query('select register_id from gis.registers where register_key=$1', [params.slug]).then(el => el.rows?.[0]?.register_id) || params.slug;
+
+    const row = await dataUpdate({
+        pg,
+        id,
+        table: 'gis.registers',
+        data: body,
+        uid: user?.uid,
+    });
+
+    return reply.status(200).send(row);
+}

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

@@ -0,0 +1,15 @@
+import { dataDelete, pgClients } from "@opengis/fastify-table/utils.js";
+
+export default async function deleteGisRegistry({
+    params = {}, pg = pgClients.client, user = {},
+}, reply) {
+    const id = await pg.query('select register_id from gis.registers where register_key=$1', [params.slug]).then(el => el.rows?.[0]?.register_id) || params.slug;
+
+    const row = await dataDelete({
+        pg,
+        id,
+        table: 'gis.registers',
+        uid: user?.uid,
+    });
+    return reply.status(200).send(row);
+}

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

@@ -1,4 +1,4 @@
-import { getSelectVal } from '@opengis/fastify-table/utils.js';
+import { getSelectVal, getSelect } from '@opengis/fastify-table/utils.js';
 
 export async function attachClassifiers(rowOrRows, classifiers = []) {
     const rows = Array.isArray(rowOrRows) ? rowOrRows : [rowOrRows];
@@ -35,3 +35,49 @@ export async function attachClassifiers(rowOrRows, classifiers = []) {
 
     return rowOrRows;
 }
+
+export async function populateFilterOptions({ pg, table, filters, columns, whereConditions }) {
+    if (!filters?.length || !table || !columns?.length) return;
+
+    const optimizedSQL = `select * from ${table} where ${whereConditions || '1=1'}`;
+
+    await Promise.all(
+        filters
+            .filter(
+                (el) =>
+                    el.id &&
+                    el.type !== "Autocomplete" &&
+                    !el.sql &&
+                    !el.options?.find?.((item) => item.sql)
+            )
+            .map(async (el) => {
+                const cls = el.data ? await getSelect(el.data, pg) : null;
+
+                if (!cls && !el.type?.includes?.("Check")) return;
+                const { dataTypeID } = (columns || []).find((item) => item.name === el.id) || {};
+
+                const q = pg.pgType[dataTypeID || '']?.includes("[]")
+                    ? `select unnest(${el.id})::text as id,count(*) from (${optimizedSQL})q group by unnest(${el.id}) limit 100`
+                    : `select ${el.id}::text as id,count(*) from (${optimizedSQL})q group by ${el.id} limit 100`;
+
+                const countArr = await pg.queryCache(q, { table });
+
+                if (countArr.timeout) {
+                    Object.assign(el, { timeout: countArr.timeout });
+                    console.warn("timeout filter", table, el.id);
+                }
+
+                const ids = countArr.rows.map((el1) => el1.id);
+
+                const clsData = await getSelectVal({ pg, values: ids, name: el.data });
+
+                const options = countArr.rows.map((cel) => {
+                    const data = cls?.arr?.find?.(
+                        (c) => c.id?.toString?.() === cel.id?.toString?.()
+                    ) || { text: clsData?.[cel.id]?.text || clsData?.[cel.id] || cel.id };
+                    return { ...cel, id: cel.id === null ? "null" : cel.id, ...data };
+                });
+                Object.assign(el, { options });
+            })
+    );
+}

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

@@ -1,16 +1,28 @@
-import { attachClassifiers } from './classifiers.js';
+import { attachClassifiers, populateFilterOptions } from './classifiers.js';
 import { extractVisibleColumns } from './columns.js';
 import { getMeta, 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 async function handleRegistryRequest({ settings, query, object_id, offset = 0, limit = 16, page = 1, pg }) {
     const { name, table_name, 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 { geom } = await getMeta({ pg, table: table_name });
+    const activeFilters = (filtersParsed || []).filter((f) => f.disabled !== true);
+    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 }));
 
     const mode = object_id ? "card" : "table";
-    const visibleColumns = extractVisibleColumns(parsedColumns, mode);
+    const visibleColumns = parsedColumns ? extractVisibleColumns(parsedColumns, mode) : [];
     const selectColumns = visibleColumns.map((col) => col.name);
     /*const columnsInfo = visibleColumns.map((col) => ({
         name: col.name,
@@ -26,7 +38,7 @@ export async function handleRegistryRequest({ settings, query, object_id, offset
 
     if (object_id) {
         const sql = `
-            SELECT "${pk}" as id,* , ${selectColumns.join(", ")} ${geom ? `, st_asgeojson(${geom})::json as geom` : ''}
+            SELECT "${pk}" as id,* ${selectColumns.length ? `, ${selectColumns.join(", ")}` : ''} ${geom ? `, st_asgeojson(${geom})::json as geom` : ''}
             FROM ${table_name}
             WHERE ${pk} = $1
         `;
@@ -60,13 +72,12 @@ export async function handleRegistryRequest({ settings, query, object_id, offset
         : { q: '1=1' };
 
     const whereConditions = [whereQuery, sqlFilter].filter(Boolean).join(' AND ');
-    const whereClause = whereConditions ? `WHERE ${whereConditions}` : '';
 
-    const sqlBase = `FROM ${table_name} ${whereClause}`;
+    const sqlBase = `FROM ${table_name} WHERE ${whereConditions || 'true'}`;
     const sqlOrder = order ? `ORDER BY ${order}` : "";
     const sqlLimit = `LIMIT $1 OFFSET $2`;
 
-    const sqlSelect = `SELECT "${pk}" as id, ${selectColumns.join(", ")} ${geom ? `, st_asgeojson(${geom})::json as geom` : ''} ${sqlBase}`;
+    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}`;
 
@@ -79,11 +90,22 @@ export async function handleRegistryRequest({ settings, query, object_id, offset
     const total = parseInt(countRes.rows[0]?.count || 0, 10);
 
     const listConfig = {};
-    for (const col of parsedColumns) {
-        if (col.view_type === 'title') listConfig.title = col.name;
-        if (col.view_type === 'subtitle') listConfig.subtitle = col.name;
+
+    if (parsedColumns?.length) {
+        for (const col of parsedColumns) {
+            if (col.view_type === 'title') listConfig.title = col.name;
+            if (col.view_type === 'subtitle') listConfig.subtitle = col.name;
+        }
     }
 
+    await populateFilterOptions({
+        pg,
+        table: table_name,
+        filters: activeFilters,
+        columns,
+        whereConditions
+    });
+
     return {
         register_id,
         name,
@@ -91,6 +113,7 @@ export async function handleRegistryRequest({ settings, query, object_id, offset
         total,
         columns: visibleColumns,
         filters: activeFilters,
+        fields,
         limit,
         page,
         view,