@wemap/routers 7.1.1 → 7.2.1

package/src/Utils.js

@@ -1,3 +1,6 @@
+
+import RouterResponse from './model/RouterResponse.js';
+
 /**
  * Get route duration
  * @param {Number} speed in km/h
@@ -6,3 +9,55 @@
 export function getDurationFromLength(length, speed = 5) {
     return length / (speed * 1000 / 3600);
 }
+
+/* eslint-disable max-statements */
+/* eslint-disable max-depth */
+/**
+ * @param {RouterResponse} routerResponse
+ * @param {Number} levelFactor
+ */
+export function multiplyRouterResponseLevel(routerResponse, levelFactor) {
+    if (routerResponse.from.level) {
+        routerResponse.from.level.multiplyBy(levelFactor);
+    }
+    if (routerResponse.to.level) {
+        routerResponse.to.level.multiplyBy(levelFactor);
+    }
+    for (const itinerary of routerResponse.itineraries) {
+        if (itinerary.from.level) {
+            itinerary.from.level.multiplyBy(levelFactor);
+        }
+        if (itinerary.to.level) {
+            itinerary.to.level.multiplyBy(levelFactor);
+        }
+
+        for (const leg of itinerary.legs) {
+            if (leg.from.coords.level) {
+                leg.from.coords.level.multiplyBy(levelFactor);
+            }
+            if (leg.to.coords.level) {
+                leg.to.coords.level.multiplyBy(levelFactor);
+            }
+            for (const coords of leg.coords) {
+                if (coords.level) {
+                    coords.level.multiplyBy(levelFactor);
+                }
+            }
+            if (leg.steps) {
+                for (const step of leg.steps) {
+                    if (step.coords.level) {
+                        step.coords.level.multiplyBy(levelFactor);
+                    }
+                }
+            }
+        }
+
+        if (itinerary._coords) {
+            for (const coords of itinerary._coords) {
+                if (coords.level) {
+                    coords.level.multiplyBy(levelFactor);
+                }
+            }
+        }
+    }
+}

package/src/Utils.spec.js

@@ -0,0 +1,60 @@
+/* eslint-disable max-statements */
+import chai from 'chai';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import RouterResponse from './model/RouterResponse.js';
+import { multiplyRouterResponseLevel } from './Utils.js';
+
+const { expect } = chai;
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const assetsPath = path.resolve(__dirname, '../assets');
+
+describe('Routers Utils', () => {
+
+    it('multiplyRouterResponseLevel', () => {
+
+        const filePath = path.resolve(assetsPath, 'rr-wemap-meta-multi-level.json');
+        const fileString = fs.readFileSync(filePath, 'utf8');
+        const json = JSON.parse(fileString);
+
+        const routerResponse = RouterResponse.fromJson(json);
+        multiplyRouterResponseLevel(routerResponse, 5);
+
+        expect(routerResponse.from.level.val).equal(10);
+        expect(routerResponse.to.level.val).equal(5);
+
+        const itinerary = routerResponse.itineraries[0];
+        expect(itinerary.from.level.val).equal(10);
+        expect(itinerary.to.level.val).equal(5);
+
+        const leg = itinerary.legs[0];
+        expect(leg.from.coords.level.val).equal(10);
+        expect(leg.to.coords.level.val).equal(5);
+
+        for (let i = 0; i < leg.coords.length; i++) {
+            if (i <= 6) {
+                expect(leg.coords[i].level.val).equal(10);
+            } else if (i <= 8) {
+                expect(leg.coords[i].level.up).equal(10);
+                expect(leg.coords[i].level.low).equal(5);
+            } else {
+                expect(leg.coords[i].level.val).equal(5);
+            }
+        }
+
+        const { steps } = leg;
+        for (let i = 0; i < steps.length; i++) {
+            if (i <= 5) {
+                expect(steps[i].coords.level.val).equal(10);
+            } else {
+                expect(steps[i].coords.level.val).equal(5);
+            }
+        }
+    });
+
+
+});
+

package/src/remote/RemoteRouterUtils.js

@@ -1,6 +1,10 @@
+import { NoRouteFoundError } from '@wemap/geo';
 import { diffAngle } from '@wemap/maths';
 
 import Itinerary from '../model/Itinerary.js';
