@opengis/gis 0.2.167 → 0.2.169

package/module/test/select/address_id.sql

@@ -1,8 +0,0 @@
-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/select/core.user_uid.sql

@@ -1 +0,0 @@
-select uid, coalesce(coalesce(sur_name,'')||coalesce(' '||user_name,'') ||coalesce(' '||father_name,''),login) as text from admin.users

package/module/test/table/data_address.street.table.json

@@ -1,70 +0,0 @@
-{
-    "key": "str_id",
-    "table": "data_address.street",
-    "controls": [
-        "search",
-        "list",
-        "add"
-    ],
-    "form": "data_address.street.form",
-    "access": "user",
-    "sqlColumns": "*",
-    "order": "cdate desc",
-    "columns": [
-        {
-            "ua": "Назва вулиці",
-            "meta": "title",
-            "name": "name",
-            "format": "text"
-        },
-        {
-            "ua": "Статус",
-            "name": "status",
-            "data": "address.status",
-            "format": "select"
-        },
-        {
-            "ua": "Тип об'єкта",
-            "name": "type",
-            "data": "str_type",
-            "format": "select"
-        },
-        {
-            "ua": "Територіальна належність",
-            "name": "parent",
-            "data": "address.atu.object_id_all",
-            "width": 300,
-            "format": "select"
-        },
-        {
-            "ua": "Довжина вулиці",
-            "name": "str_length",
-            "html": "{{num_format str_length dec='2'}}",
-            "format": "number"
-        },
-        {
-            "ua": "Версія",
-            "name": "version",
-            "format": "text"
-        }
-    ],
-    "meta": {
-        "search": "name",
-        "title": "name"
-    },
-    "ua": "Вулиці",
-    "filterList": [
-        {
-            "ua": "Тип об'єкта",
-            "name": "type",
-            "data": "str_type",
-            "type": "Autocomplete"
-        },
-        {
-            "ua": "Статус",
-            "name": "status",
-            "data": "address.status",
-            "type": "Autocomplete"
-        }
-    ]
-}

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

