@opengis/gis 0.2.168 → 0.2.170

package/server/routes/cartocss/cartocss.schema.js

@@ -0,0 +1,73 @@
+const geometrySchema = {
+
+    type: "object",
+    required: ["type", "coordinates"],
+    properties: {
+        type: {
+            enum: [
+                "Point",
+                "LineString",
+                "Polygon",
+                "MultiPoint",
+                "MultiLineString",
+                "MultiPolygon",
+            ],
+        },
+        coordinates: {
+            type: "array",
+        },
+    },
+
+};
+
+const cssBodySchema = {
+    type: "object",
+    additionalProperties: true,
+
+    properties: {
+        id: { type: "string", pattern: '^([\\d\\w]+)$' },
+        name: { type: "string" },
+        group_id: { type: "string" },
+        cartocss_key: { type: "string" },
+        source_path: { type: "string" },
+        description: { type: ["string", "null"] },
+        card_table: { type: "string" },
+        card_columns: { type: "string" },
+        card_html: { type: "string" },
+        is_public: { type: "boolean" },
+        is_static: { type: "boolean" },
+        enabled: { type: "boolean" },
+        geom: geometrySchema,
+    },
+};
+
+export const getCartocssSchema = {
+    params: {
+        type: 'object',
+        required: ['id'],
+        properties: {
+            id: { type: 'string', pattern: '^([\\d\\w]+)$' }
+        }
+    },
+    querystring: {
+        type: 'object',
+        additionalProperties: false,
+        properties: {
+            nocache: { type: 'number', enum: [1] },
+            sql: { type: 'number', enum: [1] },
+        }
+    }
+};
+
+export const addCartocssSchema = {
+    params: {
+        type: 'object',
+        required: ['id'],
+        properties: {
+            id: { type: 'string', pattern: '^([\\d\\w]+)$' }
+        }
+    },
+    body: cssBodySchema,
+};
+
+export default null;

package/server/routes/{gis/cartocss → cartocss/functions}/add.cartocss.js

@@ -1,16 +1,13 @@
 import { pgClients, dataUpdate } from '@opengis/fastify-table/utils.js';
 
 import uploadXML from '../../mapnik/functions/uploadXML.js';
+import { NotFoundError } from '@opengis/fastify-table/errors.js';
 
