@opengis/gis 0.2.167 → 0.2.169

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

@@ -0,0 +1,278 @@
+const querySearchSchema = { type: 'string', pattern: '^([А-Яа-яҐґЄєІіЇї\\d\\w\\s\\/\\[\\]\\(\\)\\{\\}\\|,.!?;:—_=-@%#$&^*+=`~]+)$' };
+
+const serviceBodySchema = {
+    type: 'object',
+    additionalProperties: false,
+    properties: {
+        service_id: { type: 'string', pattern: '^([\\d\\w]+)$' },
+        service_key: { type: 'string' },
+        name: { type: 'string' },
+        description: { type: ['string', 'null'] },
+        keywords: { type: ['array', 'null'], items: { type: 'string' } },
+        category: { type: ['string', 'null'] },
+        holder: { type: ['string', 'null'] },
+        group_id: { type: ['string', 'null'] },
+        group_name: { type: ['string', 'null'] },
+        service_type: {
+            type: 'string', enum: [
+                "geojson",
+                "vtile",
+                "wms",
+                "wfs",
+                "wmts",
+                "tms",
+                "raster",
+                "other"
+            ]
+        },
+        card_mode: { type: 'string' },
+        source_type: { type: 'string' },
+        service_url: { type: ['string', 'null'] },
+        source_path: { type: 'string' },
+        query: { type: ['string', 'null'] },
+        geom_type: { type: ['string', 'null'] },
+        geometry_column: { type: ['string', 'null'] },
+        sql_list: { type: ['array', 'string', 'null'] },
+
+        attributes: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    ua: { type: 'string' },
+                    data: { type: ['string', 'null'] },
+                    name: { type: 'string' },
+                    type: { type: 'string' },
+                    label: { type: 'string' },
+                    title: { type: 'string' },
+                    format: { type: 'string' },
+                    hidden: { type: 'boolean' },
+                    options: { type: 'array' },
+                    visible: { type: 'boolean' },
+                    disabled: { type: 'boolean' },
+                    required: { type: 'boolean' },
+                    is_required: { type: 'boolean' },
+                    data_key_date: { type: ['string', 'null'] },
+                    hidden_table_public: { type: 'boolean' },
+                },
+            },
+        },
+
+        filters: {
+            type: ['array', 'null'],
+        },
+
+        popup: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    data: { type: 'string' },
+                    meta: { type: 'string' },
+                    name: { type: 'string' },
+                    color: { type: 'string' },
+                    label: { type: 'string' },
+                    format: { type: 'string' },
+                },
+            },
+        },
+
+        style: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string' },
+                color: { type: 'string' },
+                width: { type: 'number' },
+                icon: { type: 'string' },
+            },
+        },
+
+        legend: {
+            type: ['object', 'null', 'array'],
+        },
+
+        card: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    name: { type: 'string' },
+                    label: { type: 'string' },
+                    meta: { type: 'string' },
+                    color: { type: 'string' },
+                    format: { type: 'string' },
+                    data: { type: 'string' },
+                },
+            },
+        },
+
+        srid: { type: 'number', minimum: 1 },
+
+        extent: {
+            type: 'array',
+            items: { type: 'string' },
+        },
+
+        bbox: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string' },
+                coordinates: {
+                    type: 'array',
+                    items: {
+                        type: 'array',
+                        items: {
+                            type: 'array',
+                            items: { type: 'number' },
+                        },
+                    },
+                },
+            },
+        },
+
+        center: {
+            type: 'array',
+            items: { type: 'number' },
+        },
+
+        enabled: { type: 'boolean' },
+        is_public: { type: 'boolean' },
+        is_active: { type: 'boolean' },
+        is_downloadable: { type: 'boolean' },
+
+        metadata: {
+            type: 'object',
+            additionalProperties: false,
+            properties: {
+                type: { type: 'string' },
+            },
+        },
+
+        metadata_url: { type: ['string', 'null'] },
+        thumbnail_url: { type: ['string', 'null'] },
+        created_by: { type: 'string' },
+        updated_by: { type: 'string' },
+        updated_at: { type: 'string' },
+        created_at: { type: 'string' },
+
+        template: {
+            type: ['object', 'null'],
+        },
+
+        count: { type: 'number', minimum: 0 },
+
+        fields: {
+            type: 'array',
+            items: {
+                type: 'object',
+                additionalProperties: false,
+                properties: {
+                    name: { type: 'string' },
+                    type: { type: 'string' },
+                    label: { type: 'string' },
+                },
+            },
+        },
+    },
+};
+
+export const metadataXMLSchema = {};
+export const getLayerGeomSchema = {};
+
+export const getServicesSchema = {
+    params: {
+        type: 'object',
+        properties: {
+            id: { type: 'string', pattern: '^([\\d\\w]+)$' },
+        },
+    },
+};
+
+export const getServicesColSchema = {
+    params: {
+        type: 'object',
+        required: ['id', 'col'],
+        properties: {
+            id: { type: 'string', pattern: '^([\\d\\w]+)$' },
+            col: { type: 'string', pattern: '^([\\d\\w_]+)$' },
+        },
+    },
+};
+export const addServiceSchema = {
+    params: {
+        type: 'object',
+        properties: {
+            id: { type: 'string', pattern: '^([\\d\\w]+)$' },
+        },
+    },
+    body: { ...serviceBodySchema, required: ['name', 'service_type'] }
+};
+export const editServiceSchema = {
+    params: {
+        type: 'object',
+        required: ['id'],
+        properties: {
+            id: { type: 'string', pattern: '^([\\d\\w]+)$' },
+        },
+    },
+    body: serviceBodySchema
+};
+export const deleteServiceSchema = {
+    params: {
+        type: 'object',
+        required: ['id'],
+        properties: {
+            id: { type: 'string', pattern: '^([\\d\\w]+)$' },
+        },
+    },
+};
+export const legendAutoSchema = {};
+export const getServiceUsersSchema = {
+    params: {
+        type: 'object',
+        properties: {
+            id: { type: 'string', pattern: '^([\\d\\w]+)$' },
+        },
+    },
+    querystring: {
+        type: 'object',
+        properties: {
+            search: querySearchSchema,
+            limit: {
+                type: 'number',
+                minimum: 1,
+            },
+            offset: {
+                type: 'number',
+                minimum: 0,
+                default: 0
+            },
+        },
+    },
+};
+export const createRouteSchema = {
+    querystring: {
+        type: 'object',
+        properties: {
+            from: { type: 'string', pattern: '^([\\d,.]+)$' },
+            to: { type: 'string', pattern: '^([\\d,.]+)$' },
+            via: { type: 'string', pattern: '^([\\d,.;]+)$' },
+            mode: {
+                type: 'string', pattern: '^([\\w]+)$'
+            }, // ! not found at OSRM routing api or geodata api - looks like native /{profile}/
+            alternatives: { type: 'string', enum: ['true', '1'] },
+            steps: { type: 'string', enum: ['true', '1'] },
+            optimize: { type: 'string', enum: ['true', '1'] }, // ! not found at OSRM routing api or geodata api
+            surface: { type: 'string', pattern: '^([\\w]+)$' }, // ! not found at geodata api request params
+            weight: {
+                type: 'string', pattern: '^([\\w]+)$'
+            }, // ! not found at OSRM routing api or geodata api request params
+        },
+    },
+};
+export default null;

