@wemap/routers 6.2.2 → 7.0.0

package/src/{cityway/CitywayUtils.spec.js → remote/cityway/CitywayRemoteRouter.spec.js}

@@ -6,25 +6,26 @@ import { fileURLToPath } from 'url';
 
 import { Coordinates } from '@wemap/geo';
 
-import { createRouterResponseFromJson } from './CitywayUtils.js';
+import CitywayRemoteRouter from './CitywayRemoteRouter.js';
 
-import { verifyRouterResponseData } from '../model/RouterResponse.type.spec.js';
+import checkRouterResponseType from '../../model/RouterResponse.type.spec.js';
 
 
 const { expect } = chai;
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const assetsPath = path.resolve(__dirname, '../../../assets');
 
-describe('CitywayUtils - createRouterResponseFromJson', () => {
+describe('CitywayRemoteRouter - createRouterResponseFromJson', () => {
 
     it('RouterResponse - 1', () => {
 
-        const filePath = path.resolve(__dirname, '../../assets/itinerary-lehavre-cityway-1.json');
+        const filePath = path.resolve(assetsPath, 'itinerary-lehavre-cityway-1.json');
         const fileString = fs.readFileSync(filePath, 'utf8');
         const json = JSON.parse(fileString);
 
-        const routerResponse = createRouterResponseFromJson(json);
-        verifyRouterResponseData(routerResponse);
+        const routerResponse = CitywayRemoteRouter.createRouterResponseFromJson(json);
+        checkRouterResponseType(routerResponse);
 
         expect(routerResponse.routerName).equal('cityway');
         expect(routerResponse.itineraries.length).equal(3);
@@ -62,48 +63,48 @@ describe('CitywayUtils - createRouterResponseFromJson', () => {
     });
 
     it('RouterResponse - 2', () => {
-        const filePath = path.resolve(__dirname, '../../assets/itinerary-lehavre-cityway-2.json');
+        const filePath = path.resolve(assetsPath, 'itinerary-lehavre-cityway-2.json');
         const fileString = fs.readFileSync(filePath, 'utf8');
         const json = JSON.parse(fileString);
 
-        const routerResponse = createRouterResponseFromJson(json);
-        verifyRouterResponseData(routerResponse);
+        const routerResponse = CitywayRemoteRouter.createRouterResponseFromJson(json);
+        checkRouterResponseType(routerResponse);
 
         expect(routerResponse.itineraries.length).equal(1);
         expect(routerResponse.itineraries[0].mode).equal('WALK');
     });
 
     it('RouterResponse - 3', () => {
-        const filePath = path.resolve(__dirname, '../../assets/itinerary-lehavre-cityway-3.json');
+        const filePath = path.resolve(assetsPath, 'itinerary-lehavre-cityway-3.json');
         const fileString = fs.readFileSync(filePath, 'utf8');
         const json = JSON.parse(fileString);
 
-        const routerResponse = createRouterResponseFromJson(json);
-        verifyRouterResponseData(routerResponse);
+        const routerResponse = CitywayRemoteRouter.createRouterResponseFromJson(json);
+        checkRouterResponseType(routerResponse);
 
         expect(routerResponse.itineraries[0].mode).equal('PT');
         expect(routerResponse.itineraries[0].legs[1].mode).equal('FUNICULAR');
     });
 
     it('RouterResponse - 4', () => {
-        const filePath = path.resolve(__dirname, '../../assets/itinerary-lehavre-cityway-4.json');
+        const filePath = path.resolve(assetsPath, 'itinerary-lehavre-cityway-4.json');
         const fileString = fs.readFileSync(filePath, 'utf8');
         const json = JSON.parse(fileString);
 
-        const routerResponse = createRouterResponseFromJson(json);
-        verifyRouterResponseData(routerResponse);
+        const routerResponse = CitywayRemoteRouter.createRouterResponseFromJson(json);
+        checkRouterResponseType(routerResponse);
 
         expect(routerResponse.itineraries[0].mode).equal('BIKE');
         expect(routerResponse.itineraries[0].legs[0].mode).equal('BIKE');
     });
 
     it('RouterResponse - 5', () => {
-        const filePath = path.resolve(__dirname, '../../assets/itinerary-lehavre-cityway-5.json');
+        const filePath = path.resolve(assetsPath, 'itinerary-lehavre-cityway-5.json');
         const fileString = fs.readFileSync(filePath, 'utf8');
         const json = JSON.parse(fileString);
 
-        const routerResponse = createRouterResponseFromJson(json);
-        verifyRouterResponseData(routerResponse);
+        const routerResponse = CitywayRemoteRouter.createRouterResponseFromJson(json);
+        checkRouterResponseType(routerResponse);
 
         expect(routerResponse.itineraries[1].mode).equal('PT');
         expect(routerResponse.itineraries[1].legs[1].mode).equal('TRAM');

package/src/remote/deutsche-bahn/DeutscheBahnRemoteRouter.js

@@ -0,0 +1,143 @@
+/* eslint-disable max-statements */
+
+import { Coordinates, GraphEdge, GraphItinerary, GraphNode, Level } from '@wemap/geo';
+import { OsmElement, OsmNode, OsmWay } from '@wemap/osm';
+
+import RemoteRouter from '../RemoteRouter.js';
+import Itinerary from '../../model/Itinerary.js';
+import RouterResponse from '../../model/RouterResponse.js';
+import { generateStepsMetadata } from '../RemoteRouterUtils.js';
+import StepsGeneration from '../../wemap/WemapStepsGeneration.js';
+import RemoteRouterServerUnreachable from '../RemoteRouterServerUnreachable.js';
+
+/**
+ * Singleton.
+ */
+class DeutscheBahnRemoteRouter extends RemoteRouter {
+
+    /**
+     * @override
+     */
+    get rname() {
+        return 'deutsche-bahn';
+    }
+
+    /**
+     * @override
+     * @throws {RemoteRouterServerUnreachable}
+     */
+    async getItineraries(endpointUrl, mode, waypoints) {
+        const url = this.getURL(endpointUrl, mode, waypoints);
+        const res = await fetch(url);
+        if (res.status !== 200) {
+            throw new RemoteRouterServerUnreachable(this.rname, url);
+        }
+        const response = await res.json();
+        return this.createRouterResponseFromJson(response, waypoints[0], waypoints[1]);
+    }
+
+    /**
+     * @param {string} endpointUrl
+     * @param {string} mode
+     * @param {Array<Coordinates>} waypoints
+     */
+    getURL(endpointUrl, mode, waypoints) {
+        let url = endpointUrl + '/route/v1/walking/';
+
+        url += waypoints.map(waypoint => {
+            if (waypoint.level) {
+                const altitude = waypoint.level.isRange ? waypoint.level.low : waypoint.level.val;
+
+                return waypoint.longitude + ',' + waypoint.latitude + ',' + altitude;
+            }
+
+            return waypoint.longitude + ',' + waypoint.latitude;
+        }).join(';');
+
+        url += '?geometries=geojson&overview=full&steps=true';
+
+        return url;
+    }
+
+    /**
+     * Generate multi itineraries from the DB JSON
+     * @param {object} json JSON file provided by the DB.
+     * @param {Coordinates} from itinerary start
+     * @param {Coordinates} to itinerary end
+     * @returns {?RouterResponse}
+     */
+    createRouterResponseFromJson(json, from, to) {
+
+        const { segments: jsonSegments } = json;
+
+        if (!jsonSegments) {
+            return null;
+        }
+
+        const routerResponse = new RouterResponse();
+        routerResponse.routerName = this.rname;
+
+        routerResponse.from = from;
+        routerResponse.to = to;
+
+        /** @type {GraphEdge<OsmElement>[]} */
+        const edges = [];
+
+        /** @type {GraphNode<OsmElement>[]} */
+        const nodes = [];
+
+        /** @type {number[]} */
+        const edgesWeights = [];
+
+        let id = 1;
+        for (const jsonSegment of jsonSegments) {
+
+            const level = new Level(jsonSegment.fromLevel, jsonSegment.toLevel);
+            const osmWay = new OsmWay(id++, null, level);
+
+            for (const jsonPoint of jsonSegment.polyline) {
+                const coord = new Coordinates(jsonPoint.lat, jsonPoint.lon, null, level);
+
+                if (nodes.length !== 0
+                    && nodes[nodes.length - 1].coords.equalsTo(coord)) {
+                    continue;
+                }
+
+                const osmNode = new OsmNode(id++, coord);
+                const node = new GraphNode(osmNode.coords, osmNode);
+
+                if (nodes.length !== 0) {
+                    const prevNode = nodes[nodes.length - 1];
+                    const edge = new GraphEdge(prevNode, node, level, osmWay);
+                    edges.push(edge);
+                    edgesWeights.push(prevNode.coords.distanceTo(osmNode));
+                }
+
+                nodes.push(node);
+
+            }
+        }
+
+        /** @type {GraphItinerary<OsmElement>} */
+        const graphItinerary = new GraphItinerary();
+        graphItinerary.nodes = nodes;
+        graphItinerary.edges = edges;
+        graphItinerary.edgesWeights = edgesWeights;
+        graphItinerary.start = nodes[0].coords;
+        graphItinerary.end = nodes[nodes.length - 1].coords;
+
+        const points = nodes.map(node => node.coords);
+        const itinerary = Itinerary.fromOrderedCoordinates(points, from, to);
+        itinerary.legs[0].steps = StepsGeneration.fromGraphItinerary(graphItinerary);
+        itinerary.legs[0].steps.map((step, idx) => (step._idCoordsInLeg = idx));
+
+        // All legs have to be parsed before computing steps metadata
+        generateStepsMetadata(itinerary);
+
+        routerResponse.itineraries.push(itinerary);
+
+        return routerResponse;
+    }
+}
+
+export default new DeutscheBahnRemoteRouter();

package/src/{deutsche-bahn/DeutscheBahnRouterUtils.spec.js → remote/deutsche-bahn/DeutscheBahnRemoteRouter.spec.js}

@@ -7,29 +7,30 @@ import { fileURLToPath } from 'url';
 
 import { Coordinates, Level } from '@wemap/geo';
 
-import { createRouterResponseFromJson } from './DeutscheBahnRouterUtils.js';
+import DeutscheBahnRemoteRouter from './DeutscheBahnRemoteRouter.js';
 
-import { verifyRouterResponseData } from '../model/RouterResponse.type.spec.js';
+import checkRouterResponseType from '../../model/RouterResponse.type.spec.js';
 
 
 const { expect } = chai;
 chai.use(chaiAlmost(0.1));
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const assetsPath = path.resolve(__dirname, '../../../assets');
 
-describe('OtpUtils - createRouterResponseFromJson', () => {
+describe('DeutscheBahnRemoteRouter - createRouterResponseFromJson', () => {
 
     it('RouterResponse - 1', () => {
 
-        const filePath = path.resolve(__dirname, '../../assets/itinerary-deutsche-bahn-1.json');
+        const filePath = path.resolve(assetsPath, 'itinerary-deutsche-bahn-1.json');
         const fileString = fs.readFileSync(filePath, 'utf8');
         const json = JSON.parse(fileString);
 
         const from = new Coordinates(52.5258473, 13.3683657, null, new Level(-10));
         const to = new Coordinates(52.52499085853664, 13.369467296949914, null, new Level(0));
 
-        const routerResponse = createRouterResponseFromJson(json, from, to);
-        verifyRouterResponseData(routerResponse);
+        const routerResponse = DeutscheBahnRemoteRouter.createRouterResponseFromJson(json, from, to);
+        checkRouterResponseType(routerResponse);
 
         expect(routerResponse.routerName).equal('deutsche-bahn');
         expect(routerResponse.itineraries.length).equal(1);