-export default async function addCartocss(req, reply) {
-  const {
-    pg = pgClients.client, body, params, user,
-  } = req;
-
-  const cartocss = await pg.query('select cartocss_id, source_path, config, style from gis.cartocss where cartocss_id=$1', [params.id]).then(el => el.rows?.[0]);
+export default async function addCartocss({ id, body, uid }, pg = pgClients.client) {
+  const cartocss = await pg.query('select cartocss_id, source_path, config, style from gis.cartocss where cartocss_id=$1', [id]).then(el => el.rows?.[0]);
 
   if (!cartocss) {
-    return reply.status(404).send({ error: 'cartocss not found', code: 404 });
+    throw NotFoundError('cartocss not found');
   }
 
   const sourcePath = body.source_path || cartocss.source_path;
@@ -22,21 +19,21 @@ export default async function addCartocss(req, reply) {
 
   await dataUpdate({
     pg,
-    id: params.id,
+    id,
     table: 'gis.cartocss',
     data,
-    uid: user?.uid,
+    uid,
   });
 
   // if not from static xml file
   if (!data.source_path) {
     await uploadXML({
-      id: params.id,
+      id,
       dataset: config,
       style,
       source_path: sourcePath,
     }, pg);
   }
 
-  return reply.status(200).send({ message: 'cartocss updated', code: 200 });
+  return { message: 'cartocss updated', code: 200 };
 }

package/server/routes/{gis/cartocss → cartocss/functions}/get.cartocss.js

@@ -2,6 +2,7 @@ import { config, pgClients } from '@opengis/fastify-table/utils.js';
 
 import mapnik from '../../../plugins/mapnik/funcs/mapnik.js';
 import cartoBounds from '../../mapnik/functions/cartoBounds.js';
+import { NotFoundError, NotImplementedError } from '@opengis/fastify-table/errors.js';
 
 const { RenderTile } = mapnik();
 
@@ -10,39 +11,36 @@ const { prefix = '/api' } = config;
 const exclude = ['created_at', 'updated_at', 'created_by', 'updated_by'];
 
 export default async function checkCarto({
-    pg = pgClients.client, params, query, user,
-}, reply) {
+    id, sql, nocache, isAdmin,
+}, pg = pgClients.client) {
     const time = Date.now();
     if (!config.mapnik?.server) {
-        return reply.status(400).send({ error: 'mapnik server address needed', code: 400 });
+        throw NotImplementedError('mapnik server address needed');
     }
 
-    const { sql } = query || {};
-
     // extract all columns, migrations-agnostic
-    const cartocss = await pg.query('select *, ARRAY[ST_XMin(geom), ST_YMin(geom),  ST_XMax(geom),  ST_YMax(geom)] as bounds, st_asgeojson(geom)::json as geom, source_path from gis.cartocss where cartocss_id=$1', [params.id]).then(el => el.rows?.[0]);
+    const cartocss = await pg.query('select *, ARRAY[ST_XMin(geom), ST_YMin(geom),  ST_XMax(geom),  ST_YMax(geom)] as bounds, st_asgeojson(geom)::json as geom, source_path from gis.cartocss where cartocss_id=$1', [id]).then(r => r.rows?.[0]);
 
     if (!cartocss) {
-        return reply.status(404).send({ error: `cartocss not found: ${params.id}`, code: 404 });
+        throw NotFoundError(`cartocss not found: ${id}`);
     }
 
     // filter system columns
     Object.keys(cartocss).filter(key => exclude.includes(key)).forEach(key => delete cartocss[key]);
 
     const rtile = await RenderTile({
-        name: cartocss.source_path ? `vector/${cartocss.source_path}` : params.id, // required for cartocss
+        name: cartocss.source_path ? `vector/${cartocss.source_path}` : id, // required for cartocss
         width: 256,
         bbox: [3713463.7081504324, 6088362.176970857, 3713616.5822070027, 6088515.051027427],
         ttl: '0',
-        // debug: query.debug,
     }).catch(err => ({ err: err.toString() }));
 
     // skip empty bounds[null,null,null,null]
-    const bounds = cartocss.bounds && cartocss.geom && !(query.nocache && user?.user_type?.includes?.('admin')) ? cartocss.bounds : await cartoBounds({
-        id: params.id, dataset: cartocss.config, table: cartocss.card_table, sql,
+    const bounds = cartocss.bounds && cartocss.geom && !(nocache && isAdmin) ? cartocss.bounds : await cartoBounds({
+        id: id, dataset: cartocss.config, table: cartocss.card_table, sql,
     }, pg).catch(err => ({ err: err.toString() }));
 
-    if (!(cartocss.bounds && cartocss.geom) && sql && user?.user_type?.includes?.('admin')) {
+    if (!(cartocss.bounds && cartocss.geom) && sql && isAdmin) {
         return bounds;
     }
 
@@ -50,7 +48,7 @@ export default async function checkCarto({
         time: Date.now() - time,
         ...cartocss,
         info: !!(cartocss.card_auto || (cartocss.card_html && cartocss.card_table)),
-        url: `${prefix}/gis-rtile/${params.id}/{z}/{x}/{y}.png`,
+        url: `${prefix}/gis-rtile/${id}/{z}/{x}/{y}.png`,
         bounds,
         render: !!rtile.base64,
         renderError: rtile.err && config.local ? rtile.err : !!rtile.err,

package/server/routes/gis/functions/checkXML.js

@@ -0,0 +1,107 @@
+import path from 'node:path';
+
+import mapnik from "../../../plugins/mapnik/funcs/mapnik.js";
+
+export default async function checkXML(pg, send = () => { }) {
+    if (!pg?.pk) {
+        throw new Error("empty pg");
+    }
+
+    const {
+        GetRasterStatus, GetRasterInfo, RenderTile,
+    } = mapnik();
+
+    const errors = { raster: 0, css: 0, service: 0 };
+
+    const rasters = pg.pk['gis.rasters'] ? await pg.query('select * from gis.rasters').then(r => r.rows || []) : [];
+
+    const css = pg.pk['gis.cartocss'] ? await pg.query('select * from gis.cartocss').then(r => r.rows || []) : [];
+
+    const dataset = pg.pk['gis.dataset'] && false ? await pg.query('select * from gis.dataset').then(r => r.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'}`);
+
+}

package/server/routes/gis/functions/dashboard.js

@@ -0,0 +1,24 @@
+import { pgClients } from '@opengis/fastify-table/utils.js';
+
+export default async function getDashboard({ pg = pgClients.client }) {
+
+  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 stats = await pg.query(statsQuery).then(r => r.rows?.[0] || {});
+
+  return {
+    cards: {
+      services: stats.services_count || 0,
+      registers: stats.registers_count || 0,
+      maps: stats.maps_count || 0,
+      ogc: stats.ogc_count || 0,
+    },
+  };
+
+}

package/server/routes/gis/gis.route.js

@@ -0,0 +1,26 @@
+import getDashboard from './functions/dashboard.js';
+import checkXML from './functions/checkXML.js';
+
+import { logger, eventStream, pgClients } from '@opengis/fastify-table/utils.js';
+
+const privateParams = { config: { policy: 'L1', package: 'gis' } };
+const publicParams = { config: { policy: 'L0', package: 'gis' } };
+
+async function route(app) {
+    app.get('/gis-check', privateParams, async (req, reply) => {
+        const { pg = pgClients.client } = req;
+        const callback = process.env.NODE_ENV === 'test' || process.env.VITEST
+            ? console.log
+            : eventStream(reply);
+        try {
+            await checkXML(pg, callback);
+        } catch (err) {
+            logger.error(err);
+            callback(process.env.local === 'true' ? err.toString() : 'check error');
+        } finally {
+            callback('finish', true);
+        }
+    });
+    app.get('/dashboard', publicParams, getDashboard); // no params required
+}
+export default route;

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

@@ -0,0 +1,34 @@
+import { beforeAll, describe, expect, test } from 'vitest';
+
+import { build, injectWithHeaders } from '../../../test/helper.js';
+
+const user = { id: '2', type: 'admin' };
+
+beforeAll(async () => {
+    await build();
+});
+
+describe('GIS routes', () => {
+    test('GET /gis-check returns 200', async () => {
+        const res = await injectWithHeaders({
+            url: '/api/gis-check',
+            headers: { uid: user.id, user_type: user.type }
+        });
+
+        // event stream
+        expect(res.statusCode).toBe(200);
+    });
+
+    test('GET /dashboard returns 200', async () => {
+        const res = await injectWithHeaders({
+            url: '/api/dashboard',
+        });
+
+        expect(res.statusCode).toBe(200);
+        expect(res.body).toHaveProperty('cards');
+        expect(res.body.cards).toHaveProperty('services');
+        expect(res.body.cards).toHaveProperty('registers');
+        expect(res.body.cards).toHaveProperty('maps');
+        expect(res.body.cards).toHaveProperty('ogc');
+    });
+});

package/server/routes/gis/gis.schema.js

@@ -0,0 +1 @@
+export default null;

package/server/routes/map/{controllers → functions}/clearTiles.js

@@ -5,14 +5,15 @@ import {
 } from 'node:fs/promises';
 
 import rootFolder from '../../../plugins/mapnik/funcs/rootFolder.mjs';
+import { BadRequestError, NotFoundError } from '@opengis/fastify-table/errors.js';
 
 export default async function clearTiles({
-    params, query, user,
-}, reply) {
-    const filepath = path.join(rootFolder, 'vtile', params.id);
+    id, debug,
+}) {
+    const filepath = path.join(rootFolder, 'vtile', id);
 
-    if (query.debug && user?.user_type?.includes?.('admin')) {
-        return filepath;
+    if (debug) {
+        return { filepath };
     }
 
     const exists = existsSync(filepath);
@@ -21,14 +22,14 @@ export default async function clearTiles({
     const count = isDirectory ? await readdir(filepath).then(el => el.length) : 0;
 
     if (isDirectory && count === 0) {
-        return reply.status(404).send({ error: 'Тайли не знайдено', code: 404 });
+        throw NotFoundError('Тайли не знайдено');
     }
 
     if (isDirectory && exists) {
         await rm(filepath, { force: true, recursive: true });
         await mkdir(filepath, { recursive: true });
-        return reply.status(200).send({ message: 'Тайли очищено', code: 200 });
+        return { message: 'Тайли очищено', code: 200 };
     }
 
-    return reply.status(400).send({ error: 'Некорректний параметр: id', code: 400 });
+    throw BadRequestError('Некорректний параметр: id');
 }

package/server/routes/map/{controllers → functions}/geojson.js

@@ -10,9 +10,12 @@ import {
 } from '@opengis/fastify-table/utils.js';
 
 import rootFolder from '../../../plugins/mapnik/funcs/rootFolder.mjs';
+import { BadRequestError, NotFoundError } from '@opengis/fastify-table/errors.js';
 
 const systemColumns = ['uid', 'cdate', 'editor_id', 'editor_date', 'created_by', 'created_at', 'updated_by', 'updated_at'];
 
+const unittest = process.env.NODE_ENV === 'test' || process.env.VITEST;
+
 /**
  * Повертає GeoJSON для сервісу на основі налаштувань з gis.services
  * 
@@ -21,20 +24,18 @@ const systemColumns = ['uid', 'cdate', 'editor_id', 'editor_date', 'created_by',
  * @param {string} query.sql - повернути SQL запит замість даних
  * @param {boolean} query.nocache - не використовувати кеш
  */
-export default async function geojson({
-    pg = pgClients.client, params = {}, query = {}, unittest,
-}, reply) {
-    const { layer } = params;
-    const { sql, nocache, srid, type, extent } = query;
 
+export default async function geojson({
+    layer, sql, nocache, srid, type, extent,
+}, pg = pgClients.client) {
     if (!layer) {
-        return reply.status(400).send('not enough params: layer (service_id)');
+        throw BadRequestError('not enough params: layer (service_id)');
     }
 
     const serviceId = layer.replace('.json', '');
 
     if (!pg.pk?.['gis.services']) {
-        return reply.status(404).send('services table not found');
+        throw NotFoundError('services table not found');
     }
 
     const service = await pg.query(
@@ -50,10 +51,10 @@ export default async function geojson({
         from gis.services 
         where service_id = $1 and is_active = true and is_public = true`,
         [serviceId],
-    ).then(el => el.rows?.[0]);
+    ).then(r => r.rows?.[0]);
 
     if (!service) {
-        return reply.status(404).send('service not found or not available');
+        throw NotFoundError('service not found or not available');
     }
 
     const {
@@ -66,20 +67,17 @@ export default async function geojson({
     } = service;
 
     if (!source) {
-        return reply.status(400).send('invalid service source path');
+        throw BadRequestError('invalid service source path');
     }
 
-    const table = source;
-
-    if (!pg.pk?.[table]?.length) {
-        return reply.status(404).send('layer table not found');
+    if (!pg.pk?.[source]?.length) {
+        throw NotFoundError('layer table not found');
     }
 
-    const meta = await getMeta({ pg, table });
-    const { columns = [] } = meta || {};
+    const { columns = [], geom: metaGeom } = await getMeta({ pg, table: source }) || {};
 
-    const geom = gc || meta?.geom || 'geom';
-    const pk = pg.pk?.[table] || columns[0]?.name;
+    const geom = gc || metaGeom || 'geom';
+    const pk = pg.pk?.[source] || columns[0]?.name;
 
     let attributeColumns = [];
     if (attributes && Array.isArray(attributes)) {
@@ -113,11 +111,14 @@ export default async function geojson({
         const ageInMs = Date.now() - birthtimeMs;
         if (ageInMs < 86400000) {
             const content = await readFile(filepath, 'utf8');
-            return reply
-                .status(200)
-                .header('Content-Type', 'application/json')
-                .header('Cache-Control', 'public, max-age=86400')
-                .send(content);
+
+            return {
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Cache-Control': 'public, max-age=86400',
+                },
+                data: content
+            }
         }
     }
 
@@ -136,7 +137,7 @@ export default async function geojson({
         geomExpression = `st_transform(${geomExpression}, 4326)`;
     }
 
-    const quotedTable = table.split('.').map(el => `"${el}"`).join('.');
+    const quotedTable = source.split('.').map(el => `"${el}"`).join('.');
     const quotedGeom = `"${geom}"`;
 
     const geomFinal = `st_force2d(${geomExpression.replace(new RegExp(`(\\b)${geom}(\\b)`, 'g'), `$1${quotedGeom}$2`)})`;
@@ -159,29 +160,28 @@ export default async function geojson({
         ) f
     `;
 
-    if (sql === '1') return q;
-    if (sql === '2') return filepath.replace(/\\/g, '/');
+    if (sql === 1) return q;
+    if (sql === 2) return filepath.replace(/\\/g, '/');
 
-    try {
-        const result = await pg.query(q);
-        const geojsonData = result.rows[0] || { type: 'FeatureCollection', features: [] };
 
-        geojsonData.service_id = serviceId;
-        geojsonData.count = geojsonData.features?.length || 0;
+    const geojsonData = await pg.query(q)
+        .then(r => r.rows?.[0] || { type: 'FeatureCollection', features: [] });
 
-        const jsonString = JSON.stringify(geojsonData);
+    geojsonData.service_id = serviceId;
+    geojsonData.count = geojsonData.features?.length || 0;
 
-        if (!nocache && !unittest) {
-            await mkdir(path.dirname(filepath), { recursive: true });
-            await writeFile(filepath, jsonString, 'utf8');
-        }
+    const jsonString = JSON.stringify(geojsonData);
+
+    if (!nocache && !unittest) {
+        await mkdir(path.dirname(filepath), { recursive: true });
+        await writeFile(filepath, jsonString, 'utf8');
+    }
 
-        return reply
-            .status(200)
-            .header('Content-Type', 'application/json')
-            .header('Cache-Control', nocache ? 'no-cache' : 'public, max-age=86400')
-            .send(jsonString);
-    } catch (err) {
-        return reply.status(500).send({ error: err.message });
+    return {
+        headers: {
+            'Content-Type': 'application/json',
+            'Cache-Control': nocache ? 'no-cache' : 'public, max-age=86400',
+        },
+        data: jsonString
     }
 }

package/server/routes/map/{controllers → functions}/gis.convert.js

@@ -1,6 +1,8 @@
 import path from "node:path";
 
 import { downloadFile } from "@opengis/fastify-table/utils.js";
+import { BadRequestError, ConflictError, NotFoundError } from "@opengis/fastify-table/errors.js";
+
 import mapnik from "../../../plugins/mapnik/funcs/mapnik.js";
 
 const { ConvertVector } = mapnik();
@@ -20,41 +22,35 @@ function resolveExtension(filename) {
  * @body {string}  [filepath] - шлях до файлу на сервері (legacy)
  * @body {number}  [srid=4326] - цільовий EPSG код
  */
-export default async function gisConvert({ body = {} }, reply) {
-  const { file, filename, filepath, srid = 4326, encoding } = body;
-
+export default async function gisConvert({ file, filename, filepath, encoding }) {
   let data;
   let sourceName;
 
   if (typeof file === "string" && file) {
     if (!filename || typeof filename !== "string") {
-      return reply
-        .status(400)
-        .send({ error: "Потрібен параметр filename разом з file", code: 400 });
+      throw BadRequestError("Потрібен параметр filename разом з file");
     }
+
     data = Buffer.from(file, "base64");
     sourceName = path.basename(filename);
   } else if (typeof filepath === "string" && filepath) {
+    const filepath1 = filepath.replace(/%2e/g, ".").replace(/%2E/g, ".");
+    if (filepath1.includes('..')) {
+      throw ConflictError('path traversals are not allowed');
+    }
     data = await downloadFile(filepath, { buffer: true });
     if (!data) {
-      return reply
-        .status(404)
-        .send({ error: `Файл не знайдено: ${filepath}`, code: 404 });
+      throw NotFoundError(`Файл не знайдено: ${filepath}`);
     }
     sourceName = path.basename(filepath);
   } else {
-    return reply.status(400).send({
-      error: "Потрібен параметр file (base64) або filepath",
-      code: 400,
-    });
+    throw BadRequestError("Потрібен параметр file (base64) або filepath");
   }
 
   const ext = resolveExtension(sourceName);
+
   if (!ALLOWED_FORMAT.has(ext)) {
-    return reply.status(400).send({
-      error: `Непідтримуване розширення: .${ext}. Підтримується: ${[...ALLOWED_FORMAT].join(", ")}`,
-      code: 400,
-    });
+    throw BadRequestError(`Непідтримуване розширення: .${ext}. Підтримується: ${[...ALLOWED_FORMAT].join(", ")}`);
   }
 
   const res = await ConvertVector({
@@ -63,11 +59,7 @@ export default async function gisConvert({ body = {} }, reply) {
     // srs: +srid, // target srs, 4326 by default
     encoding,
     filename: sourceName,
-  }).catch((err) => ({ err }));
-
-  if (res?.err) {
-    return reply.code(500).send(res.err);
-  }
+  });
 
-  return reply.send(JSON.parse(res.geojson));
+  return JSON.parse(res.geojson);
 }