@wemap/routers 6.2.3 → 7.0.0

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);

package/src/remote/idfm/IdfmRemoteRouter.js

@@ -0,0 +1,432 @@
+/* eslint-disable max-statements */
+import { Coordinates, Utils as GeoUtils } from '@wemap/geo';
+import Logger from '@wemap/logger';
+
+import Itinerary from '../../model/Itinerary.js';
+import Leg from '../../model/Leg.js';
+import RouterResponse from '../../model/RouterResponse.js';
+import Step from '../../model/Step.js';
+import { generateStepsMetadata, dateWithTimeZone } from '../RemoteRouterUtils.js';
+import Constants from '../../Constants.js';
+import RemoteRouter from '../RemoteRouter.js';
+import RemoteRouterServerUnreachable from '../RemoteRouterServerUnreachable.js';
+import IdfmRemoteRouterTokenError from './IdfmRemoteRouterTokenError.js';
+
+/**
+ * List of all modes supported by the API
+ * http://doc.navitia.io/#physical-mode
+ */
+
+const routingModeCorrespondance = new Map();
+routingModeCorrespondance.set('Air', Constants.ROUTING_MODE.AIRPLANE);
+routingModeCorrespondance.set('Boat', Constants.ROUTING_MODE.BOAT);
+routingModeCorrespondance.set('Bus', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('BusRapidTransit', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('Coach', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('Ferry', Constants.ROUTING_MODE.FERRY);
+routingModeCorrespondance.set('Funicular', Constants.ROUTING_MODE.FUNICULAR);
+routingModeCorrespondance.set('LocalTrain', Constants.ROUTING_MODE.TRAIN);
+routingModeCorrespondance.set('LongDistanceTrain', Constants.ROUTING_MODE.TRAIN);
+routingModeCorrespondance.set('Metro', Constants.ROUTING_MODE.METRO);
+routingModeCorrespondance.set('Métro', Constants.ROUTING_MODE.METRO);
+routingModeCorrespondance.set('RailShuttle', Constants.ROUTING_MODE.TRAIN);
+routingModeCorrespondance.set('RapidTransit', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('Shuttle', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('SuspendedCableCar', Constants.ROUTING_MODE.FUNICULAR);
+routingModeCorrespondance.set('Taxi', Constants.ROUTING_MODE.TAXI);
+routingModeCorrespondance.set('Train', Constants.ROUTING_MODE.TRAIN);
+routingModeCorrespondance.set('RER', Constants.ROUTING_MODE.TRAIN);
+routingModeCorrespondance.set('Tramway', Constants.ROUTING_MODE.TRAM);
+routingModeCorrespondance.set('walking', Constants.ROUTING_MODE.WALK);
+routingModeCorrespondance.set('bike', Constants.ROUTING_MODE.BIKE);
+
+/**
+ * List of transports modes
+ */
+const TRANSPORT_IDS = [
+    'physical_mode:Air',
+    'physical_mode:Boat',
+    'physical_mode:Bus',
+    'physical_mode:BusRapidTransit',
+    'physical_mode:Coach',
+    'physical_mode:Ferry',
+    'physical_mode:Funicular',
+    'physical_mode:LocalTrain',
+    'physical_mode:LongDistanceTrain',
+    'physical_mode:Metro',
+    'physical_mode:RailShuttle',
+    'physical_mode:RapidTransit',
+    'physical_mode:Shuttle',
+    'physical_mode:SuspendedCableCar',
+    'physical_mode:Taxi',
+    'physical_mode:Train',
+    'physical_mode:Tramway'
+];
+
+const clientId = '539eec73-3bb5-4327-bb5e-a52672658592';
+const clientSecret = '899f4bb9-f1d5-45d3-9f67-530827bb6734';
+
+/**
+ * Get last item of a given array
+ * @param {Array} array
+ * @returns {any}
+ */
+function last(array) {
+    return array[array.length - 1];
+}
+
+/**
+ * Singleton.
+ */
+class IdfmRemoteRouter extends RemoteRouter {
+
+    isLogged = false;
+    token = null;
+    expiresAt = null;
+
+    /**
+     * @override
+     */
+    get rname() {
+        return 'idfm';
+    }
+
+    /**
+     * @override
+     * @throws {IdfmRemoteRouterTokenError}
+     * @throws {RemoteRouterServerUnreachable}
+     */
+    async getItineraries(endpointUrl, mode, waypoints) {
+        if (!this.canRequestService()) {
+            await this._connect();
+        }
+
+        const url = this.getURL(endpointUrl, mode, waypoints);
+
+        const res = await fetch(url, {
+            method: 'GET',
+            headers: { Authorization: 'Bearer ' + this.token }
+        });
+        if (res.status !== 200) {
+            throw new RemoteRouterServerUnreachable(this.rname, url);
+        }
+        const response = await res.json();
+
+        return this.createRouterResponseFromJson(response);
+    }
+
+    /**
+     * @throws {IdfmRemoteRouterTokenError}
+     */
+    async _connect() {
+
+        const details = {
+            'grant_type': 'client_credentials',
+            'scope': 'read-data',
+            'client_id': clientId,
+            'client_secret': clientSecret
+        };
+
+        const data = new URLSearchParams();
+        for (const property in details) {
+            if (details.hasOwnProperty(property)) {
+                const encodedKey = encodeURIComponent(property);
+                const encodedValue = encodeURIComponent(details[property]);
+                data.append(encodedKey, encodedValue);
+            }
+        }
+
+        const headers = new Headers({
+            'Content-Type': 'application/x-www-form-urlencoded;charset=UTF-8'
+        });
+
+        const res = await fetch('https://idfm.getwemap.com/api/oauth/token', {
+            method: 'POST',
+            body: data,
+            headers
+        });
+        if (res.status !== 200) {
+            throw new IdfmRemoteRouterTokenError();
+        }
+        const response = await res.json();
+
+        if (response.access_token) {
+            this.token = response.access_token;
+            this.isLogged = true;
+            this.expiresAt = new Date(new Date().getTime() + response.expires_in * 1000);
+        }
+    }
+
+    canRequestService() {
+        return this.token && this.expiresAt && this.expiresAt - new Date() > 0;
+    }
+
+    /**
+     * @param {string} endpointUrl
+     * @param {string} mode
+     * @param {Array<Coordinates>} waypoints
+     */
+    getURL(endpointUrl, mode, waypoints) {
+
+        if (waypoints.length > 2) {
+            Logger.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints.length})`);
+        }
+
+        const fromPlace = `from=${waypoints[0].longitude};${waypoints[0].latitude}`;
+        const toPlace = `to=${waypoints[1].longitude};${waypoints[1].latitude}`;
+
+        let url = new URL(endpointUrl);
+        let { search } = url;
+        search = (search ? `${search}&` : '?') + `${fromPlace}&${toPlace}`;
+
+        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;
+        }
+
+        url = `${url.origin}${url.pathname}${search}${query}`;
+
+        return url;
+    }
+
+    getCarQuery() {
+        const forbiddenTransport = TRANSPORT_IDS.map((id) => `forbidden_uris[]=${id}`).join('&');
+        const allowCar = 'first_section_mode[]=walking&first_section_mode[]=car&last_section_mode[]=walking&last_section_mode[]=car';
+
+        return `&${forbiddenTransport}&${allowCar}`;
+    }
+
+    getWalkingQuery() {
+        const forbiddenTransport = TRANSPORT_IDS.map((id) => `forbidden_uris[]=${id}`).join('&');
+        const allowWalking = 'first_section_mode[]=walking&last_section_mode[]=walking';
+
+        return `&${forbiddenTransport}&${allowWalking}`;
+    }
+
+    getBikeQuery() {
+        const forbiddenTransport = TRANSPORT_IDS.map((id) => `forbidden_uris[]=${id}`).join('&');
+        const allowBike = 'first_section_mode[]=bike&last_section_mode[]=bike';
+
+        return `&${forbiddenTransport}&${allowBike}`;
+    }
+
+    /**
+     * @param {object} json
+     * @returns {Coordinates}
+     */
+    jsonToCoordinates(json) {
+        return new Coordinates(Number(json.lat), Number(json.lon));
+    }
+
+    getSectionCoords(section) {
+        const from = section.from.stop_point ? this.jsonToCoordinates(section.from.stop_point.coord) : this.jsonToCoordinates(section.from.address.coord);
+        const to = section.to.stop_point ? this.jsonToCoordinates(section.to.stop_point.coord) : this.jsonToCoordinates(section.to.address.coord);
+
+        return {
+            from,
+            to
+        };
+    }
+
+    /**
+     * Since the IDFM API does not provide coords for each step, we need to compute them
+     * We trim the coordinates of the leg with the distance of each step and keep the last result as the coords of the step
+     * @param {Leg} leg
+     */
+    findStepsCoord(leg) {
+        const { steps, coords } = leg;
+
+        const duplicatedCoords = [...coords];
+        let previousStep = steps[0];
+        let accumulatedIndex = 0;
+
+        for (const [idx, step] of steps.entries()) {
+            let newCoords;
+
+            if (idx === 0) {
+                step._idCoordsInLeg = 0;
+                newCoords = coords[0];
+            } else if (idx === steps.length - 1) {
+                step._idCoordsInLeg = coords.length - 1;
+                newCoords = last(coords);
+            } else if (duplicatedCoords.length === 1) {
+                accumulatedIndex++;
+
+                step._idCoordsInLeg = accumulatedIndex;
+
+                newCoords = duplicatedCoords[0];
+
+                coords[step._idCoordsInLeg] = newCoords;
+            } else {
+                const result = GeoUtils.trimRoute(duplicatedCoords, duplicatedCoords[0], previousStep.distance);
+                accumulatedIndex += result.length - 1;
+
+                duplicatedCoords.splice(0, result.length - 1);
+
+                step._idCoordsInLeg = accumulatedIndex;
+
+                newCoords = last(result);
+
+                coords[step._idCoordsInLeg] = newCoords;
+            }
+
+            step.coords = newCoords;
+
+            previousStep = step;
+        }
+    }
+
+    /**
+     * @param {string} stringDate (e.g. 20211117T104516)
+     * @returns {number}
+     */
+    dateStringToTimestamp(stringDate, timeZone) {
+        const yearStr = stringDate.substr(0, 4);
+        const monthStr = stringDate.substr(4, 2);
+        const dayStr = stringDate.substr(6, 2);
+        const hoursStr = stringDate.substr(9, 2);
+        const minutesStr = stringDate.substr(11, 2);
+        const secondsStr = stringDate.substr(13, 2);
+
+        return dateWithTimeZone(
+            Number(yearStr),
+            Number(monthStr) - 1,
+            Number(dayStr),
+            Number(hoursStr),
+            Number(minutesStr),
+            Number(secondsStr),
+            timeZone
+        ).getTime();
+    }
+
+    /**
+     * Generate multi itineraries from OTP JSON
+     * @param {object} json JSON file provided by OTP.
+     * @returns {?RouterResponse}
+     */
+    createRouterResponseFromJson(json) {
+
+        if (!json || !json.journeys) {
+            return null;
+        }
+
+        const routerResponse = new RouterResponse();
+        routerResponse.routerName = this.rname;
+
+        routerResponse.from = this.getSectionCoords(json.journeys[0].sections[0]).from;
+        routerResponse.to = this.getSectionCoords(last(json.journeys[0].sections)).to;
+
+        const timeZone = json.context.timezone;
+
+        for (const jsonItinerary of json.journeys) {
+
+            const itinerary = new Itinerary();
+
+            itinerary.duration = jsonItinerary.duration;
+            itinerary.startTime = this.dateStringToTimestamp(jsonItinerary.departure_date_time, timeZone);
+            itinerary.endTime = this.dateStringToTimestamp(jsonItinerary.arrival_date_time, timeZone);
+            itinerary.from = routerResponse.from;
+            itinerary.to = routerResponse.to;
+            itinerary.distance = 0;
+
+            routerResponse.itineraries.push(itinerary);
+
+            for (const jsonSection of jsonItinerary.sections) {
+
+                if (jsonSection.type === 'waiting' || jsonSection.type === 'transfer') {
+                    continue;
+                }
+
+                const leg = new Leg();
+                let existingCoords = [];
+                const { from, to } = this.getSectionCoords(jsonSection);
+
+                leg.distance = 0;
+                leg.mode = routingModeCorrespondance.get(jsonSection.mode);
+                leg.duration = jsonSection.duration;
+                leg.startTime = this.dateStringToTimestamp(jsonSection.departure_date_time, timeZone);
+                leg.endTime = this.dateStringToTimestamp(jsonSection.arrival_date_time, timeZone);
+
+                leg.from = {
+                    name: jsonSection.from.name,
+                    coords: from
+                };
+
+                leg.to = {
+                    name: jsonSection.to.name,
+                    coords: to
+                };
+
+                // A section can have multiple same coordinates, we need to remove them
+                leg.coords = jsonSection.geojson.coordinates.reduce((acc, [lon, lat]) => {
+                    if (!existingCoords.includes(`${lon}-${lat}`)) {
+                        existingCoords = existingCoords.concat(`${lon}-${lat}`);
+                        acc.push(new Coordinates(lat, lon));
+                    }
+
+                    return acc;
+                }, []);
+
+                leg.steps = [];
+
+                if (jsonSection.path) {
+                    for (const jsonPathLink of jsonSection.path) {
+                        const step = new Step();
+
+                        step.levelChange = null;
+
+                        step.name = jsonPathLink.name;
+                        step.distance = jsonPathLink.length;
+
+                        leg.distance += step.distance;
+                        leg.steps.push(step);
+                    }
+
+                    this.findStepsCoord(leg);
+                }
+
+                if (jsonSection.type === 'public_transport') {
+                    leg.transportInfo = {
+                        name: jsonSection.display_informations.code,
+                        routeColor: jsonSection.display_informations.color,
+                        routeTextColor: jsonSection.display_informations.text_color,
+                        directionName: jsonSection.display_informations.direction
+                    };
+
+                    leg.mode = routingModeCorrespondance.get(jsonSection.display_informations.physical_mode);
+
+                    const legStep = new Step();
+                    legStep.coords = leg.coords[0];
+                    legStep._idCoordsInLeg = 0;
+                    legStep.name = leg.transportInfo.directionName;
+                    legStep.levelChange = null;
+                    legStep.distance = jsonSection.geojson.properties[0].length;
+
+                    leg.steps = [legStep];
+                }
+
+                itinerary.distance += leg.distance;
+
+                itinerary.legs.push(leg);
+
+            }
+
+            // All legs have to be parsed before computing steps metadata
+            generateStepsMetadata(itinerary);
+        }
+
+        return routerResponse;
+    }
+}
+
+export default new IdfmRemoteRouter();

package/src/{idfm/IdfmUtils.spec.js → remote/idfm/IdfmRemoteRouter.spec.js}

@@ -6,25 +6,26 @@ import { fileURLToPath } from 'url';
 
 import { Coordinates } from '@wemap/geo';
 
-import { createRouterResponseFromJson } from './IdfmUtils.js';
+import IdfmRemoteRouter from './IdfmRemoteRouter.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('IdfmUtils - createRouterResponseFromJson', () => {
+describe('IdfmRouter - createRouterResponseFromJson', () => {
 
     it('RouterResponse - 1', () => {
 
-        const filePath = path.resolve(__dirname, '../../assets/itinerary-paris-idfm.json');
+        const filePath = path.resolve(assetsPath, 'itinerary-paris-idfm.json');
         const fileString = fs.readFileSync(filePath, 'utf8');
         const json = JSON.parse(fileString);
 
-        const routerResponse = createRouterResponseFromJson(json);
-        verifyRouterResponseData(routerResponse);
+        const routerResponse = IdfmRemoteRouter.createRouterResponseFromJson(json);
+        checkRouterResponseType(routerResponse);
 
         expect(routerResponse.routerName).equal('idfm');
         expect(routerResponse.itineraries.length).equal(5);

package/src/remote/idfm/IdfmRemoteRouterTokenError.js

@@ -0,0 +1,6 @@
+export default class IdfmRemoteRouterTokenError extends Error {
+
+    constructor() {
+        super('An error occured with IDFM token request');
+    }
+}