package/server/routes/widgets/functions/add.widget.js

@@ -0,0 +1,39 @@
+import { BadRequestError, UnauthorizedError } from "@opengis/fastify-table/errors.js";
+import { dataInsert, dataUpdate, pgClients } from "@opengis/fastify-table/utils.js";
+
+export default async function addWidget({
+    method, id, map, body, uid,
+}, pg = pgClients.client) {
+    if (!uid) {
+        throw UnauthorizedError('unauthorized');
+    }
+
+    if (!map) {
+        throw BadRequestError('not enough params: map id');
+    }
+
+    if (method === 'PUT' && !id) {
+        throw BadRequestError('not enough params: id');
+    }
+
+    if (method === 'POST') {
+        Object.assign(body, { map_id: map });
+        const row = await dataInsert({
+            pg,
+            id,
+            table: 'gis.widgets',
+            data: body,
+            uid,
+        }).then(r => r.rows[0]);
+        return row;
+    }
+
+    const row = await dataUpdate({
+        pg,
+        id,
+        table: 'gis.widgets',
+        data: body,
+        uid,
+    });
+    return row;
+}

package/server/routes/widgets/functions/del.widget.js

@@ -0,0 +1,18 @@
+import { UnauthorizedError } from "@opengis/fastify-table/errors.js";
+import { dataDelete, pgClients } from "@opengis/fastify-table/utils.js";
+
+export default async function delWidget({
+    id, uid,
+}, pg = pgClients.client) {
+    if (!uid) {
+        throw UnauthorizedError('unauthorized');
+    }
+
+    const row = await dataDelete({
+        pg,
+        id,
+        table: 'gis.widgets',
+        uid,
+    });
+    return row;
+}

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

@@ -1,3 +1,4 @@
+import { BadRequestError, NotFoundError } from "@opengis/fastify-table/errors.js";
 import { getMeta, pgClients } from "@opengis/fastify-table/utils.js";
 
 const table = 'gis.widgets';
@@ -12,9 +13,9 @@ const columnType = {
     'timestamp with time zone': 'date',
 };
 