+import IdfmRemoteRouterTokenError from './idfm/IdfmRemoteRouterTokenError.js';
+import RemoteRouterServerUnreachable from './RemoteRouterServerUnreachable.js';
+import RoutingModeCorrespondanceNotFound from './RoutingModeCorrespondanceNotFound.js';
 
 
 /**
@@ -76,3 +80,10 @@ export function dateWithTimeZone(year, month, day, hour, minute, second, timeZon
 
     return date;
 }
+
+export function isRoutingError(e) {
+    return e instanceof RemoteRouterServerUnreachable
+        || e instanceof RoutingModeCorrespondanceNotFound
+        || e instanceof IdfmRemoteRouterTokenError
+        || e instanceof NoRouteFoundError;
+}

package/src/remote/idfm/IdfmRemoteRouter.js

@@ -103,14 +103,37 @@ class IdfmRemoteRouter extends RemoteRouter {
 
         const url = this.getURL(endpointUrl, mode, waypoints);
 
-        const res = await fetch(url, {
+        const res = await (fetch(url, {
             method: 'GET',
             headers: { Authorization: 'Bearer ' + this.token }
+        }).catch(() => {
+            throw new RemoteRouterServerUnreachable(this.rname, url);
+        }));
+
+
+        const response = await res.json().catch(() => {
+            throw new RemoteRouterServerUnreachable(this.rname, url);
         });
+
+        // When IDFM failed to calculate an itinerary (ie. start or end
+        // point is far from network), it respond a 404 with an error message
+        if (res.status === 404) {
+            let errorMessage = 'no details.';
+            if (response && 'error' in response && 'message' in response.error) {
+                errorMessage = response.error.message;
+            }
+
+            const routerResponse = new RouterResponse();
+            routerResponse.routerName = this.rname;
+            routerResponse.from = waypoints[0];
+            routerResponse.to = waypoints[1];
+            routerResponse.error = errorMessage;
+            return routerResponse;
+        }
+
         if (res.status !== 200) {
             throw new RemoteRouterServerUnreachable(this.rname, url);
         }
-        const response = await res.json();
 
         return this.createRouterResponseFromJson(response);
     }
@@ -181,17 +204,17 @@ class IdfmRemoteRouter extends RemoteRouter {
 
         let query = '';
         switch (mode) {
-        case Constants.ROUTING_MODE.WALK:
-            query = this.getWalkingQuery();
-            break;
-        case Constants.ROUTING_MODE.BIKE:
-            query = this.getBikeQuery();
-            break;
-        case Constants.ROUTING_MODE.CAR:
-            query = this.getCarQuery();
-            break;
-        default:
-            break;
+            case Constants.ROUTING_MODE.WALK:
+                query = this.getWalkingQuery();
+                break;
+            case Constants.ROUTING_MODE.BIKE:
+                query = this.getBikeQuery();
+                break;
+            case Constants.ROUTING_MODE.CAR:
+                query = this.getCarQuery();
+                break;
+            default:
+                break;
         }
 
         url = `${url.origin}${url.pathname}${search}${query}`;

package/src/wemap-meta/WemapMetaRouter.js

@@ -7,6 +7,7 @@ import Logger from '@wemap/logger';
 import IOMap from './IOMap.js';
 import WemapMetaRouterOptions from './WemapMetaRouterOptions.js';
 import RemoteRouterManager from '../remote/RemoteRouterManager.js';
+import { isRoutingError } from '../remote/RemoteRouterUtils.js';
 import WemapMetaRemoteRouterOptions from '../remote/wemap-meta/WemapMetaRemoteRouterOptions.js';
 import WemapRouterOptions from '../wemap/WemapRouterOptions.js';
 import RouterResponse from '../model/RouterResponse.js';
@@ -63,6 +64,12 @@ class WemapMetaRouter {
         const start = waypoints[0];
         const end = waypoints[1];
 
+        const routerResponse = new RouterResponse();
+        routerResponse.routerName = this.rname;
+        routerResponse.from = start;
+        routerResponse.to = end;
+
+
         // Avoid cycles on remoteRouters
         const remoteRouters = options.remoteRouters.filter(
             ({ name }) => name !== WemapMetaRemoteRouterOptions.rname
@@ -101,7 +108,15 @@ class WemapMetaRouter {
          * 3 - intersection of this.maps and options.targetMaps is empty
          */
         if (!ioMapsToTest.length) {
-            return RemoteRouterManager.getItinerariesWithFallback(remoteRouters, mode, waypoints);
+            try {
+                return await RemoteRouterManager.getItinerariesWithFallback(remoteRouters, mode, waypoints);
+            } catch (e) {
+                if (!isRoutingError(e)) {
+                    throw e;
+                }
+                routerResponse.error = e.message;
+                return routerResponse;
+            }
         }
 
 