@@ -1,123 +0,0 @@
-{
-  "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/server/routes/gis/checkXML.js

@@ -1,117 +0,0 @@
-import path from 'node:path';
-
-import { config, eventStream, pgClients } from "@opengis/fastify-table/utils.js";
-
-import mapnik from "../../plugins/mapnik/funcs/mapnik.js";
-
-const {
-    GetRasterStatus, GetRasterInfo, RenderTile,
-} = mapnik();
-
-export default async function checkXML(req, reply) {
-    const { pg = pgClients.client } = req;
-    const send = process.env.NODE_ENV === 'test' || process.env.VITEST
-        ? console.log
-        : eventStream(reply);
-
-    const errors = { raster: 0, css: 0, service: 0 };
-    try {
-        const rasters = pg?.pk?.['gis.rasters'] ? await pg.query('select * from gis.rasters').then(el => el.rows || []) : [];
-
-        const css = pg?.pk?.['gis.cartocss'] ? await pg.query('select * from gis.cartocss').then(el => el.rows || []) : [];
-
-        const dataset = pg?.pk?.['gis.dataset'] && false ? await pg.query('select * from gis.dataset').then(el => el.rows || []) : [];
-
-        const total = rasters.length + css.length + dataset.length;
-        let successCount = 0;
-
-        send(`Всього растрів: ${rasters.length || '0'}`);
-
-        await rasters.reduce(
-            (promise, row, idx) => promise.then(async () => {
-                const uploadStatus = path.extname(row.source_path) ? await GetRasterStatus({ path: row.source_path }) : {};
-
-                if (uploadStatus.exists === false) {
-                    errors.raster += 1;
-                    send(`${idx}/${rasters.length} ERROR: GetRasterStatus: not uploaded (raster:${row.raster_id}/${row.name})`);
-                    return null;
-                }
-
-                if (uploadStatus.finished === false) {
-                    errors.raster += 1;
-                    send(`${idx}/${rasters.length} ERROR: GetRasterStatus: upload not finished (raster:${row.raster_id}/${row.name})`);
-                    return null;
-                }
-
-                const rasterInfo = await GetRasterInfo({
-                    path: row.source_path,
-                }).catch(err => ({ err }));
-
-                if (rasterInfo.err) {
-                    errors.raster += 1;
-                    send(`${idx}/${rasters.length} ERROR: GetRasterInfo: ${rasterInfo.err} (raster:${row.raster_id}/${row.name})`);
-                    return null;
-                }
-
-                const data = await RenderTile({
-                    path: row.source_path,
-                    width: 256,
-                    bbox: [3713463.7081504324, 6088362.176970857, 3713616.5822070027, 6088515.051027427], // /:id/18/155363/91245.png
-                    ttl: '0',
-                }).catch(err => ({ err: err.toString() }));
-
-                if (data.err) {
-                    errors.raster += 1;
-                    send(`${idx}/${rasters.length} ERROR: RenderTile: ${data.err} (raster:${row.raster_id}/${row.name})`);
-                    return null;
-                }
-
-                send(`${idx}/${rasters.length} OK: (raster:${row.raster_id}/${row.name})`);
-                successCount += 1;
-            }),
-            Promise.resolve(),
-        );
-
-        send(`Всього CSS: ${css.length || '0'}`);
-
-        await css.reduce(
-            (promise, row, idx) => promise.then(async () => {
-                const data = await RenderTile({
-                    path: row.source_path,
-                    name: row.source_path ? undefined : row.cartocss_id,
-                    width: 256,
-                    bbox: [3713463.7081504324, 6088362.176970857, 3713616.5822070027, 6088515.051027427], // /:id/18/155363/91245.png
-                    ttl: '0',
-                }).catch(err => ({ err: err.toString() }));
-
-                if (data.err) {
-                    errors.css += 1;
-                    send(`${idx}/${css.length} ERROR: RenderTile: ${data.err} (css:${row.cartocss_id}/${row.name})`);
-                    return null;
-                }
-
-                send(`${idx}/${css.length} OK: (css:${row.cartocss_id}/${row.name})`);
-                successCount += 1;
-            }),
-            Promise.resolve(),
-        );
-
-        send(`Всього наборів: ${dataset.length || '0'}`);
-        // ? place dataset check logic here
-
-        const errorCount = Object.keys(errors).reduce((acc, curr) => acc + errors[curr], 0);
-        send(`Всього помилок: ${errorCount || '0'}`);
-        send(`Помилки растрів: ${errors.raster || '0'}`);
-        send(`Помилки CSS: ${errors.css || '0'}`);
-        send(`Помилки наборів: ${errors.dataset || '0'}`);
-
-        send(`Успіх: ${successCount || '0'}/${total || '0'}`);
-    }
-    catch (err) {
-        send(config.local ? err.toString() : 'check error');
-        throw err; // allow logger to catch error automatically
-    }
-    finally {
-        send('finish', true);
-    }
-}

package/server/routes/gis/dashboard.js

@@ -1,29 +0,0 @@
-import { pgClients } from '@opengis/fastify-table/utils.js';
-
-export default async function getDashboard({ pg = pgClients.client }) {
-  try {
-    const statsQuery = `
-      SELECT
-        (SELECT COUNT(*)::int FROM gis.services) as services_count,
-        (SELECT COUNT(*)::int FROM gis.registers) as registers_count,
-        (SELECT COUNT(*)::int FROM gis.maps) as maps_count,
-        (SELECT COUNT(*)::int FROM gis.ogc_service) as ogc_count
-    `;
-
-    const result = await pg.query(statsQuery);
-    const stats = result?.rows?.[0] || {};
-
-    return {
-      cards: {
-        services: stats.services_count || 0,
-        registers: stats.registers_count || 0,
-        maps: stats.maps_count || 0,
-        ogc: stats.ogc_count || 0,
-      },
-    };
-  }
-  catch (error) {
-    console.error('Dashboard error:', error);
-    return { status: 500, error: 'Internal Server Error' };
-  }
-}

package/server/routes/gis/index.mjs

@@ -1,92 +0,0 @@
-import insertColumns from './registers/insert.columns.js';
-import insertFilters from './registers/insert.filters.js';
-
-import metadataXML from './metadata/metadataXML.js';
-import editMetadata from './metadata/editMetadata.js';
-
-import getLayerGeom from './services/get.layer.geom.js';
-import gisRegistry from './registers/gis.registry.js';
-import gisRegistryList from './registers/gis.registry.list.js';
-import mapRegistry from './registers/map.registry.js';
-import gisExport from './registers/gis.export.js';
-
-import getServices from './services/get.services.js';
-import getServiceUsers from './services/get.service.users.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';
-import getServicesCol from './services/get.services.col.js';
-import legendAuto from './services/legend.auto.js';
-import mapInfoPoint from './ogc/map.info.point.js';
-import getDashboard from './dashboard.js';
-import checkXML from './checkXML.js';
-
-import getCartocss from './cartocss/get.cartocss.js';
-import addCartocss from './cartocss/add.cartocss.js';
-import createRoute from './services/create.route.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'],
-  },
-};
-const editMetadataSchema = {
-  params: {
-    type: 'object',
-    properties: {
-      type: { type: 'string', enum: ['raster', 'css', 'dataset', 'service'] },
-      id: { type: 'string' },
-    },
-    required: ['type', 'id'],
-  },
-};
-
-const params = { config: { package: 'gis' } };
-const publicParams = { config: { policy: 'L0', package: 'gis' } };
-
-async function route(app) {
-  app.get('/gis-check', params, checkXML);
-  app.put('/insert-columns/:token', params, insertColumns);
-  app.put('/insert-filters/:token', params, insertFilters);
-  app.get('/gis-registry/:slug', publicParams, gisRegistry);
-  app.get('/gis-registry/:slug/:objectId', publicParams, gisRegistry);
-  app.get('/gis-registry', publicParams, gisRegistryList);
-  app.post('/gis-registry', publicParams, addGisRegistry);
-  app.put('/gis-registry/:slug', publicParams, addGisRegistry);
-  app.delete('/gis-registry/:slug', publicParams, deleteGisRegistry);
-  app.get('/map-registry/:slug/:id', publicParams, mapRegistry);
-
-  app.get('/xml/:id', publicParams, metadataXML);
-  app.post('/gis-metadata/:type/:id', { ...params, schema: editMetadataSchema }, editMetadata);
-
-  app.get('/get-layer-geom/:id', publicParams, getLayerGeom);
-
-  app.get('/gis-export/:type/:slug', publicParams, gisExport);
-
-  app.get('/gis-service/:id?', publicParams, getServices);
-  app.get('/gis-service/:id/:col', publicParams, getServicesCol);
-  app.post('/gis-service/:id?', publicParams, addService);
-  app.put('/gis-service/:id', publicParams, addService);
-  app.delete('/gis-service/:id', publicParams, deleteService);
-  app.get('/legend-auto/:id', publicParams, legendAuto);
-  app.get('/gis-service-users/:id', publicParams, getServiceUsers);
-
-  app.get('/map-info-point', { ...publicParams, schema: mapInfoPointSchema }, mapInfoPoint);
-
-  app.get('/dashboard', publicParams, getDashboard);
-
-  app.get('/routes', publicParams, createRoute);
-
-  app.get('/gis-css/:id', publicParams, getCartocss);
-  app.post('/gis-css/:id', { config: { policy: 'L0', allowSql: true, package: 'gis' } }, addCartocss);
-}
-export default route;

