@opengis/gis 0.2.168 → 0.2.170

package/server/routes/mapnik.prefixless/mapnik.prefixless.route.test.js

@@ -0,0 +1,91 @@
+import {
+    describe, test, expect, beforeAll,
+} from 'vitest';
+
+import { build, injectWithHeaders } from '../../../test/helper.js';
+
+const user = { uid: '2', type: 'admin' };
+
+beforeAll(async () => {
+    await build();
+});
+
+test('GET /logger-gis/stat (restrict unauthorized)', async () => {
+    const res = await injectWithHeaders({
+        method: 'GET',
+        url: '/logger-gis/stat',
+
+    });
+    expect(res.statusCode).toBe(403);
+});
+
+test('GET /logger-gis/stat (restrict non-admin)', async () => {
+    const res = await injectWithHeaders({
+        method: 'GET',
+        url: '/logger-gis/stat',
+        headers: { uid: user.uid, user_type: 'regular' }
+
+    });
+    expect(res.statusCode).toBe(403);
+});
+
+test('GET /logger-gis/stat', async () => {
+    const res = await injectWithHeaders({
+        method: 'GET',
+        url: '/logger-gis/stat',
+        headers: { uid: user.uid, user_type: user.type }
+
+    });
+    expect(res.statusCode).toBe(200);
+
+    const body = res.json();
+
+    expect(body).toHaveProperty('timestamp');
+    expect(body).toHaveProperty('global');
+    expect(body).toHaveProperty('per_map_id');
+    expect(typeof body.global).toBe('object');
+    expect(typeof body.per_map_id).toBe('object');
+    expect(body.global).toHaveProperty('total_use_count');
+    expect(body.global).toHaveProperty('ready_1');
+    expect(body.global).toHaveProperty('total_maps');
+    expect(body.global).toHaveProperty('ready_0');
+    expect(body.global).toHaveProperty('max_in_use');
+    expect(body.global).toHaveProperty('current_in_use');
+    expect(body.global).toHaveProperty('avg_use_time_sec');
+
+    const mapKey = Object.keys(body.per_map_id)[0];
+    if (mapKey) {
+        expect(body.per_map_id[mapKey]).toHaveProperty('use_count');
+        expect(body.per_map_id[mapKey]).toHaveProperty('ready_1');
+        expect(body.per_map_id[mapKey]).toHaveProperty('total');
+        expect(body.per_map_id[mapKey]).toHaveProperty('ready_0');
+        expect(body.per_map_id[mapKey]).toHaveProperty('avg_use_time_sec');
+    }
+});
+
+describe('GET /gis-logger', () => {
+    test('returns log root directories', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: '/logger-gis/',
+            headers: { uid: user.uid, user_type: user.type }
+
+        });
+
+        expect(res.statusCode).toBe(200);
+        expect(res.headers['content-type']).toBe('text/html; charset=UTF-8');
+        expect(res.body).toMatch('<a href=');
+    });
+    test('returns error log directories', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: '/logger-gis/error',
+            headers: { uid: user.uid, user_type: user.type }
+
+
+        });
+        expect(res.statusCode).toBe(200);
+        expect(res.headers['content-type']).toBe('text/html; charset=UTF-8');
+        expect(res.body).toMatch('<a href=');
+    });
+});

package/server/routes/mapnik.prefixless/mapnik.prefixless.schema.mjs

@@ -0,0 +1,27 @@
+// values hardcoded into mapnik
+const periodSchema = {
+  type: 'string', enum: ['1w', '1d', '1h', '5m', '1m']
+};
+
+
+export const mapnikStatSchema = {
+  querystring: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      period: periodSchema,
+    },
+  },
+};
+
+export const mapnikLoggerSchema = {
+  querystring: {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+      debug: { type: "number", minimum: 1, maximum: 10 },
+    },
+  },
+};
+
+export default null;

package/server/routes/maps/functions/add.map.js