@@ -114,10 +129,8 @@ class WemapMetaRouter {
          *
          */
 
-        const routerResponse = new RouterResponse();
-        routerResponse.from = start;
-        routerResponse.to = end;
-
+        /** @type {Itinerary} */
+        let ioMapItinerary;
 
         // Find the first map where the "start" is inside.
         const mapWithStart = ioMapsToTest.find(map => map.isPointInside(start));
@@ -134,9 +147,17 @@ class WemapMetaRouter {
          */
         if (mapWithStart && mapWithStart.isPointInside(end)) {
 
-            const itinerary = mapWithStart.getItineraryInsideMap(start, end, wemapRouterOptions);
+            try {
+                ioMapItinerary = mapWithStart.getItineraryInsideMap(start, end, wemapRouterOptions);
+            } catch (e) {
+                if (!isRoutingError(e)) {
+                    throw e;
+                }
+                routerResponse.error = `${e.message} - on map ${mapWithStart.name}.`;
+                return routerResponse;
+            }
 
-            routerResponse.itineraries.push(itinerary);
+            routerResponse.itineraries.push(ioMapItinerary);
             routerResponse.routerName = [this.rname, WemapRouter.rname];
 
             return routerResponse;
@@ -146,21 +167,27 @@ class WemapMetaRouter {
         // Note: At this step, mapWithEnd is necessarily different from mapWithStart
         const mapWithEnd = ioMapsToTest.find(map => map.isPointInside(end));
 
+
+        /** @type {RouterResponse} */
+        let remoteRouterResponse;
+
         /*
          * Case 2
          *
          * If no io map have been found for "start" and "end", therefore use remote router.
          */
         if (!mapWithStart && !mapWithEnd) {
-            return RemoteRouterManager.getItinerariesWithFallback(remoteRouters, mode, waypoints);
+            try {
+                return await RemoteRouterManager.getItinerariesWithFallback(remoteRouters, mode, waypoints);
+            } catch (e) {
+                if (!isRoutingError(e)) {
+                    throw e;
+                }
+                routerResponse.error = e.message;
+                return routerResponse;
+            }
         }
 
-        /** @type {RouterResponse} */
-        let remoteRouterResponse;
-
-        /** @type {Itinerary} */
-        let ioMapItinerary;
-
         /**
          * Case 3
          *
@@ -184,23 +211,21 @@ class WemapMetaRouter {
 
             try {
                 ioMapItinerary = mapWithStart.getBestItineraryFromStartToEntryPoints(start, end, wemapRouterOptions);
+                remoteRouterResponse = await RemoteRouterManager.getItinerariesWithFallback(
+                    remoteRouters, mode, [ioMapItinerary.to, end]
+                );
+                if (!remoteRouterResponse.itineraries.length) {
+                    throw new NoRouteFoundError(ioMapItinerary.to, end, remoteRouterResponse.error);
+                }
             } catch (e) {
-                if (!(e instanceof NoRouteFoundError)) {
+                if (!isRoutingError(e)) {
                     throw e;
                 }
-                routerResponse.error = `${e.message} - on map ${mapWithStart.name}.`;
-                return routerResponse;
-            }
-            remoteRouterResponse = await RemoteRouterManager.getItinerariesWithFallback(
-                remoteRouters, mode, [ioMapItinerary.to, end]
-            );
-
-
-            if (!remoteRouterResponse.itineraries.length) {
-                routerResponse.error = `Tried to calculate an itinerary from "start" 
-                    to "entrypoints" using wemap router on local map "${mapWithStart.name}" and
-                    an itinerary from  "entrypoints" to "end" using remote routers 
-                    (${remoteRouters.map(r => r.name).join(', ')}), but failed.`;
+                routerResponse.error = 'Tried to calculate an itinerary from "start" '
+                    + `to "entrypoints" using wemap router on local map "${mapWithStart.name}" and `
+                    + 'an itinerary from  "entrypoints" to "end" using remote routers '
+                    + `(${remoteRouters.map(r => r.name).join(', ')}), but failed. `
+                    + `Details: ${e.message}.`;
                 return routerResponse;
             }
 
@@ -240,22 +265,21 @@ class WemapMetaRouter {
              */
             try {
                 ioMapItinerary = mapWithEnd.getBestItineraryFromEntryPointsToEnd(start, end, wemapRouterOptions);
+                remoteRouterResponse = await RemoteRouterManager.getItinerariesWithFallback(
+                    remoteRouters, mode, [start, ioMapItinerary.from]
+                );
+                if (!remoteRouterResponse.itineraries.length) {
+                    throw new NoRouteFoundError(start, ioMapItinerary.from, remoteRouterResponse.error);
+                }
             } catch (e) {
-                if (!(e instanceof NoRouteFoundError)) {
+                if (!isRoutingError(e)) {
                     throw e;
                 }
-                routerResponse.error = `${e.message} - on map ${mapWithEnd.name}.`;
-                return routerResponse;
-            }
-            remoteRouterResponse = await RemoteRouterManager.getItinerariesWithFallback(
-                remoteRouters, mode, [start, ioMapItinerary.from]
-            );
-
-            if (!remoteRouterResponse.itineraries.length) {
-                routerResponse.error = `Tried to calculate an itinerary from "start" to "entrypoints" 
-                    using remote routers (${remoteRouters.map(r => r.name).join(', ')}) and an
-                    itinerary from "entrypoints" to "end" using wemap router on local map
-                    "${mapWithEnd.name}", but failed.`;
+                routerResponse.error = 'Tried to calculate an itinerary from "start" to "entrypoints" '
+                    + `using remote routers (${remoteRouters.map(r => r.name).join(', ')}) and an `
+                    + 'itinerary from "entrypoints" to "end" using wemap router on local map '
+                    + `"${mapWithEnd.name}", but failed. `
+                    + `Details: ${e.message}.`;
                 return routerResponse;
             }
 
@@ -298,32 +322,23 @@ class WemapMetaRouter {
         let ioMapItinerary1, ioMapItinerary2;
         try {
             ioMapItinerary1 = mapWithStart.getBestItineraryFromStartToEntryPoints(start, end, wemapRouterOptions);
-        } catch (e) {
-            if (!(e instanceof NoRouteFoundError)) {
-                throw e;
-            }
-            routerResponse.error = `${e.message} - on map ${mapWithStart.name}.`;
-            return routerResponse;
-        }
-        try {
             ioMapItinerary2 = mapWithEnd.getBestItineraryFromEntryPointsToEnd(start, end, wemapRouterOptions);
+            remoteRouterResponse = await RemoteRouterManager.getItinerariesWithFallback(
+                remoteRouters, mode, [ioMapItinerary1.to, ioMapItinerary2.from]
+            );
+            if (!remoteRouterResponse.itineraries.length) {
+                throw new NoRouteFoundError(ioMapItinerary1.to, ioMapItinerary2.from, remoteRouterResponse.error);
+            }
         } catch (e) {
-            if (!(e instanceof NoRouteFoundError)) {
+            if (!isRoutingError(e)) {
                 throw e;
             }
-            routerResponse.error = `${e.message} - on map ${mapWithEnd.name}.`;
-            return routerResponse;
-        }
-        remoteRouterResponse = await RemoteRouterManager.getItinerariesWithFallback(
-            remoteRouters, mode, [ioMapItinerary1.to, ioMapItinerary2.from]
-        );
-
-        if (!remoteRouterResponse.itineraries.length) {
-            routerResponse.error = `Tried to calculate an itinerary from "start" to "entrypoints1" 
-                using wemap router on local map  "${mapWithStart.name}", an itinerary from
-                "entrypoints1" to "entrypoints2" using remote routers 
-                (${remoteRouters.map(r => r.name).join(', ')}) and an itinerary from "entrypoints2" 
-                to "end" using wemap router on local map "${mapWithEnd.name}", but failed.`;
+            routerResponse.error = 'Tried to calculate an itinerary from "start" to "entrypoints1" '
+                + `using wemap router on local map  "${mapWithStart.name}", an itinerary from `
+                + '"entrypoints1" to "entrypoints2" using remote routers '
+                + `(${remoteRouters.map(r => r.name).join(', ')}) and an itinerary from "entrypoints2" `
+                + `to "end" using wemap router on local map "${mapWithEnd.name}", but failed. `
+                + `Details: ${e.message}.`;
             return routerResponse;
         }