package/server/routes/gis/metadata/editMetadata.js

@@ -1,34 +0,0 @@
-import { pgClients, dataUpsert } from "@opengis/fastify-table/utils.js";
-
-export default async function editMetadata(req, reply) {
-  const { pg = pgClients.client, body, params } = req;
-  const { type, id } = params || {};
-  const { uid } = req.user || {};
-
-  const q = {
-    raster: 'select 1 from gis.rasters where raster_id = $1',
-    css: 'select 1 from gis.cartocss where cartocss_id = $1',
-    dataset: 'select 1 from gis.dataset where dataset_id = $1',
-    service: 'select 1 from gis.services where service_id = $1',
-  }[type];
-
-  if (!q) {
-    return reply.code(400).send({ error: 'invalid params: type', code: 400 });
-  }
-
-  const exists = await pg.query(q, [id]).then(el => el.rowCount || 0);
-
-  if (!exists) {
-    return reply.code(404).send({ error: `${type} not found: ${id}`, code: 404 });
-  }
-
-  const data = await dataUpsert({
-    pg,
-    id,
-    table: 'gis.metadata',
-    data: { ...body, type, layer_id: id },
-    uid,
-  });
-
-  return reply.status(200).send(data);
-}

package/server/routes/gis/metadata/metadataXML.js

@@ -1,13 +0,0 @@
-import {  handlebars, getTemplate } from "@opengis/fastify-table/utils.js";
-
-export default async function insertColumns(req,reply) {
-  const { params} = req;
-  const { id } = params;
-
-  const pt = await getTemplate('templates','ISO19136_2017_gml_template');
-  const data = await handlebars.compile(pt)({ id: id });
-
-  return reply
-    .header('Content-Type', 'text/xml; charset=utf-8')
-    .send(data);
-}

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

