@opengis/gis 0.2.85 → 0.2.87

package/package.json

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

package/server/migrations/cartocss.sql

@@ -19,3 +19,7 @@ create table if not exists gis.cartocss(
 
 alter table gis.cartocss add column if not exists geom public.geometry;
 alter table gis.cartocss add column if not exists source_path text;
+alter table gis.cartocss add column if not exists card_auto boolean not null default false;
+alter table gis.cartocss add column if not exists card_html text;
+alter table gis.cartocss add column if not exists card_table text;
+alter table gis.cartocss add column if not exists card_columns text;

package/server/migrations/rasters.sql

@@ -261,4 +261,6 @@ COMMENT ON COLUMN gis.rasters.raster_zoom IS 'Зум для відображен
 COMMENT ON COLUMN gis.rasters.srid IS 'Просторова система координат';
 COMMENT ON COLUMN gis.rasters.center IS 'Центр покриття';
 COMMENT ON COLUMN gis.rasters.bbox IS 'Область покриття сервісу';
-COMMENT ON COLUMN gis.rasters.group_id IS 'id групи';
+COMMENT ON COLUMN gis.rasters.group_id IS 'id групи';
+
+ALTER TABLE gis.rasters add COLUMN if not exists isadmin boolean NOT NULL default false;

package/server/plugins/mapnik/map.proto

@@ -206,6 +206,7 @@ message GetRasterInfoData {
     repeated string bands = 11;
     int64 color_depth = 12;
     string compression = 13;
+    bool xml = 14;
 }
 
 message GetRasterInfoOut {

package/server/routes/gis/cartocss/add.cartocss.js

@@ -14,6 +14,7 @@ export default async function addCartocss(req, reply) {
   }
 
   const sourcePath = body.source_path || cartocss.source_path;
+
   const config = body.config || cartocss.config;
   const style = body.style || cartocss.style;
 

package/server/routes/gis/cartocss/get.cartocss.js

@@ -7,6 +7,8 @@ const { RenderTile } = mapnik();
 
 const { prefix = '/api' } = config;
 
+const exclude = ['created_at', 'updated_at', 'created_by', 'updated_by'];
+
 export default async function checkCarto({
     pg = pgClients.client, params,
 }, reply) {
@@ -15,12 +17,16 @@ export default async function checkCarto({
         return reply.status(400).send({ error: 'mapnik server address needed', code: 400 });
     }
 
-    const cartocss = await pg.query('select config,  ARRAY[ST_XMin(geom), ST_YMin(geom),  ST_XMax(geom),  ST_YMax(geom)] as bounds, cartocss_key,name,description,style,group_id,enabled,is_public, source_path from gis.cartocss where cartocss_id=$1', [params.id]).then(el => el.rows?.[0]);
+    // extract all columns, migrations-agnostic
+    const cartocss = await pg.query('select *, ARRAY[ST_XMin(geom), ST_YMin(geom),  ST_XMax(geom),  ST_YMax(geom)] as bounds, st_asgeojson(geom)::json as geom from gis.cartocss where cartocss_id=$1', [params.id]).then(el => el.rows?.[0]);
 
     if (!cartocss) {
         return reply.status(404).send({ error: `cartocss not found: ${params.id}`, code: 404 });
     }
 
+    // filter system columns
+    Object.keys(cartocss).filter(key => exclude.includes(key)).forEach(key => delete cartocss[key]);
+
     const rtile = await RenderTile({
         name: params.id,
         width: 256,
@@ -34,6 +40,7 @@ export default async function checkCarto({
     return {
         time: Date.now() - time,
         ...cartocss,
+        info: !!(cartocss.card_auto || (cartocss.card_html && cartocss.card_table)),
         url: `${prefix}/gis-rtile/${params.id}/{z}/{x}/{y}.png`,
         bounds,
         render: !!rtile.base64,

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

@@ -1,43 +1,181 @@
 import {
   pgClients, getTemplate, handlebars, metaFormat,
+  getMeta,
 } from '@opengis/fastify-table/utils.js';
 
-export default async function mapFormat(req, reply) {
-  const { pg = pgClients.client, query = {}, user } = req;
-  const { layer, id } = query;
-  const time = Date.now();
+const excluded = ['created_by', 'created_at', 'updated_by', 'geom', 'id', 'uid', 'updated_at', 'cdate', 'editor_date', 'editor_id'];
 
-  if (!layer || !id) return reply.status(404).send('not enough params: layer,id,map is required');
+function getLayerTableQuery({
+  el, id, point, srids, nogeom,
+}, pg = pgClients.client) {
+  const {
+    gcol: geom = 'geom', table, pk = pg.pk[el.table], query: tableQuery, srid, columns,
+  } = el;
+  const step = srids.length && srids.includes(srid - 0) && srid !== 4326 ? 10 : 0.001;
+  return `SELECT
+  ${pk} as "id"
+  ,'${el.key}' as "key"
+  ${nogeom ? '' : `,st_asgeojson(${srid !== 4326 ? `st_transform(${geom}, 4326)` : geom})::json as geom`}, ${srid !== 4326 ? `st_transform(${geom}, 4326)` : geom}::box2d as box2d, ${columns ? `row_to_json(t)` : 'null'} as "data" 
+  ${point ? `,st_distance(${el.srid !== 4326 ? `st_transform(${geom}, 4326)` : geom},'${point} ') as distance` : ''} 
+  FROM ${table} t WHERE ${tableQuery || '1 = 1'} and st_isvalid(${geom}) and st_srid(${geom}) > 0
+and ${point ? `case
+    when ST_GeometryType(${geom}) in ('ST_Polygon','ST_MultiPolygon')
+    then st_intersects(${srid !== 4326 ? `st_transform(${geom}, 4326)` : geom},st_buffer('${point}',${step}))
+
+    when ST_GeometryType(${geom}) in ('ST_LineString','ST_MultiLineString', 'ST_MultiPoint', 'ST_Point')
+    then st_distance(${srid !== 4326 ? `st_transform(${geom}, 4326)` : geom},'${point}') < ${step}
+  else false end` : `${id ? `${pk}='${id.replace(/'/g, "")}'` : '2=2'}`
+    } ${point ? 'order by distance' : ''} limit 1`;
+}
+
+async function getLayersData({
+  id, lng, lat, cartocss, nogeom,
+}, pg = pgClients.client) {
+  if (!(lng && lat) && !id) {
+    return { error: 'not enough params: lat / lng' };
+  }
+
+  if (!cartocss.config?.length) {
+    return { error: 'empty cartocss.config' };
+  }
+
+  const point = lng && lat ? `srid=4326;point(${lng} ${lat})`.replace(/'/g, "''") : null;
+
+  const srids = pg?.queryCache ? await pg.queryCache('select json_agg(srid) from public.spatial_ref_sys').then(el => el.rows?.[0]?.json_agg || []) : [];
+
+  const q = cartocss.card_table
+    ? getLayerTableQuery({
+      el: { key: cartocss.card_table, table: cartocss.card_table, columns: cartocss.card_columns }, id, point, srids, nogeom,
+    }, pg)
+    : cartocss.config.filter((el, idx, arr) => el.key && el.table && pg.pk?.[el.table] && arr.map(item => item.table).indexOf(el.table) === idx).map(el => getLayerTableQuery({
+      el, id, point, srids, nogeom,
+    }, pg)).join(' union all ');
+
+  // console.time(q);
+  const rows = await pg.query(q).then(el => el.rows || []);
+  // console.timeEnd(q);
+
+  if (!rows.length) {
+    return { error: 'object not found', code: 404 };
+  }
+
+  const layerData = rows[0].key ? cartocss.config?.find(el => el.key === rows[0].key) || { table: cartocss?.card_table, columns: cartocss?.card_columns } : {};
 
-  const service = await getTemplate('layer', layer) || (pg.tlist.includes('gis.services') ? await pg.query('SELECT * FROM gis.services WHERE service_id = $1', [layer]).then(res => res.rows[0]) : null);
+  if (rows[0].data && layerData.columns) {
+    const columnNames = layerData.columns.split(',');
+    const rowData = Object.keys(rows[0].data).filter(key => columnNames.includes(key)).reduce((acc, key) => ({ ...acc, [key]: rows[0].data[key] }), {});
+    Object.assign(rows[0], { data: undefined, ...rowData });
+  }
+
+  const metaColumns = cartocss?.card_table && cartocss?.card_columns
+    ? await getMeta({ pg, table: cartocss?.card_table }).then(el => el.columns?.map(({ name }) => ({ name, format: 'text' })) || [])
+    : [];
+
+  const columns = metaColumns.length && cartocss?.card_columns
+    ? metaColumns.filter(el => cartocss?.card_columns.includes(el.name))
+    : Object.keys(rows[0] || {}).map(key => ({ name: key, format: 'text' }));
+
+  return {
+    rows,
+    columns,
+    tname: layerData.table,
+    htmlTemplate: cartocss.card_html,
+  };
+}
 
+async function getTableData({
+  service, layer, id, user,
+}, pg = pgClients.client) {
   const {
-    source_path: tname, cardInterface, card, template,
-  } = service;
+    source_path: tname, card, template,
+  } = service || {};
 
   const columns = (card || []).filter((col) => (user?.uid ? true : !col.is_admin));
-  if (!tname) return reply.status(404).send('missing source_path');
+
+  if (!tname) {
+    return { error: 'missing source_path', code: 400 };
+  }
 
   const pk = pg.pk?.[tname];
-  if (!pk) return reply.status(404).send('missing pk');
 
-  if (!columns) return reply.status(404).send('columns setting not found');
+  if (!pk) {
+    return { error: 'missing pk', code: 400 };
+  }
+
+  if (!columns) {
+    return { error: 'columns setting not found', code: 404 };
+  }
 
   const columnNames = columns.map(col => col.name);
-  const excluded = ['created_by', 'created_at', 'updated_by', 'geom', 'id', 'uid', 'updated_at', 'cdate', 'editor_date', 'editor_id'];
+
   const filteredColumns = columnNames.filter(name => !excluded.includes(name));
 
   const rows = await pg.query(
-    `SELECT ${pk} as "id", geom::json, geom::box2d as box2d ${filteredColumns?.length > 0 ? ',' : ''}  ${filteredColumns.map((n) => `"${n}"`).join(', ')} FROM ${tname} WHERE ${pk} = $1`,
+    `SELECT ${pk} as "id", st_asgeojson(geom)::json as geom, geom::box2d as box2d ${filteredColumns?.length > 0 ? ',' : ''}  ${filteredColumns.map((n) => `"${n}"`).join(', ')} FROM ${tname} WHERE ${pk} = $1`,
     [id],
   ).then(el => el.rows || []);
 
-  if (!rows.length) return reply.status(404).send('object not found');
+  if (!rows.length) {
+    return { error: 'object not found', code: 404 };
+  }
 
   const classifiers = columns
     .filter(col => col.data && ['select', 'badge', 'tags'].includes(col.format))
     .reduce((acc, curr) => ({ ...acc, [curr.name]: curr.data }), {});
 
+  const htmlTemplate = pg?.pk?.['admin.templates'] && service?.card_mode === 'html'
+    ? await pg.query('select body from admin.templates where name=$1 limit 1', [template || layer]).then(el => el.rows?.[0]?.body)
+    : null;
+
+  return {
+    rows,
+    columns,
+    classifiers,
+    tname,
+    htmlTemplate,
+  };
+}
+
+export default async function mapFormat({ pg = pgClients.client, query = {}, user }, reply) {
+  const {
+    layer, id, lat, lng, nogeom,
+  } = query;
+
+  const t1 = Date.now();
+
+  if (!layer) {
+    return reply.status(400).send({ error: 'not enough query params: layer', code: 400 });
+  }
+
+  const service = await getTemplate('layer', layer) || (pg.pk?.['gis.services'] ? await pg.query('SELECT * FROM gis.services WHERE service_id = $1', [layer]).then(el => el.rows[0]) : null);
+  const cartocss = pg.pk?.['gis.cartocss'] ? await pg.query('SELECT * FROM gis.cartocss WHERE cartocss_id = $1', [layer]).then(el => el.rows[0]) : null;
+
+  if (!cartocss && !id) {
+    return reply.status(400).send({ error: 'not enough query params: id', code: 400 });
+  }
+
+  if (cartocss && !cartocss.config?.length) {
+    return reply.status(400).send({ error: 'invalid layer settings: empty config', code: 400 });
+  }
+
+  if (cartocss && !(lat && lng) && !id) {
+    return reply.status(400).send({ error: 'not enough query params: lat and lng / id', code: 400 });
+  }
+
+  const {
+    rows, columns, classifiers, tname, template, error, code = 500, htmlTemplate,
+  } = cartocss
+      ? await getLayersData({
+        cartocss, id, lng, lat, nogeom,
+      }, pg)
+      : await getTableData({
+        service, layer, id, user, nogeom,
+      }, pg);
+
+  if (error) {
+    return reply.status(code).send({ error, code });
+  }
+
   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({
@@ -51,34 +189,32 @@ export default async function mapFormat(req, reply) {
     const col = filtered[i];
 
     const name = col.label || col.ua || col.name;
-    const value = (col.format === 'date' ? new Date(fullRow[col.name]).toLocaleDateString('uk-UA') : null) || fullRow[`${col.name}_data`]?.text
-      || fullRow[`${col.name}_text`]
+    const value = (col.format === 'date' ? new Date(fullRow[col.name]).toLocaleDateString('uk-UA') : null) || fullRow[`${col.name} _data`]?.text
+      || fullRow[`${col.name} _text`]
       || fullRow[col.name];
 
-    result.push(`<div class="grid grid-cols-1 gap-1 py-3 sm:grid-cols-3 sm:gap-4 even:bg-gray-50 text-[12px]">
+    result.push(`< div class="grid grid-cols-1 gap-1 py-3 sm:grid-cols-3 sm:gap-4 even:bg-gray-50 text-[12px]" >
             <dt class="text-gray-900">${name}</dt>
             <dd class="text-gray-700 sm:col-span-2">${value || '-'}</dd>
-        </div>`);
+        </div > `);
   }
 
-  const htmlTemplate = pg?.pk?.['admin.templates'] && service.card_mode === 'html'
-    ? await pg.query('select body from admin.templates where name=$1 limit 1', [template || layer]).then(el => el.rows?.[0]?.body)
-    : null;
-
   const html1 = htmlTemplate ? await handlebars.compile(htmlTemplate)(fullRow) : null;
 
-  const html = html1 || `<dl class="divide-y divide-gray-100 py-[5px]">${result.join('')}</dl>`;
+  const auto = service ? service?.card_mode === 'list' : cartocss?.card_auto;
+  const html = html1 || (auto ? `< dl class="divide-y divide-gray-100 py-[5px]" > ${result.join('')}</dl > ` : undefined);
 
   const res = {
-    time: Date.now() - time,
-    id,
+    time: Date.now() - t1,
+    id: fullRow.id,
     rows: fullRow,
     columns,
     template,
     html,
+    auto,
   };
   if (service) {
-    res.cardInterface = cardInterface;
+    res.cardInterface = service.cardInterface;
   }
 
   return res;

package/server/routes/mapnik/functions/cartoBounds.js

@@ -1,7 +1,7 @@
 import { pgClients } from "@opengis/fastify-table/utils.js";
 
 export default async function cartoBounds({ id, dataset }, pg = pgClients.client) {
-    const sqlBounds = dataset.map(el => ({ tbl: el.table.split('.'), geom: el.gcol || 'geom' })).map(({ tbl, geom }) => `select ST_EstimatedExtent('${tbl[0]}','${tbl[1]}', '${geom}')`);
+    const sqlBounds = dataset.map(el => ({ tbl: el.table.replace(/"/g, "").split('.'), geom: el.gcol || 'geom' })).map(({ tbl, geom }) => `select ST_EstimatedExtent('${tbl[0]}','${tbl[1]}', '${geom}')`);
     // const sqlBounds = dataset.map(el => ({ srid: el.srid || 4326, tbl: el.table.split('.'), geom: el.gcol || 'geom' })).map(({ tbl, geom, srid }) => `select st_transform(st_setsrid(ST_EstimatedExtent('${tbl[0]}','${tbl[1]}', '${geom}'),${srid}),4326) as st_estimatedextent`);
 
     const geom = await pg.query(