@opengis/gis 0.0.15 → 0.0.17

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

@@ -1,120 +0,0 @@
-import { config, getMeta, getFilterSQL, getTemplate, metaFormat, pgClients } from '@opengis/fastify-table/utils.js';
-
-const layerMetaColumns = ['id', 'name', 'label', 'source', 'table', 'pk', 'geomColumn', 'srid', 'cls', 'htmls'];
-
-export default async function mapFeaturesPoint({ pg = pgClients.client, params = {}, query = {} }, reply) {
-    const { slug, id } = params;
-    const { x, y, sql } = query;
-
-    if (!slug) {
-        return reply.status(400).send('not enough params: slug');
-    }
-
-    if (!(x && y) && !id) {
-        return reply.status(400).send('not enough params: xy');
-    }
-
-    const loadTemplate = await getTemplate('map', slug);
-
-    if (!loadTemplate) {
-        return reply.status(404).send('map not found');
-    }
-
-    const index = loadTemplate?.find?.(el => el[0].split('.').shift() === 'index')?.[1];
-
-    const layers = !index
-        ? loadTemplate?.layers
-        : loadTemplate?.filter?.(el => el[0].split('.').shift() !== 'index')?.map(el => ({ ...el[1], id: el[0].replace('.yml', '').replace('.json', '') }));
-
-    if (!layers?.length) {
-        return reply.status(404).send('map layers not found');
-    }
-
-    if (!layers.filter(el => el.source_path).length) {
-        return reply.status(404).send('map layers sources not provided');
-    }
-
-    const point = `srid=4326;point(${x} ${y})`; // 30, 50
-
-    const { srids } = await pg.queryCache?.('select json_agg(srid) as srids from spatial_ref_sys').then(el => el.rows?.[0] || {}) || {};
-
-    await Promise.all(layers.map(async (layer, idx) => {
-        const { source_path: source, srid = 4326, id: layerId, name } = 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 cls = columns
-            ?.filter(el => el.name && el.data)
-            ?.reduce?.((acc, curr) => ({ ...acc, [curr.name]: curr.data }), {});
-        const htmls = columns
-            ?.filter(el => el.name && el.html)
-            ?.reduce?.((acc, curr) => ({ ...acc, [curr.name]: curr.html }), {});
-
-        const pk = pg.pk?.[table] || loadTable?.key;
-
-        const { optimizedSQL } = await getFilterSQL({ pg, table: source, query: layer?.query });
-
-        Object.assign(layer, {
-            layer: (layerId || name || idx.toString())?.replace?.(/'/g, "''"),
-            table,
-            pk,
-            cls,
-            htmls,
-            geomColumn: geom,
-            optimizedSQL,
-            srid,
-            step: srids?.includes?.(srid - 0) && srid !== 4326 ? 10 : 0.0002,
-        });
-    }));
-
-    const unique = layers
-        .filter((el, idx, arr) => el.table && arr.map((item) => item.table).indexOf(el.table) === idx);
-
-    const q = unique.map((el) => {
-        const where = id
-            ? `${el.pk}::text='${id.replace(/'/g, "''")}'`
-            : `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`;
-        return `select ${el.pk}::text as pk, '${el.layer}' as layer,
-    row_to_json(t) as data, 
-    ${id ? 'null' : `st_distance(${el.geomColumn},'${point.replace(/'/g, "''")}')`} as distance,
-    st_asgeojson(${el.geomColumn})::json as geom from (${el.optimizedSQL}) t 
-    where ${where}`;
-    }).join(' union all ').concat(' order by distance');
-
-    if (sql === '1') return q;
-
-    const { rows: objects = [] } = await pg.query(q);
-
-    if (!objects.length) {
-        return reply.status(200).send(`object not found: ${id}`);
-    }
-
-    const layerData = layers.find((el) => (el.id || el.name) === objects[0].layer) || {};
-    const rows = objects.slice(0, 1).map(el => ({ ...el.data, data: undefined }));
-
-    const { cls, htmls } = layerData;
-    await metaFormat({ rows, cls, htmls, sufix: false }, pg);
-
-    const resp = {
-        meta: {
-            ...layerMetaColumns.reduce((acc, curr) => ({ ...acc, [curr]: layerData[curr] }), {}),
-            distance: objects[0].distance,
-        },
-        data: {
-            id: rows[0][layerData.pk],
-            ...rows[0],
-        },
-    };
-
-    return reply.status(200).send(resp);
-}

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

@@ -1,111 +0,0 @@
-import { pgClients, getTemplate } from "@opengis/fastify-table/utils.js";
-import { attachClassifiers } from '../../gis/registers/funcs/classifiers.js';
-import formatDate from '@opengis/fastify-table/server/helpers/format/formatDate.js';
-
-const pg = pgClients.client;
-
-export default async function mapFormat(req, reply) {
-    const { query } = req;
-    const { layer, id, map } = query;
-    const time = Date.now();
-
-    if (!layer || !id) return reply.status(404).send('not enough params: layer,id,map is required');
-
-    let service = null;
-
-    if (map) {
-        const {
-            rows: [mapLayer],
-        } = await pg.query(
-            `select s.*
-             from gis.maps_layers ml
-             join gis.services s on s.service_id = ml.service_id
-             join gis.maps m on m.map_id = ml.map_id
-             where m.map_key = $1 and s.service_key = $2`,
-            [map, layer]
-        );
-
-        if (mapLayer) {
-            service = mapLayer;
-        }
-    } else {
-        const {
-            rows: [s],
-        } = await pg.query(`SELECT * FROM gis.services WHERE service_id = $1`, [layer]);
-
-        if (s) {
-            service = s;
-        }
-    }
-
-    let source_path, attributes, tpl;
-    if (service) {
-        ({ source_path, attributes } = service);
-    } else {
-        // git
-        tpl = await getTemplate('map', map);
-        const matchedLayer = tpl?.layers?.find(l => l.id === layer || l.service === layer);
-        if (!matchedLayer || !matchedLayer.source_path || !matchedLayer.card) {
-            return reply.status(404).send('template not found');
-        }
-
-        source_path = matchedLayer.source_path;
-        attributes = matchedLayer.card;
-    }
-
-    const columns = attributes;
-    if (!source_path) return reply.status(404).send('missing source_path');
-
-    const pk = pg.pk?.[source_path];
-    if (!pk) return reply.status(404).send('missing pk');
-
-    if (!columns) return reply.status(404).send('columns setting not found');
-
-    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: [row]
-    } = await pg.query(
-        `SELECT ${pk} as "id", geom::json, ${filteredColumns.map(n => `"${n}"`).join(", ")} FROM ${source_path} WHERE ${pk} = $1`,
-        [id]
-    );
-
-    if (!row) return reply.status(404).send('object not found');
-
-    const classifiers = columns
-        .filter(col => col.data && ["select", "badge", "tags"].includes(col.format))
-        .map(col => ({ name: col.name, classifier: col.data }));
-
-    const fullRow = await attachClassifiers(row, classifiers);
-    const result = [];
-    for (const col of columns) {
-        if (excluded.includes(col.name)) continue;
-        if (col.hidden_card === true) continue;
-
-        const name = col.ua || col.name;
-        let value;
-        value = fullRow[`${col.name}_data`]?.text
-            || fullRow[`${col.name}_text`]
-            || fullRow[col.name]
-            || '-';
-
-        if (col.format === 'date' && fullRow[col.name]) { value = formatDate(fullRow[col.name], { hash: { format: 'dd.mm.yy' } }); }
-
-        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>`);
-    }
-
-    const html = `<dl class="divide-y divide-gray-100 py-[5px]">${result.join('')}</dl>`;
-
-    return {
-        time: Date.now() - time,
-        id,
-        rows: fullRow,
-        columns,
-        html
-    };
-}

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