@@ -1,35 +0,0 @@
-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 res = await dataInsert({
-            pg,
-            table: 'gis.registers',
-            data: body,
-            uid: user?.uid,
-        });
-        return reply.status(200).send(res.data);
-    }
-
-    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/insert.columns.js

@@ -1,107 +0,0 @@
-import { getToken } from '@opengis/fastify-table/utils.js';
-/**
- * Автозаповнення колонок Реєстру
- *
- * @method put
- * @summary Автозаповнення колонок Реєстру
- * @alias gis.registers
- * @type api
- * @tag dataset
- * @param   {String} token - токен
- * @returns {Number} status - номер помилки
- * @returns {String} error - опис помилки
- * @returns {String} message - повідомлення про успішне виконання і передача певних даних
- */
-export default async function insertColumns(req,reply) {
-  const {pg, user, params} = req;
-  const token = params.token;
-  if (!token) return { message: 'empty token', status: 400 };
-  try {
-
-    const tokenData = await getToken({ token, uid: user?.uid });
-    if (!tokenData) return reply.code(400).send({ message: 'access restricted', status: 400 });
-
-    const { id, type } = JSON.parse(tokenData) || {};
-    if (!id||!type) return reply.code(403).send({ message: 'access restricted', status: 403 });
-    if (!['services','registers'].includes(type)) return reply.code(403).send({ message: 'invalid type', status: 403 });
-
-    const tableColumn =  (type === 'registers') ? 'table_name':'source_path';
-    const jsonColumn = (type === 'registers') ? 'columns':'attributes';
-    const pk = (type === 'registers')?'register_id':'service_id';
-
-    const select = `update gis.${type} set ${jsonColumn}=
-        (select
-        jsonb_agg(row_to_json(q)) as column_list
-        from
-        (select 
-          q.column_name as name,
-          case 
-            when q.column_name='editor_id' and comment is null then 'Хто редагував'
-            when q.column_name ilike '%geom%' and comment is null then 'Геометрія'
-            when q.column_name='editor_date' and comment is null then 'Дата редагування'
-            when q.column_name='image' and comment is null then 'Зображення'
-            when q.column_name='file' and comment is null then 'Файл'
-            when q.column_name='files' and comment is null then 'Файли'
-            else comment
-          end as ua, 
-          case 
-            when q.data_type in ('text','character varying') then 'text'
-            when q.data_type ='ARRAY' then 'tags'
-            when q.data_type in ('integer','numeric','double precision') then 'number'
-            when q.data_type ='boolean' then 'yes/no'
-            when q.data_type='USER-DEFINED' then 'geom'
-            when q.data_type in ('date','timestamp without time zone') then 'date'
-          end as format,
-          '' as data,
-          false as hidden_register,
-          false as hidden_card
-        from 
-          (
-            select 
-              column_name, 
-              data_type, 
-              table_schema || '.' || table_name as table_name 
-            from 
-              (
-                select 
-                  distinct table_name, 
-                  table_schema, 
-                  column_name, 
-                  data_type
-                from 
-                  information_schema.columns
-              ) q
-          ) q 
-        
-          left join lateral (
-             SELECT
-                pgd.description AS comment,
-                 pgns.nspname||'.'||pgc.relname AS table_name,
-                pg_attribute.attname AS column_name
-                
-                FROM
-                pg_catalog.pg_description pgd
-                JOIN pg_catalog.pg_class pgc ON pgd.objoid = pgc.oid
-                JOIN pg_catalog.pg_namespace pgns ON pgc.relnamespace = pgns.oid
-                JOIN pg_catalog.pg_attribute pg_attribute ON pgc.oid = pg_attribute.attrelid
-                AND pg_attribute.attnum = pgd.objsubid
-          )b on b.column_name=q.column_name and b.table_name=q.table_name
-        where 
-          q.table_name = (
-            select 
-              ${tableColumn} 
-            from 
-              gis.${type} 
-            where
-             ${pk} = '${id}'
-          ) and q.column_name not in ('cdate','uid') and q.data_type<>'json')q
-        )
-        where ${pk} = '${id}'
-        `;
-    await pg.one(select);
-
-    return { message: 'Колонки заповнені упішно', status: 200 };
-  } catch (err) {
-    return reply.code(500).send({ message: err.message, status: 500 });
-  }
-}