@@ -0,0 +1,42 @@
+import { BadRequestError, UnauthorizedError } from "@opengis/fastify-table/errors.js";
+import { dataInsert, dataUpdate, pgClients } from "@opengis/fastify-table/utils.js";
+
+export default async function addMap({
+  method, id, body, uid,
+}, pg = pgClients.client) {
+  if (!uid) {
+    throw UnauthorizedError('unauthorized');
+  }
+
+  if (method === 'POST') {
+    if (!body?.name) {
+      throw BadRequestError('not enough body params: name');
+    }
+
+    if (!body?.map_key) {
+      throw BadRequestError('not enough body params: map_key');
+    }
+
+    const { rows = [] } = await dataInsert({
+      pg,
+      id,
+      table: 'gis.maps',
+      data: body,
+      uid,
+    });
+    return rows[0];
+  }
+
+  if (!id) {
+    throw BadRequestError('not enough params: id');
+  }
+
+  const row = await dataUpdate({
+    pg,
+    id,
+    table: 'gis.maps',
+    data: body,
+    uid,
+  });
+  return row;
+}

package/server/routes/{map/maps → maps/functions}/del.map.js

@@ -1,19 +1,18 @@
+import { UnauthorizedError } from "@opengis/fastify-table/errors.js";
 import { dataDelete, pgClients } from "@opengis/fastify-table/utils.js";
 
 export default async function delMap({
-    params = {}, pg = pgClients.client, user = {},
-}, reply) {
-    const { uid } = user;
-
+    id, uid,
+}, pg = pgClients.client) {
     if (!uid) {
-        return reply.status(401).send('unauthorized');
+        throw UnauthorizedError('unauthorized');
     }
 
     const row = await dataDelete({
         pg,
-        id: params.id,
+        id,
         table: 'gis.maps',
         uid,
     });
-    return reply.status(200).send(row);
+    return row;
 }

package/server/routes/{map/maps → maps/functions}/get.map.js

@@ -1,3 +1,4 @@
+import { NotFoundError } from '@opengis/fastify-table/errors.js';
 import {
   getMeta, getTemplate, pgClients, getTemplates, yml2json,
 } from '@opengis/fastify-table/utils.js';
@@ -14,7 +15,7 @@ const columnType = {
   'timestamp with time zone': 'date',
 };
 