@@ -1,148 +0,0 @@
-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 Sphericalmercator from '@mapbox/sphericalmercator';
-
-import { getTemplate, pgClients, getFilterSQL, getMeta } from '@opengis/fastify-table/utils.js';
-
-import rootFolder from '../../../plugins/mapnik/funcs/rootFolder.mjs';
-
-const limit = 3000;
-const mercator = new Sphericalmercator({ size: 256 });
-const types = { point: 'ST_Point', polygon: 'ST_Polygon,ST_MultiPolygon' };
-const systemColumns = ['uid', 'cdate', 'editor_id', 'editor_date', 'created_by', 'created_at', 'updated_by', 'updated_at'];
-
-export default async function mapTiles({ pg = pgClients.client, params = {}, query = {}, unittest }, reply) {
-    const { slug, y, z } = params;
-    const { sql, nocache, filter, pointZoom, type, layers } = query;
-    const x = params.x?.split?.('.')?.[0] - 0;
-
-    if (!slug) {
-        return reply.status(400).send('not enough params: slug');
-    }
-
-    if (!x || !y || !z) {
-        return reply.status(400).send('not enough params: xyz');
-    }
-
-    const bbox = mercator.bbox(+y, +x, +z, false);
-    const bbox2d = `'BOX(${bbox[0]} ${bbox[1]},${bbox[2]} ${bbox[3]})'::box2d`;
-
-    const headers = {
-        'Content-Type': 'application/x-protobuf',
-        'Cache-Control': nocache || sql ? 'no-cache' : 'public, max-age=86400',
-    };
-
-    const hash = [filter].filter((el) => el).join();
-
-    const filepath = path.join(
-        rootFolder,
-        `/map/vtile/${slug}/${hash ? `${createHash('md5').update(hash).digest('hex')}/` : ''}${z}/${x}/${y}.pbf`
-    );
-
-    if (existsSync(filepath) && z < 13 && !nocache && !sql && !unittest) {
-        const { birthtimeMs = Date.now() } = await stat(filepath);
-        const ageInMs = Date.now() - birthtimeMs;
-        if (ageInMs < 86400000) {
-            const buffer = await readFile(filepath);
-            return reply.status(200).headers(headers).send(buffer);
-        }
-    }
-
-    const loadTemplate = await getTemplate('map', slug);
-
-    if (!loadTemplate) {
-        return reply.status(404).send('map not found');
-    }
-
-    const index = loadTemplate?.find?.(el => el[0].split('.').shift() === 'index')?.[1];
-
-    const layers1 = !index
-        ? loadTemplate?.layers
-        : loadTemplate?.filter?.(el => el[0].split('.').shift() !== 'index')?.map(el => ({ ...el[1], id: el[0].replace('.yml', '').replace('.json', '') }));
-
-    if (!layers1?.length) {
-        return reply.status(404).send('map layers not found');
-    }
-
-    if (!layers1.filter(el => el.source_path).length) {
-        return reply.status(404).send('map layers sources not provided');
-    }
-
-    layers1.forEach(el => Object.assign(el, { name: el.name || el.id }));
-
-    const q = (await Promise.all(layers1.filter(el => el.name && el.source_path).filter(el => layers ? layers.includes(el.name) : true).map(async (layer) => {
-        const { source_path: source, id, name, style, geometry_type: gt, query: lquery, geometry_column: gCol } = layer;
-        const loadTable = await getTemplate('table', source);
-
-        const table = loadTable?.table || source;
-        const meta = await getMeta({ pg, table });
-        const { columns = [] } = meta || {};
-        const geom = gCol || meta?.geom || 'geom';
-        if (!columns?.length) return null;
-
-        const pk = pg.pk?.[table] || loadTable?.key;
-        const fData = filter ? await getFilterSQL({ pg, table: source, filter }) : {};
-
-        const geomCol = parseInt(z, 10) < parseInt(pointZoom || '0', 10) || (style?.centroid && gt === 'point')
-            ? `ST_Centroid(${geom})`
-            : geom;
-
-        const columnsFiltered = columns
-            .filter(el => !['json', 'geometry'].includes(pg.pgType?.[el.dataTypeID]) && !systemColumns.includes(el.name));
-
-        const props = columnsFiltered.map(el => {
-            return el.type?.[0] === '_'
-                ? `${el.name}[1] as ${el.name}`
-                : `${el.name}${['int4'].includes(el.type) ? '::text' : ''}`;
-        });
-
-        return `SELECT ST_AsMVT(q, '${(id || name).replace(/'/g, "''")}', 4096, 'geom','row') as tile
-                      FROM (
-                        SELECT  /*substr(${pk},12)::int*/ /*${(y - 0 + x) * 10000} + row_number() over()*/ 
-
-                           row_number() over() as row,
-                            
-                           ${style?.colorAttr ? `${style.colorAttr},` : ''} ${props?.length ? `${props.map(el => `"${el}"`).join(',')},` : ''}
-
-                            ${pk} as  id, 
-                            ST_AsMVTGeom(st_transform(${geomCol},3857),ST_TileEnvelope(${z},${y},${x})::box2d,4096,256,true) geom
-
-                            FROM (select * from ${table} where ${loadTable?.query || '1=1'} and ${fData?.q || 'true'} and ${geom} && ${bbox2d} 
-                            
-                            and ${geom} is not null and st_srid(${geom}) >0
-                            
-                        ${types[type] ? ` and ST_GeometryType(${geom}) = any ('{ ${types[type]} }') ` : ''}
-
-                        and ${lquery || '1=1'}
-                        
-                        ${gt === 'polygon' ? `order by st_area(st_transform(${geom},3857)) desc` : ''}
-
-                        limit ${limit})q
-                      ) q`;
-    }))).filter(el => el).join(' union all ');
-
-    if (sql === '1') return q;
-    if (sql === '2') return filepath.replace(/\\/g, '/');
-
-    const tile = await pg.query(q);
-
-    if (unittest && !tile.rows?.length) {
-        console.log(slug, q);
-    }
-
-    if (sql === '3') return tile.rows.map((el) => el.tile);
-
-    if (sql === '4') return tile.rows.map((el) => el.tile);
-
-    const buffer = Buffer.concat(tile.rows.map((el) => Buffer.from(el.tile)));
-
-    if (!nocache) {
-        await mkdir(path.dirname(filepath), { recursive: true });
-        await writeFile(filepath, buffer, 'binary');
-    }
-
-    return reply.status(200).headers(headers).send(buffer);
-}

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

