@opengis/gis 0.2.167 → 0.2.169

package/server/routes/map/map.route.js

@@ -0,0 +1,280 @@
+import map from './functions/map.js';
+import mapTiles from './functions/mapTiles.js';
+import mapFeatures from './functions/mapFeatures.js';
+
+import mapCatalog from './functions/mapCatalog.js';
+import mapCatalogAttribute from './functions/mapCatalogAttribute.js';
+
+// import vtile from './functions/vtile.js';
+import vtile1 from './functions/vtile1.js';
+import clearTiles from './functions/clearTiles.js';
+import geojson from './functions/geojson.js';
+import jsonData from './functions/jsonData.js';
+import layerList from './functions/layerList.js';
+
+import mapFormat from './functions/mapFormat.js';
+import parseGeoFile from './functions/parseGeoFile.js';
+import maps from './functions/maps.js';
+import gisIconApi from './functions/gis.icon.js';
+// import markerIconApi from './controllers/marker_icon.js';
+
+import gisConvert from './functions/gis.convert.js';
+import pointHeight from './functions/pointHeight.js';
+
+import {
+    gisConvertSchema,
+    mapFormatSchema,
+    pointHeightSchema,
+    getIconSchema,
+    mapSchema,
+    mapTilesSchema,
+    mapFeaturesSchema,
+    mapFeaturesPointSchema,
+    mapCatalogAttributeSchema,
+
+    vtileSchema,
+    clearTilesSchema,
+    geojsonSchema,
+    jsonDataSchema,
+    layerListSchema,
+    parseGeoFileSchema,
+} from './map.schema.js';
+
+const publicParams = {
+    config: { policy: 'L0' },
+    package: 'gis',
+}; // * L0 === public
+
+const privateParams = {
+    config: { policy: 'L1' },
+    package: 'gis',
+}; // require authorized user
+
+export default function route(app) {
+    if (!app.hasRoute({ method: 'GET', url: '/maps' })) {
+        app.get('/maps', publicParams, maps);
+    }
+
+    if (!app.hasRoute({ method: 'GET', url: '/map/:slug' })) {
+        app.get('/map/:slug', { ...publicParams, schema: mapSchema }, async ({ params, pg }) => {
+            const result = await map({ slug: params.slug }, pg);
+            return result;
+        });
+    }
+
+    if (!app.hasRoute({ method: 'GET', url: '/map-tiles/:slug/:z/:y/:x' })) {
+        app.get('/map-tiles/:slug/:z/:y/:x', { ...publicParams, schema: mapTilesSchema }, async ({ params, query, pg }, reply) => {
+            const result = await mapTiles({
+                slug: params.slug,
+                z: params.z,
+                x: params.x?.split?.('.')?.[0] - 0,
+                y: params.y,
+                sql: query.sql,
+                nocache: query.nocache,
+                filter: query.filter,
+                pointZoom: query.pointZoom,
+                type: query.type,
+                layers: query.layers,
+                layer: query.layer,
+            }, pg);
+            return reply.headers(result.headers).send(result.data);
+        });
+    }
+
+    if (!app.hasRoute({ method: 'GET', url: '/map-features/:slug/:id' })) {
+        app.get('/map-features/:slug/:id', { ...publicParams, schema: mapFeaturesSchema }, async ({ params, query, pg }) => {
+            const result = await mapFeatures({
+                slug: params.slug, id: params.id, x: query.x, y: query.y, sql: query.sql
+            }, pg);
+            return result;
+        });
+    }
+
+    if (!app.hasRoute({ method: 'GET', url: '/map-features-point/:slug' })) {
+        app.get('/map-features-point/:slug', { ...publicParams, schema: mapFeaturesPointSchema }, async ({ params, query, pg }) => {
+            const result = await mapFeatures({
+                slug: params.slug, id: params.id, x: query.x, y: query.y, sql: query.sql
+            }, pg);
+            return result;
+        });
+    }
+
+    if (!app.hasRoute({ method: 'GET', url: '/map-catalog' })) {
+        app.get('/map-catalog', publicParams, async () => {
+            const result = await mapCatalog();
+            return result;
+        });
+    }
+
+    if (!app.hasRoute({ method: 'GET', url: '/map-catalog/:service/:attr' })) {
+        app.get('/map-catalog/:service/:attr', { ...publicParams, schema: mapCatalogAttributeSchema }, async ({ params, query, pg }) => {
+            const result = await mapCatalogAttribute({
+                service: params.service,
+                attr: params.attr,
+                cls: query.cls
+            }, pg);
+            return result;
+        });
+    }
+
+    /*if (!app.hasRoute({ method: 'GET', url: '/layer-rtile/:id/:z/:y/:x' })) {
+      app.get('/layer-rtile/:id/:z/:y/:x', publicParams, rtile);
+    }*/
+
+    /*if (!app.hasRoute({ method: 'GET', url: '/layer-vtile/:id/:z/:y/:x' })) {
+        app.get('/layer-vtile/:id/:z/:y/:x', publicParams, vtile);
+    }*/
+
+    if (
+        !app.hasRoute({ method: 'GET', url: '/api/vtile/:layer/:lang/:z/:y/:x' })
+    ) {
+        console.log('\x1b[34m%s\x1b[0m', 'add vtile from gis');
+        app.get('/vtile/:layer/:lang/:z/:y/:x', { ...publicParams, schema: vtileSchema }, async ({ params, query, user, pg }, reply) => {
+            const x = params.x.split('.')[0] - 0;
+            const result = await vtile1({
+                layer: params.layer,
+                lang: params.lang,
+                z: params.z,
+                x,
+                y: params.y,
+
+                uid: user?.uid,
+
+                type: query.type,
+                nocache: query.nocache,
+                clusterZoom: query.clusterZoom,
+                filter: query.filter,
+                nottl: query.nottl,
+                all: query.all,
+                sql: query.sql,
+                pointZoom: query.pointZoom,
+            }, pg);
+            return reply.headers(result.headers).send(result.data);
+        });
+    }
+
+    if (!app.hasRoute({ method: 'GET', url: '/api/gis-clear-vtile/:id' })) {
+        app.get('/gis-clear-vtile/:id', { ...privateParams, schema: clearTilesSchema }, async ({ params, query, user }) => {
+            const result = await clearTiles({
+                id: params.id,
+                debug: query.debug && user?.user_type?.includes?.('admin')
+            });
+            return result;
+        });
+    }
+
+    if (!app.hasRoute({ method: 'GET', url: '/api/geojson/:layer' })) {
+        console.log('\x1b[34m%s\x1b[0m', 'add geojson from gis');
+        app.get('/geojson/:layer', { ...publicParams, schema: geojsonSchema }, async ({ params, query, pg }, reply) => {
+            const result = await geojson({
+                layer: params.layer,
+                sql: query.sql,
+                nocache: query.nocache,
+                srid: query.srid,
+                type: query.type,
+                extent: query.extent,
+            }, pg);
+            if (query.sql && typeof result === 'string') {
+                return result;
+            }
+            return reply.headers(result.headers).send(result.data);
+        });
+    }
+
+    if (!app.hasRoute({ method: 'GET', url: '/api/json/:layer' })) {
+        console.log('\x1b[34m%s\x1b[0m', 'add json from gis');
+        app.get('/json/:layer', { ...publicParams, schema: jsonDataSchema }, async ({ params, query, pg }, reply) => {
+            const result = await jsonData({
+                layer: params.layer,
+                sql: query.sql,
+                nocache: query.nocache,
+                page: query.page,
+                limit: query.limit,
+                // where: query.where,
+            }, pg);
+            if (query.sql && typeof result === 'string') {
+                return result;
+            }
+            return reply.headers(result.headers).send(result.data);
+        });
+    }
+
+    if (!app.hasRoute({ method: 'GET', url: '/api/gis-layer-list' })) {
+        console.log('\x1b[34m%s\x1b[0m', 'add gis-layer-list from gis');
+        app.get('/gis-layer-list', { ...publicParams, schema: layerListSchema }, async ({ user, query, pg }) => {
+            const result = await layerList({ uid: user?.uid, sql: query.sql }, pg);
+            return result;
+        });
+    }
+
+    if (!app.hasRoute({ method: 'GET', url: '/gis-icon/*' })) {
+        app.get('/gis-icon/*', { ...publicParams, schema: getIconSchema }, async (req, reply) => {
+            const result = await gisIconApi({ name: req.params['*'], nocache: !!req.query.nocache });
+            return reply.headers(result.headers).send(result.data);
+        });
+    }
+
+    if (!app.hasRoute({ method: 'GET', url: '/icon/*' })) {
+        app.get('/icon/*', { ...publicParams, schema: getIconSchema }, async (req, reply) => {
+            const result = await gisIconApi({ name: req.params['*'], nocache: !!req.query.nocache });
+            return reply.headers(result.headers).send(result.data);
+        });
+    }
+
+    if (!app.hasRoute({ method: 'GET', url: '/marker-icon/*' })) {
+        app.get('/marker-icon/*', { ...publicParams, schema: getIconSchema }, async (req, reply) => {
+            const result = await gisIconApi({ name: req.params['*'], nocache: !!req.query.nocache });
+            return reply.headers(result.headers).send(result.data);
+        });
+    }
+
+    if (!app.hasRoute({ method: 'GET', url: '/api/map-format' })) {
+        app.get(
+            '/map-format',
+            { ...publicParams, schema: mapFormatSchema },
+            async ({ query, user, pg }) => {
+                const result = await mapFormat({
+                    layer: query.layer,
+                    id: query.id,
+                    lat: query.lat,
+                    lng: query.lng,
+                    nogeom: query.nogeom,
+                    radius: query.radius,
+                    uid: user?.uid
+                }, pg);
+                return result;
+            }
+        );
+    }
+
+    if (!app.hasRoute({ method: 'GET', url: '/api/coords/height' })) {
+        app.get(
+            '/coords/height',
+            { ...publicParams, schema: pointHeightSchema },
+            async ({ query }) => {
+                const result = await pointHeight({ lat: query.lat, lng: query.lng });
+                return result;
+            }
+        );
+    }
+
+    if (!app.hasRoute({ method: 'POST', url: '/api/gis-parse-geo' })) {
+        app.post('/gis-parse-geo', { ...publicParams, schema: parseGeoFileSchema }, async ({ body }) => {
+            const result = await parseGeoFile({ content: body.content, filename: body.filename });
+            return result;
+        });
+    }
+
+    if (!app.hasRoute({ method: 'POST', url: '/api/gis-convert' })) {
+        app.post(
+            '/gis-convert',
+            { ...publicParams, schema: gisConvertSchema },
+            async ({ body }) => {
+                const result = await gisConvert({
+                    file: body.file, filename: body.filename, filepath: body.filepath, encoding: body.encoding
+                });
+                return result;
+            },
+        );
+    }
+}