@opengis/gis 0.2.175 → 0.2.177

package/dist/{vs-datatable-DqVncrSg.js → vs-datatable-B9WoVk-b.js}

@@ -1,7 +1,7 @@
 import { defineComponent as F, mergeModels as O, defineAsyncComponent as I, useModel as R, ref as y, watch as K, openBlock as o, createElementBlock as s, createElementVNode as e, createVNode as $, unref as x, withCtx as S, createStaticVNode as V, useSlots as P, computed as H, Fragment as b, createTextVNode as U, createCommentVNode as N, renderList as A, normalizeStyle as Q, toDisplayString as M, normalizeClass as z, withModifiers as X, createBlock as Y, resolveDynamicComponent as ee, withDirectives as te, renderSlot as ne } from "vue";
 import { notify as E } from "@opengis/core";
 import { Edit as le, Trash as oe } from "lucide-vue-next";
-import { _ as u } from "./index-CHFLgCGW.js";
+import { _ as u } from "./index-cUagVqgA.js";
 const se = { class: "flex items-center justify-center col-span-3 gap-2" }, re = { class: "flex justify-end p-[20px] gap-[10px] border-t w-full" }, ie = /* @__PURE__ */ F({
   __name: "vs-datatable-controls",
   props: /* @__PURE__ */ O({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengis/gis",
-  "version": "0.2.175",
+  "version": "0.2.177",
   "type": "module",
   "author": "Softpro",
   "main": "./dist/index.js",

package/server/routes/map/functions/mapFormat.js

@@ -1,9 +1,11 @@
-import { BadRequestError } from '@opengis/fastify-table/errors.js';
+import { BadRequestError, NotFoundError } from '@opengis/fastify-table/errors.js';
 import {
   pgClients, getTemplate, handlebars, metaFormat,
   getMeta,
 } from '@opengis/fastify-table/utils.js';
 
+import listFiles from '../../../shared/listFiles.js';
+
 const excluded = ['created_by', 'created_at', 'updated_by', 'geom', 'id', 'uid', 'updated_at', 'cdate', 'editor_date', 'editor_id'];
 
 function getLayerTableQuery({
@@ -31,11 +33,11 @@ async function getLayersData({
   id, lng, lat, cartocss, nogeom, radius,
 }, pg = pgClients.client) {
   if (!(lng && lat) && !id) {
-    return { error: 'not enough params: lat / lng' };
+    throw new Error('not enough params: lat / lng');
   }
 
   if (!cartocss.config?.length && !cartocss.card_table) {
-    return { error: 'empty cartocss.config' };
+    throw new Error('empty cartocss.config');
   }
 
   const point = lng && lat ? `srid=4326;point(${lng} ${lat})`.replace(/'/g, "''") : null;
@@ -65,7 +67,7 @@ async function getLayersData({
   // console.timeEnd(q);
 
   if (!rows.length) {
-    return { error: 'object not found', code: 404 };
+    throw NotFoundError('object not found');
   }
 
   const layerData = rows[0].key ? cartocss.config?.find(el => el.key === rows[0].key) || { table: cartocss?.card_table, columns: cartocss?.card_columns } : {};
@@ -106,17 +108,17 @@ async function getTableData({
   const columns = (card || []).filter((col) => (uid ? true : !col.is_admin));
 
   if (!tname) {
-    return { error: 'missing source_path', code: 400 };
+    throw BadRequestError('missing source_path');
   }
 
   const pk = pg.pk?.[tname];
 
   if (!pk) {
-    return { error: 'missing pk', code: 400 };
+    throw BadRequestError('missing pk');
   }
 
   if (!columns) {
-    return { error: 'columns setting not found', code: 404 };
+    throw NotFoundError('columns setting not found');
   }
 
   const columnNames = columns.map(col => col.name);
@@ -129,7 +131,7 @@ async function getTableData({
   ).then(r => r.rows || []);
 
   if (!rows.length) {
-    return { error: 'object not found', code: 404 };
+    throw NotFoundError('object not found');
   }
 
   const classifiers = columns
@@ -181,10 +183,6 @@ export default async function mapFormat({ layer, id, lat, lng, nogeom, radius =
         service, layer, id, uid, nogeom,
       }, pg);
 
-  if (error) {
-    throw new Error(error);
-  }
-
   rows.forEach(row => Object.assign(row, { box2d: undefined, bounds: row.box2d ? row.box2d.replace(/[A-Z\)\(]+/g, '').split(/[ ,]+/).map(el => el - 0) : null }));
 
   await metaFormat({
@@ -192,6 +190,8 @@ export default async function mapFormat({ layer, id, lat, lng, nogeom, radius =
   });
   const fullRow = rows[0];
 
+  const files = rows.length ? await listFiles({ /*entityType: tname,*/ entityId: fullRow.id }, { pg }) : [];
+
   const result = [];
   const filtered = columns.filter(col => !excluded.includes(col.name));
   for (let i = 0; i < filtered.length; i += 1) {
@@ -222,6 +222,7 @@ export default async function mapFormat({ layer, id, lat, lng, nogeom, radius =
     template,
     html,
     auto,
+    files,
   };
   if (service) {
     res.cardInterface = service.cardInterface;

package/server/routes/registers/functions/getTableColumnMeta.js

@@ -0,0 +1,131 @@
+import {
+    pgClients,
+    getTemplate,
+    getMeta,
+    getSelect,
+    getFilter,
+} from "@opengis/fastify-table/utils.js";
+
+const defaultLimit = 50;
+
+export default async function getTableColumnMeta(
+    {
+        table,
+        template,
+        column: queryColumn,
+        filtered,
+        startsWith,
+        key,
+    },
+    pg = pgClients.client
+) {
+    if (!table || !queryColumn) {
+        return null;
+    }
+
+    const metaColumns = await getMeta(
+        {
+            pg,
+            table,
+        },
+    ).then((r) => r?.columns || []);
+
+    const { dataTypeID } =
+        (metaColumns || []).find((col) => col?.name === queryColumn) || {};
+
+    const { table: tableName, sql } = template
+        ? await getTemplate("table", template)
+        : { table };
+
+    const filters = template
+        ? await getFilter({ pg, table: template }).then((el) => el.list)
+        : null;
+
+    const { data: clsName } =
+        (filters || []).find((el) => el.name === queryColumn) || {};
+    const { arr, sql: select } =
+        (await getSelect(clsName || queryColumn, pg)) || // cls name === table:column
+        (await getSelect(queryColumn, pg)) || // cls name === column name
+        {};
+
+    const sqlTable =
+        (sql || [])
+            .filter(
+                (el) =>
+                    !el.disabled && el.sql && el.sql.includes(queryColumn) && false
+            )
+            .map(
+                (el, i) =>
+                    ` left join lateral (${el.sql}) ${el.name || `t${i}`} on 1=1 `
+            )
+            ?.join("") || "";
+
+    if (arr?.length && !arr.find((el) => el.id === "null")) {
+        arr.push({
+            color: "#B8B8B8",
+            icon: null,
+            id: "null",
+            text: "Показати порожні значення",
+        });
+    }
+
+    // w/out select
+    const searchQueryDefault =
+        startsWith && key
+            ? `(left(lower("text"::text),${key.length}) = $1 )`
+            : '(lower("text"::text) ~ $1 )';
+
+    // w/ select
+    const searchQuerySelect =
+        startsWith && key
+            ? `id in ( with cc(id, text) as (${select}) select id from cc where (left(lower("text"),${key.length})=$1) )`
+            : `id in ( with cc(id, text) as (${select}) select id from cc where (lower("text") ~ $1) )`;
+
+    if (pg.pgType?.[dataTypeID]?.includes("[]")) {
+        const original = filtered
+            ? `with c(id,text) as (select id, id as text from (select unnest("${queryColumn.replace(
+                /"/g,
+                ""
+            )}") as id from ${tableName} t ${sqlTable})q group by id) select id, text from c`
+            : `with c(id,text) as (select id, id as text, count(*) from (select unnest("${queryColumn.replace(
+                /"/g,
+                ""
+            )}") as id from ${tableName} t ${sqlTable})q group by id limit ${defaultLimit}) select * from c`;
+
+        return {
+            arr,
+            original,
+            searchQuery: select ? searchQuerySelect : searchQueryDefault,
+            pk: "id",
+        };
+    }
+
+    const original = filtered
+        ? `with c(id,text) as (select "${queryColumn.replace(
+            /"/g,
+            ""
+        )}" as id, "${queryColumn.replace(
+            /"/g,
+            ""
+        )}" as text from ${tableName} t ${sqlTable} group by "${queryColumn.replace(
+            /"/g,
+            ""
+        )}") select id, text from c`
+        : `with c(id,text) as (select "${queryColumn.replace(
+            /"/g,
+            ""
+        )}"  as id, "${queryColumn.replace(
+            /"/g,
+            ""
+        )}" as text, count(*) from ${tableName} t ${sqlTable} group by "${queryColumn.replace(
+            /"/g,
+            ""
+        )}" limit ${defaultLimit}) select * from c`;
+
+    return {
+        arr,
+        original,
+        searchQuery: select ? searchQuerySelect : searchQueryDefault,
+        pk: "id",
+    };
+}

package/server/routes/registers/functions/gis.suggest.js

@@ -0,0 +1,284 @@
+import { BadRequestError, NotFoundError } from "@opengis/fastify-table/errors.js";
+import { getColumnCLS, getMeta, getRedis, metaFormat } from "@opengis/fastify-table/utils.js";
+
+import getTableColumnMeta from "./getTableColumnMeta.js";
+
+const rclient = getRedis();
+
+const count = false;
+const maxLimit = 100;
+
+export default async function gisSuggest({ token, key, val, limit: limit1 = 50 }, pg) {
+    const time = Date.now();
+
+    const redisKey = `${pg?.options?.database}:registry-filter:${token}`;
+
+    const cache = await rclient.get(redisKey);
+
+    if (!cache) {
+        throw BadRequestError('invalid params: token');
+    }
+
+    const { register, filter } = JSON.parse(cache);
+
+    const {
+        rows: [registry],
+    } = await pg.query(
+        `SELECT register_id, table_name, filters FROM gis.registers WHERE register_id=$1`,
+        [register],
+    );
+
+    if (!registry) {
+        throw NotFoundError('registry not found');
+    }
+
+    if (!registry.table_name) {
+        throw new Error('registry table not set');
+    }
+
+    const filterData = (registry.filters).find(el => el.name === filter);
+
+    if (!filterData) {
+        throw new Error('registry filter not found');
+    }
+
+    const { name, data: cls } = filterData;
+
+    const metaColumns = await getMeta({ pg, table: registry.table_name }).then((r) => r.columns || []);
+
+    const { dataTypeID } = metaColumns.find((col) => col.name === name);
+
+    if (!dataTypeID) {
+        throw NotFoundError('registry column not found: ' + name);
+    }
+
+    const clsMeta = await getTableColumnMeta({
+        table: registry.table_name,
+        column: name,
+        filtered: !!(key || val),
+        key,
+    });
+
+    const { arr, searchQuery } = clsMeta;
+
+    const limit = Math.min(limit1 || maxLimit, maxLimit);
+
+    const [schemaName, tableName] = registry.table_name.split('.');
+
+    const table = [`"${schemaName}"`, `"${tableName}"`].join('.').replace(
+        /'/g,
+        "''"
+    );
+
+    // table:column + cls
+    if (arr && !cls) {
+        const sqlCls = count
+            ? `select value, count(*) from (select ${pg.pgType?.[dataTypeID]?.includes("[]")
+                ? `unnest("${name}")`
+                : `"${name}"`
+            } as value from ${table} where 1=1)q group by value`
+            : `select array_agg(distinct value)::text[] from (select ${pg.pgType?.[dataTypeID]?.includes("[]")
+                ? `unnest("${name}")`
+                : `"${name}"`
+            } as value from ${table} where 1=1)q`;
+
+        if (pg?.pk?.[registry.table_name] && !cls) {
+            const qRes = await pg.queryCache(sqlCls, {
+                table: registry.table_name,
+            });
+            const vals =
+                (count
+                    ? qRes.rows?.map?.((el) => el.value?.toString?.() || null)
+                    : qRes.rows?.[0]?.array_agg) || [];
+
+            const lower = key?.toLowerCase?.();
+            const data1 =
+                key || val
+                    ? arr
+                        ?.filter(
+                            (el) =>
+                                !lower ||
+                                (el[lang] || el.text)?.toLowerCase()?.indexOf(lower) !== -1
+                        )
+                        ?.filter(
+                            (el) => !val || val?.split?.(",")?.includes?.(el.id)
+                        )
+                    : arr;
+
+            const data2 = data1.filter((el) =>
+                el.id === "null"
+                    ? vals.includes(null)
+                    : el.id && vals.includes(el.id.toString())
+            );
+
+            const data = data2.slice(0, limit);
+
+            if (data.length && count) {
+                const counts = qRes.rows?.reduce?.(
+                    (acc, curr) => ({
+                        ...acc,
+                        [curr.value]: curr.count,
+                    }),
+                    {}
+                );
+                data.forEach((el) =>
+                    Object.assign(el, { count: counts?.[el.id] || 0 })
+                );
+            }
+
+            return {
+                time: Date.now() - time,
+                limit,
+                count: data.length,
+                total: arr.length,
+                mode: "array",
+                sql: process.platform === 'win32' ? sqlCls : undefined,
+                data,
+            };
+        }
+    }
+
+    // cls
+    if (arr) {
+        const lower = key?.toLowerCase();
+        const data1 =
+            key || val
+                ? arr
+                    ?.filter(
+                        (el) =>
+                            !lower ||
+                            (el[lang] || el.text)?.toLowerCase()?.indexOf(lower) !== -1
+                    )
+                    ?.filter((el) => !val || val?.split?.(",")?.includes?.(el.id))
+                : arr;
+        const data = data1.slice(0, Math.min(limit1 || limit, limit));
+
+        return {
+            time: Date.now() - time,
+            limit,
+            count: data.length,
+            total: arr.length,
+            mode: "array",
+            data,
+        };
+    }
+
+    const args = [];
+    const where = [];
+
+    // select, with search by text support
+    if (key && typeof key === "string") {
+        args.push(key.toLowerCase());
+        where.push(searchQuery);
+    }
+
+    // pk
+    if (clsMeta.pk) {
+        where.push(`${clsMeta.pk} is not null`);
+    }
+
+    // filter by value
+    if (clsMeta.pk && typeof val === "string") {
+        args.push(val.split(","));
+        where.push(`${clsMeta.pk}=any($${args.length})`);
+    }
+
+    // filter
+    if (pg.pk?.[registry.table_name] && !cls && dataTypeID) {
+        where.push(
+            `id in (select ${pg.pgType[dataTypeID]?.includes("[]")
+                ? `unnest("${name}")`
+                : `"${name}"`
+            } from ${(registry.table_name).replace(/'/g, "''")})`
+        );
+    }
+
+    // order by value if not specified explicitly
+    const order = clsMeta.original.toLowerCase().includes("order by")
+        ? ""
+        : "order by 2";
+
+    const whereQuery = where.filter(Boolean).join(" and ") || "true";
+
+    args.push(limit);
+
+    let sqlSuggest = !cls
+        ? `${clsMeta.original}
+          WHERE EXISTS ( SELECT 1 FROM ${(registry.table_name).replace(
+            /'/g,
+            "''"
+        )} o 
+            WHERE ${pg.pgType[dataTypeID]?.includes("[]")
+            ? `c.id = ANY(o."${name}")`
+            : `o."${name}" IS NOT DISTINCT FROM c.id`
+        } ) and ${whereQuery || "true"}
+          ${order} LIMIT $${args.length}::bigint`
+        : `with c(id,text) as ( ${clsMeta.original} where ${whereQuery} ${order}) select * from c LIMIT $${args.length}::bigint`;
+
+    if (sqlSuggest.includes("{{parent}}")) {
+        args.push(parent || "");
+        sqlSuggest = sqlSuggest.replace(/(['"]?){{parent}}\1/gi, `$${args.length}`);
+    }
+
+    if (sqlSuggest.includes("{{uid}}")) {
+        args.push(uid || "0");
+        sqlSuggest = sqlSuggest.replace(/(['"]?){{uid}}\1/gi, `$${args.length}`);
+    }
+
+    const dataNew = await pg
+        .query(sqlSuggest, args)
+        .then((r) => r.rows || []);
+
+    // in case id / text = Boolean
+    const data = dataNew.filter(
+        (el) => Object.hasOwn(el, "id") && Object.hasOwn(el, "text")
+    );
+
+    data
+        .filter((el) => el.id === null)
+        .forEach((el) =>
+            Object.assign(el, { id: "null", text: "Показати порожні значення" })
+        );
+
+    // table:column + select
+    if (!cls) {
+        const { name: clsName = name, type = "select" } =
+            getColumnCLS(registry.table_name, name) || {};
+
+        await metaFormat(
+            {
+                rows: data,
+                table: registry.table_name,
+                cls: { text: clsName },
+                sufix: true,
+            },
+            pg
+        );
+
+        return {
+            time: Date.now() - time,
+            limit,
+            count: data.length,
+            total: clsMeta.count - 0,
+            mode: type === "cls" ? "array" : "sql",
+            db: clsMeta.db,
+            sql: process.platform === 'win32' ? sqlSuggest : undefined,
+            data: data.map((el) => ({
+                count: el.count,
+                id: el.id,
+                text: el.text_text || el.text,
+                ...(el.text_data || {}),
+            })),
+        };
+    }
+
+    return {
+        time: Date.now() - time,
+        limit,
+        count: data.length,
+        total: clsMeta.count - 0,
+        mode: "sql",
+        sql: process.platform === 'win32' ? sqlSuggest : undefined,
+        data,
+    };
+}

package/server/routes/registers/functions/handleRegistryRequest.js

@@ -1,4 +1,6 @@
-import { getMeta, getFilterSQL, metaFormat, getFilterSQLParametrized } from "@opengis/fastify-table/utils.js";
+import { createHash } from 'node:crypto';
+
+import { getMeta, getRedis, metaFormat, getFilterSQLParametrized } from "@opengis/fastify-table/utils.js";
 import { populateFilterOptions } from './classifiers.js';
 import { extractVisibleColumns } from './columns.js';
 
@@ -12,6 +14,8 @@ const columnType = {
   'timestamp with time zone': 'date',
 };
 
+const rclient = getRedis();
+
 // eslint-disable-next-line import/prefer-default-export
 export async function handleRegistryRequest({
   settings, query, object_id, offset = 0, limit = 16, page = 1, pg, sql,
@@ -23,8 +27,24 @@ export async function handleRegistryRequest({
   const parsedColumns = Array.isArray(columns) ? columns : JSON.parse(columns);
   const parsedCardColumns = Array.isArray(card) ? card : JSON.parse(card);
   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}` : ''}`,
+  const activeFilters = await Promise.all((filtersParsed || []).filter((f) => f.disabled !== true).map(async (el) => {
+    const hash = createHash('md5').update([register_id, el.name, el.data].filter(Boolean).join('-')).digest('hex');
+    const redisKey = `${pg?.options?.database}:registry-filter:${hash}`;
+
+    const r = {
+      ...el, id: el.name || el.id, type: el.type, api: `/api/gis-suggest/${hash}`
+    };
+
+    const unique = await rclient.setnx(redisKey, 1);
+    const ttl = await rclient.ttl(redisKey);
+
+    // skip subsequent calls
+    if (!unique && ttl !== -1) {
+      return r;
+    }
+
+    await rclient.set(redisKey, JSON.stringify({ register: register_id, filter: el.name }), 'EX', 15 * 60);
+    return r;
   }));
   const { columns: fields1, geom } = await getMeta({ pg, table: table_name });
 

package/server/routes/registers/registers.route.js

@@ -4,6 +4,7 @@ import gisRegistryList from './functions/gis.registry.list.js';
 import gisExport from './functions/gis.export.js';
 import addGisRegistry from './functions/add.registry.js';
 import deleteGisRegistry from './functions/del.registry.js';
+import gisSuggest from './functions/gis.suggest.js';
 
 import {
     gisRegistrySchema,
@@ -12,6 +13,7 @@ import {
     editGisRegistrySchema,
     deleteGisRegistrySchema,
     gisExportSchema,
+    gisSuggestSchema,
 } from './registers.schema.js';
 
 const publicParams = { config: { policy: 'L0', package: 'gis' } };
@@ -76,5 +78,14 @@ async function route(app) {
         }, pg);
         return reply.headers(result.headers).send(result.data);
     });
+    app.get('/gis-suggest/:token', { ...publicParams, schema: gisSuggestSchema }, async ({ params, query, pg }) => {
+        const result = await gisSuggest({
+            token: params.token,
+            key: query.key,
+            val: query.val,
+            limit: query.limit,
+        }, pg);
+        return result;
+    });
 }
 export default route;

package/server/routes/registers/registers.schema.js

@@ -1,6 +1,11 @@
 const queryFilterSchema = { type: 'string', pattern: '^([\\w\\d_-]+)=([А-Яа-яҐґЄєІіЇї\\d\\w\\s\\/\\[\\]\\(\\)\\{\\}\\|,.!?;:—_=-@%#$&^*+=`~]+)$' };
 const querySearchSchema = { type: 'string', pattern: '^([А-Яа-яҐґЄєІіЇї\\d\\w\\s\\/\\[\\]\\(\\)\\{\\}\\|,.!?;:—_=-@%#$&^*+=`~]+)$' };
 
+const keySchema = {
+    type: "string",
+    pattern: "^([А-Яа-яҐґЄєІіЇї\\d\\w\\s_.-:—!?%@#$,'; ]+)$",
+};
+
 const registerSchema = {
     type: 'object',
     additionalProperties: false,
@@ -243,4 +248,23 @@ export const gisExportSchema = {
     },
 };
 
+export const gisSuggestSchema = {
+    params: {
+        type: 'object',
+        required: ['token'],
+        properties: {
+            token: { type: 'string' },
+        },
+    },
+    querystring: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            key: keySchema,
+            val: { type: "string", pattern: "([\\d\\w]+)$" },
+            limit: { type: 'integer', minimum: 1, maximum: 100 },
+        },
+    },
+};
+
 export default null;

package/server/routes/services/services.schema.js

@@ -83,10 +83,17 @@ const serviceBodySchema = {
             type: 'object',
             additionalProperties: false,
             properties: {
-                type: { type: 'string' },
+                type: { type: 'string', enum: ['point', 'line', 'polygon'] },
                 color: { type: 'string' },
-                width: { type: 'number' },
-                icon: { type: 'string' },
+                width: { type: 'integer', minimum: 0, maximum: 10 },
+                icon: { type: ['string', 'null'] },
+                iconAttr: { type: 'string', pattern: '^([\\d\\w._-]+)$' },
+                iconZoom: { type: 'integer', minimum: 0, maximum: 22 },
+                cluster: { type: 'boolean' },
+                clusterMaxZoom: { type: 'integer', minimum: 0, maximum: 22 },
+                label: { type: 'string', pattern: "^\\{[\\d\\w_.-]+\\}$", },
+                border: { type: 'number', minimum: 0, maximum: 10 },
+                opacity: { type: 'number', minimum: 0, maximum: 1 },
             },
         },
 

package/server/shared/listFiles.js

@@ -0,0 +1,15 @@
+const q = `SELECT 
+    file_id, entity_id, entity_type, file_path, uploaded_name, ext, size,
+    uid, cdate, file_type, ismain, isverified, uid as author, file_status
+FROM crm.files c
+where   entity_id=$1
+and     file_status<>3
+order by cdate desc`;
+
+export default async function listFiles({ entityId }, { pg } = {}) {
+    if (!pg) {
+        throw new Error('empty pg');
+    }
+
+    return pg.query(q, [entityId]).then((r) => r.rows);;
+}