@@ -1,16 +0,0 @@
-import { getTemplatePath, getTemplateSync } from "@opengis/fastify-table/utils.js";
-
-const arr = getTemplatePath('map') || [];
-
-const list = arr.map(el => {
-    const { name = el[0] } = getTemplateSync('map', el[0]);
-    return { name, slug: el[0] };
-});
-
-export default async function mapList(req, reply) {
-    if (!arr.length) {
-        return reply.status(200).send([]);
-    }
-
-    return reply.status(200).send(list);
-}

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

@@ -1,42 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath } from 'url';
-
-async function downloadImage(url, file) {
-  const resp = await fetch(url);
-  if (resp.status !== 200) throw new Error(`${url} - not found`);
-  const blob = await resp.blob();
-
-  const arrayBuffer = await blob.arrayBuffer();
-
-  const buffer = Buffer.from(arrayBuffer);
-
-  fs.writeFileSync(file, buffer);
-}
-
-const filename = fileURLToPath(import.meta.url);
-const dirname = path.dirname(filename);
-
-const fileIconDir = path.join(dirname, '../../../../log/marker-icon');
-
-fs.mkdirSync(fileIconDir, { recursive: true });
-
-export default async function markerIconApi(req, reply) {
-  const { params = {} } = req;
-  params.data = params['*'];
-  if (!params.data) {
-    return reply.status(400).send('not enough params: data');
-  }
-
-  const iconPath = path.join(fileIconDir, params?.data);
-
-  if (fs.existsSync(iconPath)) {
-    return fs.createReadStream(iconPath);
-  }
-
-  await downloadImage(`https://data.softpro.ua/api-user/marker/${params.data}`, iconPath).catch(err => {
-    return reply.status(404).send('icon not found');
-  });
-  return fs.createReadStream(iconPath);
-
-}

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