-export default async function getMap({ params = {}, pg = pgClients.client }, reply) {
+export default async function getMap({ id }, pg = pgClients.client) {
   const { columns = [] } = await getMeta({ pg, table }) || {};
 
   const fields = columns.map(({ name, dataTypeID, title }) => ({
@@ -26,12 +27,12 @@ export default async function getMap({ params = {}, pg = pgClients.client }, rep
   const mapList = getTemplates('map').map(el => el[0]);
 
   const rows = pg.pk?.['gis.maps'] ? await pg.query(
-    `SELECT map_id as id, * FROM gis.maps where ${params.id ? '$1 in (map_id,map_key)' : '1=1'}`,
-    [params.id].filter(Boolean),
+    `SELECT map_id as id, * FROM gis.maps where ${id ? '$1 in (map_id,map_key)' : '1=1'}`,
+    [id].filter(Boolean),
   ).then(el => el.rows || []) : [];
 
-  if (params.id && !mapList?.includes(params.id) && !rows[0]) {
-    return reply.status(404).send({ status: 404, message: 'map not found' });
+  if (id && !mapList?.includes(id) && !rows[0]) {
+    throw NotFoundError('map not found');
   }
 
   const totals = pg.queryCache ? await pg.queryCache('select json_object_agg(oid::regclass, reltuples) from pg_class')
@@ -45,9 +46,9 @@ export default async function getMap({ params = {}, pg = pgClients.client }, rep
     maps.unshift({ id: 'main', slug: 'main', name: 'Основна карта' });
   }
 
-  if (params.id) {
+  if (id) {
     const map = rows[0] || {};
-    const loadTemplate = await getTemplate('map', params.id) || await getTemplate('map', map.map_key);
+    const loadTemplate = await getTemplate('map', id) || await getTemplate('map', map.map_key);
     const obj = loadTemplate || map;
 
     const rawIds = [
@@ -107,12 +108,12 @@ export default async function getMap({ params = {}, pg = pgClients.client }, rep
       layers = layersResults.filter(Boolean);
     }
 
-    return reply.status(200).send({ maps, ...obj, layers });
+    return { maps, ...obj, layers };
   }
 
-  if (params.id && !rows.length) {
-    return reply.status(404).send('map not found');
+  if (id && !rows.length) {
+    throw NotFoundError('map not found');
   }
 
-  return reply.status(200).send(params.id ? { ...rows[0], fields } : { rows, fields });
+  return id ? { ...rows[0], fields } : { rows, fields };
 }

package/server/routes/maps/maps.route.js

@@ -0,0 +1,58 @@
+import getMap from './functions/get.map.js';
+import addMap from './functions/add.map.js';
+import delMap from './functions/del.map.js';
+
+import { schemaInfo } from './maps.schema.js';
+
+const publicParams = {
+    config: { policy: 'L0' },
+    schema: schemaInfo,
+    package: 'gis',
+}; // * L0 === public
+const privilegedParams = {
+    config: { policy: 'L1', role: 'admin' },
+    schema: schemaInfo,
+    package: 'gis',
+}; // ? just auth or admin
+
+export default function (app) {
+    if (!app.hasRoute({ method: 'GET', url: '/gis-map/:id?' })) {
+        app.get('/gis-map/:id?', publicParams, async ({ params, pg }) => {
+            const result = await getMap({
+                id: params.id,
+            }, pg);
+            return result;
+        });
+    }
+    if (!app.hasRoute({ method: 'POST', url: '/gis-map/:id?' })) {
+        app.post('/gis-map/:id?', privilegedParams, async ({ method, body, params, user, pg }) => {
+            const result = await addMap({
+                method,
+                id: params.id,
+                body,
+                uid: user?.uid,
+            }, pg);
+            return result;
+        });
+    }
+    if (!app.hasRoute({ method: 'PUT', url: '/gis-map/:id' })) {
+        app.put('/gis-map/:id', privilegedParams, async ({ method, body, params, user, pg }) => {
+            const result = await addMap({
+                method,
+                id: params.id,
+                body,
+                uid: user?.uid,
+            }, pg);
+            return result;
+        });
+    }
+    if (!app.hasRoute({ method: 'DELETE', url: '/gis-map/:id' })) {
+        app.delete('/gis-map/:id', privilegedParams, async ({ params, user, pg }) => {
+            const result = await delMap({
+                id: params.id,
+                uid: user?.uid,
+            }, pg);
+            return result;
+        });
+    }
+}

package/server/routes/maps/maps.route.test.js

@@ -0,0 +1,231 @@
+/* eslint-disable indent */
+import { randomUUID } from 'node:crypto';
+
+import {
+    describe, test, expect, beforeAll, afterAll,
+} from 'vitest';
+
+import {
+    getPGAsync, dataInsert,
+} from '@opengis/fastify-table/utils.js';
+
+import { build, injectWithHeaders } from '../../../test/helper.js';
+
+const user = { uid: '1', user_type: 'admin' };
+const testKey = 'unittest';
+
+let pg;
+
+const obj = {};
+
+describe('maps api test', () => {
+    beforeAll(async () => {
+        await build();
+        pg = await getPGAsync();
+        // ensure not exists in case previous test fails / timeouts
+        const { rowCount } = await pg.query('delete from gis.maps where array[$1] && keywords', [testKey]);
+        console.log('clean up before: ', rowCount);
+        await pg.query(
+            'insert into gis.maps (map_id, name, keywords, created_by, center) values($1, $1, array[$1], $2, $3) on conflict (map_id) do nothing returning *',
+            [testKey, user.uid, [30, 50]],
+        );
+        console.log('insert before success');
+    });
+
+    afterAll(async () => {
+        const { rowCount: maps } = await pg.query('delete from gis.maps where array[$1] && keywords', [testKey]);
+        console.log('clean up maps after: ', maps);
+        const { rowCount: widgets } = await pg.query('delete from gis.widgets where map_id in ($1,$2)', [testKey, name]);
+        console.log('clean up widgets after: ', widgets);
+    });
+
+    test('GET /gis-map', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: '/api/gis-map',
+            headers: { uid: user.uid, user_type: user.user_type }
+        });
+        expect(res.statusCode).toBe(200);
+        expect(res.headers['content-type']).toBe('application/json; charset=utf-8');
+        const json = res.json();
+        Object.assign(obj, { 'GET/gis-map': json });
+        expect(json).toHaveProperty('rows');
+        expect(json.rows.length).toBeTruthy();
+        expect(json.rows[0]).toHaveProperty('map_id');
+        expect(json.rows[0]).toHaveProperty('name');
+        expect(json.rows[0]).toHaveProperty('map_key');
+        expect(json).toHaveProperty('fields');
+        expect(json.fields[0]).toHaveProperty('name');
+        expect(json.fields[0]).toHaveProperty('type');
+        expect(json.fields[0]).toHaveProperty('label');
+    }, 15000);
+
+    test('GET /gis-map/:id', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: `/api/gis-map/${testKey}`,
+            headers: { uid: user.uid, user_type: user.user_type }
+        });
+        expect(res.statusCode).toBe(200);
+        expect(res.headers['content-type']).toBe('application/json; charset=utf-8');
+        const json = res.json();
+        Object.assign(obj, { 'GET/gis-map/:id': json });
+        expect(json).toHaveProperty('map_id');
+        expect(json.map_id).toBe(testKey);
+        expect(json).toHaveProperty('name');
+        expect(json).toHaveProperty('map_key');
+        expect(json).toHaveProperty('widgets');
+        expect(json).toHaveProperty('layers');
+        expect(json).toHaveProperty('center');
+        expect(Array.isArray(json.center)).toBeTruthy();
+        expect(json.center[0]).toBe(30);
+        expect(json.center[1]).toBe(50);
+        // expect(json.fields[0]).toHaveProperty('name');
+        // expect(json.fields[0]).toHaveProperty('type');
+        // expect(json.fields[0]).toHaveProperty('label');
+    });
+
+    const name = [testKey, randomUUID()].join('-');
+
+    test('POST /gis-map', async () => {
+        const res = await injectWithHeaders({
+            method: 'POST',
+            url: '/api/gis-map',
+            payload: {
+                name,
+                map_key: name,
+                keywords: [testKey],
+                widgets: [{
+                    type: 'legend',
+                    position: 'bottom-right',
+                }],
+                layers: ['dbcb186818e3', '3c95e341465d'],
+            },
+            headers: { uid: user.uid, user_type: user.user_type }
+        });
+        expect(res.statusCode).toBe(200);
+        expect(res.headers['content-type']).toBe('application/json; charset=utf-8');
+        const json = res.json();
+        Object.assign(obj, { 'POST/gis-map': json });
+        expect(json).toHaveProperty('map_id');
+        expect(json).toHaveProperty('widgets');
+        expect(Array.isArray(json.widgets)).toBeTruthy();
+        expect(json.widgets[0]).toHaveProperty('type');
+        expect(json.widgets[0].type).toBe('legend');
+        expect(json).toHaveProperty('layers');
+        expect(Array.isArray(json.layers)).toBeTruthy();
+        expect(json.layers[0]).toBe('dbcb186818e3');
+    });
+
+    test('GET /gis-widget/:map/:id', async () => {
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: `/api/gis-widget/${testKey}`,
+            headers: { uid: user.uid, user_type: user.user_type }
+        });
+        expect(res.statusCode).toBe(200);
+        expect(res.headers['content-type']).toBe('application/json; charset=utf-8');
+        const json = res.json();
+        Object.assign(obj, { 'GET/gis-widget/:map': json });
+        expect(json).toHaveProperty('rows');
+        expect(json).toHaveProperty('fields');
+    });
+
+    test('GET /gis-widget/:map/:id', async () => {
+        await dataInsert({
+            table: 'gis.widgets',
+            id: name,
+            data: {
+                widget_id: name,
+                map_id: testKey,
+                type: 'card',
+                title: name,
+                config: {
+                    items: [{
+                        label: 'Карта тимчасових споруд',
+                        url: '/map/ts',
+                    }],
+                },
+                position: 'top-right',
+            },
+            uid: '1',
+        });
+        const res = await injectWithHeaders({
+            method: 'GET',
+            url: `/api/gis-widget/${testKey}/${name}`,
+            headers: { uid: user.uid, user_type: user.user_type }
+        });
+        expect(res.statusCode).toBe(200);
+        expect(res.headers['content-type']).toBe('application/json; charset=utf-8');
+        const json = res.json();
+        Object.assign(obj, { 'GET/gis-widget/:map/:id': json });
+        expect(json).toHaveProperty('widget_id');
+        expect(json).toHaveProperty('type');
+        expect(json).toHaveProperty('title');
+        expect(json).toHaveProperty('config');
+        expect(json).toHaveProperty('position');
+    });
+
+    test('PUT /gis-widget/:map/:id', async () => {
+        const res = await injectWithHeaders({
+            method: 'PUT',
+            url: `/api/gis-widget/${testKey}/${name}`,
+            payload: {
+                type: 'card1',
+            },
+            headers: { uid: user.uid, user_type: user.user_type }
+        });
+        expect(res.statusCode).toBe(200);
+        expect(res.headers['content-type']).toBe('application/json; charset=utf-8');
+        const json = res.json();
+        Object.assign(obj, { 'PUT/gis-widget/:map/:id': json });
+        expect(json).toHaveProperty('map_id');
+        expect(json.map_id).toBe(testKey);
+    });
+
+    test('DELETE /gis-widget/:map/:id', async () => {
+        const res = await injectWithHeaders({
+            method: 'DELETE',
+            url: `/api/gis-widget/${testKey}/${name}`,
+            headers: { uid: user.uid, user_type: user.user_type }
+        });
+        expect(res.statusCode).toBe(200);
+        expect(res.headers['content-type']).toBe('application/json; charset=utf-8');
+        const json = res.json();
+        Object.assign(obj, { 'DELETE/gis-widget/:map/:id': json });
+        expect(json).toHaveProperty('map_id');
+        expect(json.map_id).toBe(testKey);
+    });
+
+    test('PUT /gis-map/:id', async () => {
+        const res = await injectWithHeaders({
+            method: 'PUT',
+            url: `/api/gis-map/${testKey}`,
+            payload: {
+                keywords: [testKey],
+                description: testKey,
+            },
+            headers: { uid: user.uid, user_type: user.user_type }
+        });
+        expect(res.statusCode).toBe(200);
+        expect(res.headers['content-type']).toBe('application/json; charset=utf-8');
+        const json = res.json();
+        Object.assign(obj, { 'PUT/gis-map/:id': json });
+        expect(json).toHaveProperty('map_id');
+        expect(json.map_id).toBe(testKey);
+    });
+
+    test('DELETE /gis-map/:id', async () => {
+        const res = await injectWithHeaders({
+            method: 'DELETE',
+            url: `/api/gis-map/${testKey}`,
+            headers: { uid: user.uid, user_type: user.user_type }
+        });
+        expect(res.statusCode).toBe(200);
+        expect(res.headers['content-type']).toBe('application/json; charset=utf-8');
+        const json = res.json();
+        Object.assign(obj, { 'DELETE/gis-map/:id': json });
+        expect(json).toHaveProperty('map_id');
+        expect(json.map_id).toBe(testKey);
+    });
+});

package/server/routes/maps/maps.schema.js

@@ -0,0 +1,10 @@
+export const schemaInfo = {
+    params: {
+        type: 'object',
+        properties: {
+            id: { type: "string", pattern: '^([\\d\\w]+)$' },
+        },
+    },
+};
+
+export default null;

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

@@ -0,0 +1,35 @@
+import { BadRequestError, NotFoundError } from "@opengis/fastify-table/errors.js";
+import { pgClients, dataUpsert } from "@opengis/fastify-table/utils.js";
+
+export default async function editMetadata({ id, type, body, uid }, pg = pgClients.client) {
+  if (!type) {
+    throw BadRequestError('not enough params: type');
+  }
+
+  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) {
+    throw BadRequestError('invalid params: type');
+  }
+
+  const exists = await pg.query(q, [id]).then(r => r.rowCount || 0);
+
+  if (!exists) {
+    throw NotFoundError(`${type} not found: ${id}`);
+  }
+
+  const data = await dataUpsert({
+    pg,
+    id: id,
+    table: 'gis.metadata',
+    data: { ...body, type: type, layer_id: id },
+    uid,
+  });
+
+  return data;
+}

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