-export default async function getWidget({ params = {}, pg = pgClients.client }, reply) {
-    if (!params.map) {
-        return reply.status(400).send('not enough params: map id');
+export default async function getWidget({ map, id }, pg = pgClients.client) {
+    if (!map) {
+        throw BadRequestError('not enough params: map id');
     }
 
     const { columns = [] } = await getMeta({ pg, table }) || {};
@@ -22,20 +23,20 @@ export default async function getWidget({ params = {}, pg = pgClients.client },
     const fields = columns.map(({ name, dataTypeID, title }) => ({ name, type: columnType[pg.pgType?.[dataTypeID] || 'text'], label: title || name }));
 
     const rows = pg.pk?.['gis.maps'] && pg.pk?.['gis.widgets'] ? await pg.query(
-        `SELECT widget_id as id, * FROM gis.widgets where map_id=$1 and ${params.id ? 'widget_id=$2' : '1=1'}`,
-        [params.map, params.id].filter(Boolean),
+        `SELECT widget_id as id, * FROM gis.widgets where map_id=$1 and ${id ? 'widget_id=$2' : '1=1'}`,
+        [map, id].filter(Boolean),
     ).then(el => el.rows || []) : [];
 
-    if (params.id && !rows.length) {
-        return reply.status(404).send('widget not found');
+    if (id && !rows.length) {
+        throw NotFoundError('widget not found');
     }
 
-    if (params.id) {
-        return reply.status(200).send({ ...rows[0], fields });
+    if (id) {
+        return { ...rows[0], fields };
     }
 
-    return reply.status(200).send({
+    return {
         rows,
         fields,
-    });
+    };
 }

package/server/routes/widgets/widgets.route.js

@@ -0,0 +1,61 @@
+import getWidget from './functions/get.widget.js';
+import addWidget from './functions/add.widget.js';
+import delWidget from './functions/del.widget.js';
+
+import { schemaInfo } from './widgets.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-widget/:map/:id?' })) {
+        app.get('/gis-widget/:map/:id?', publicParams, async ({ params, pg }) => {
+            const result = await getWidget({
+                id: params.id,
+                map: params.map
+            }, pg);
+            return result;
+        });
+    }
+    if (!app.hasRoute({ method: 'POST', url: '/gis-widget/:map/:id?' })) {
+        app.post('/gis-widget/:map/:id?', privilegedParams, async ({ method, body, params, user, pg }) => {
+            const result = await addWidget({
+                method,
+                id: params.id,
+                map: params.map,
+                body,
+                uid: user?.uid
+            }, pg);
+            return result;
+        });
+    }
+    if (!app.hasRoute({ method: 'PUT', url: '/gis-widget/:map/:id' })) {
+        app.put('/gis-widget/:map/:id', privilegedParams, async ({ method, body, params, user, pg }) => {
+            const result = await addWidget({
+                method,
+                id: params.id,
+                map: params.map,
+                body,
+                uid: user?.uid
+            }, pg);
+            return result;
+        });
+    }
+    if (!app.hasRoute({ method: 'DELETE', url: '/gis-widget/:map/:id' })) {
+        app.delete('/gis-widget/:map/:id', privilegedParams, async ({ params, user, pg }) => {
+            const result = await delWidget({
+                id: params.id,
+                uid: user?.uid
+            }, pg);
+            return result;
+        });
+    }
+}

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

@@ -0,0 +1,144 @@
+/* eslint-disable indent */
+import { randomUUID } from 'node:crypto';
+
+import {
+    describe, test, expect, beforeAll, afterAll,
+} from 'vitest';
+
+import {
+    getPGAsync,
+} 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 = {};
+
+const cleanUp = async (when) => {
+    if (!pg) return;
+    const { rowCount: widgets } = await pg.query('delete from gis.widgets where (map_id like $1 or widget_id like $1)', [`${testKey}%`]);
+    console.log(`clean up widgets ${when}:`, widgets);
+    const { rowCount: maps } = await pg.query('delete from gis.maps where array[$1] && keywords', [testKey]);
+    console.log(`clean up maps ${when}:`, maps);
+}
+
+describe('maps api test', () => {
+    beforeAll(async () => {
+        await build();
+        pg = await getPGAsync();
+        // ensure not exists in case previous test fails / timeouts
+        await cleanUp('before');
+
+        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 () => {
+        await cleanUp('after');
+    });
+
+    const name = [testKey, randomUUID()].join('-');
+
+    test('POST /gis-widget/:map/:id?', async () => {
+        const res = await injectWithHeaders({
+            method: 'POST',
+            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();
+        expect(json).toHaveProperty('map_id');
+        expect(json.map_id).toBe(testKey);
+    });
+
+    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);
+    });
+});

package/server/routes/widgets/widgets.schema.js

@@ -0,0 +1,25 @@
+export const schemaInfo = {
+    params: {
+        type: 'object',
+        properties: {
+            slug: {
+                type: 'string',
+            },
+            z: {
+                type: 'number',
+            },
+            y: {
+                type: 'number',
+            },
+            x: {
+                type: 'string',
+                pattern: '^\\d+\\.(pbf|vmt)$',
+            },
+            id: {
+                type: 'string',
+            },
+        },
+    },
+};
+
+export default null;