@@ -1,133 +0,0 @@
-import Sphericalmercator from '@mapbox/sphericalmercator';
-import path from 'node:path';
-import { existsSync } from 'node:fs';
-import { mkdir, writeFile, readFile } from 'node:fs/promises';
-
-import { config, logger, pgClients } from '@opengis/fastify-table/utils.js';
-
-import rootFolder from '../../../plugins/mapnik/funcs/rootFolder.mjs';
-import rasterXML from '../../../plugins/mapnik/funcs/rasterXML.js';
-import mapnik from '../../../plugins/mapnik/funcs/mapnik.js';
-
-const { render, loadXML } = mapnik();
-
-const mercator = new Sphericalmercator({ size: 256 });
-
-const loaded = {};
-const autoGenerate = {};
-/**
- * Формування растрового tile cartoCss
- *
- * @method GET
- * @alias rtile
- * @param {String} bbox - bbox
- * @param {Number} height - висота по координатам
- * @param {Number} width - ширина по координатам
- * @param {String} data - стилізація
- * @param {String} lang - мова
- * @param {String} z - координата z
- * @param {String} x - координата y
- * @param {String} y - координата x
- */
-
-export default async function rtile({
-    pg = pgClients.client, params = {}, query = {}, user = {},
-}, reply) {
-    const { id, z, y } = params;
-    const { debug, nocache } = query;
-    const db = pg.options?.database;
-
-    const x = params.x.split('.')[0] - 0;
-
-    if (!id) {
-        return reply.status(400).send('not enough params: id');
-    }
-
-    if (!x || !y || !z) {
-        return reply.status(400).send('not enough params: xyz');
-    }
-
-    const exists = pg.pk?.['gis.rasters']
-        ? await pg.query('select raster_id from gis.rasters where raster_id=$1::text', [id])
-            .then(el => el.rows?.[0]?.raster_id)
-        : null;
-
-    if (!exists) {
-        return reply.status(404).send('raster not found');
-    }
-
-    const bbox = mercator.bbox(y, x, z, false, '900913');
-    const styleXmlPath = path.join(rootFolder, 'mapnik', `${db}_${id}.xml`).replace(/\\/g, '/');
-
-    if (debug === '1' && user?.uid) {
-        return `python3 test/debug.py tmp/${id}.xml ${bbox.join(',')} /data/softpro/work/1.png`;
-    }
-
-    const filepath = path.join(
-        rootFolder,
-        `/rtile/${id}${z}/${x}/${y}.png`
-    ).replace(/\\/g, '/');
-
-    if (debug === '2' && user?.uid) {
-        const sourcePath = await pg.query('SELECT source_path from gis.rasters where raster_id=$1', [id]).then(el => el.rows?.[0]?.source_path);
-        const fullPath = sourcePath ? path.posix.join(config.mapServerRoot || '', config.folder, '/map/raster/', sourcePath, (sourcePath?.toLowerCase?.()?.includes?.('.tif') ? '' : 'mosaic.vrt')) : null;
-        return { rootFolder, filepath, styleXmlPath, fullPath };
-    }
-
-    if (existsSync(filepath) && !nocache && !debug) {
-        reply.headers({ 'Cache-Control': 'public, max-age=5184000', 'Content-Type': 'image/png', 'Cache-File': true });
-        return readFile(filepath);
-    }
-
-    try {
-        if (!autoGenerate[id] || debug === '3') {
-            const resp = await rasterXML({ id, pg });
-
-            if (resp?.error) {
-                return reply.status(400).send(resp.error);
-            }
-
-            if (debug === '3' && user?.uid) {
-                return resp;
-            }
-
-            autoGenerate[id] = 1;
-        }
-
-        if (!loaded[id] || debug === '4') {
-            const xml = await readFile(styleXmlPath, 'utf-8');
-
-            if (debug === '4' && user?.uid) {
-                return xml;
-            }
-
-            await loadXML({ name: id, xml, reload: true });
-            loaded[id] = 1;
-        }
-
-        const data = await render({
-            name: id,
-            width: 256,
-            height: 256,
-            bbox,
-        });
-
-        if (debug === '5' && user?.uid) {
-            return { data, bbox, id, filepath };
-        }
-
-        if (data.err) {
-            return data.err;
-        }
-
-        const buffer = Buffer.from(data.base64, 'base64');
-
-        await mkdir(path.dirname(filepath), { recursive: true });
-        await writeFile(filepath, buffer);
-
-        return reply.headers({ 'Content-Type': 'image/png' }).send(buffer);
-    } catch (err) {
-        logger.file('rtile/error', { error: err.toString(), stack: err.stack });
-        return reply.status(500).send('rtile error');
-    }
-}