@@ -0,0 +1,19 @@
+import { handlebars, getTemplate } from "@opengis/fastify-table/utils.js";
+import { BadRequestError } from "@opengis/fastify-table/errors.js";
+
+// currently unused
+export default async function metadataXml({ id }) {
+  if (!id) {
+    throw BadRequestError('not enough params: id');
+  }
+
+  const pt = await getTemplate('templates', 'ISO19136_2017_gml_template');
+  const data = await handlebars.compile(pt)({ id });
+
+  return {
+    headers: {
+      'Content-Type': 'text/xml; charset=utf-8',
+    },
+    data
+  };
+}

package/server/routes/metadata/metadata.route.js

@@ -0,0 +1,26 @@
+// import metadataXML from './functions/metadataXML.js';
+import editMetadata from './functions/editMetadata.js';
+
+import {
+    editMetadataSchema,
+} from './metadata.schema.js';
+
+const privateParams = { config: { policy: 'L1', package: 'gis' } };
+// const publicParams = { config: { policy: 'L0', package: 'gis' } };
+
+async function route(app) {
+    /*app.get('/xml/:id', { ...publicParams, schema: metadataXMLSchema }, async ({ params }, reply) => {
+        const result = await metadataXML({ id: params.id });
+        return reply.headers(result.headers).send(result.data);
+    });*/
+    app.post('/gis-metadata/:type/:id', { ...privateParams, schema: editMetadataSchema }, async ({ params, body, user, pg }) => {
+        const result = await editMetadata({
+            id: params.id,
+            type: params.type,
+            body,
+            uid: user?.uid,
+        }, pg);
+        return result;
+    });
+}
+export default route;

package/server/routes/metadata/metadata.route.test.js

@@ -0,0 +1,47 @@
+import { afterAll, beforeAll, describe, expect, test } from 'vitest';
+
+import { getPGAsync } from '@opengis/fastify-table/utils.js';
+
+import { build, injectWithHeaders } from '../../../test/helper.js';
+
+let pg;
+
+beforeAll(async () => {
+    await build();
+
+    pg = await getPGAsync();
+
+    await cleanUp('before');
+});
+
+afterAll(async () => {
+    await cleanUp('after');
+});
+
+const testId = 'testCss';
+const user = { id: '2', type: 'admin' };
+
+const cleanUp = async (when) => {
+    if (!pg) return;
+    const rowCount = await pg.query('delete from gis.cartocss where cartocss_id=$1', [testId]).then(r => r.rowCount || 0);
+    const rowCount3 = await pg.query('delete from gis.metadata where metadata_id=$1', [testId]).then(r => r.rowCount || 0);
+    console.log(`clean up finished: ${when}`, rowCount, rowCount3);
+};
+
+describe('GIS routes', () => {
+    test('POST /gis-metadata/:type/:id returns 200', async () => {
+        await pg.query('insert into gis.cartocss(cartocss_id,name) values($1,$2)', [testId, 'unit-test']).catch(err => console.error(err));
+        const res = await injectWithHeaders({
+            method: 'POST',
+            url: `/api/gis-metadata/css/${testId}`,
+            payload: {
+                layer_id: testId
+            },
+            headers: { uid: user.id, user_type: user.type }
+        });
+
+        expect(res.statusCode).toBe(200);
+        expect(res.body).toHaveProperty('metadata_id');
+        expect(res.body.metadata_id).toBe(testId);
+    });
+});