@wemap/routers 6.0.2 → 6.2.1

package/src/idfm/IdfmUtils.js

@@ -0,0 +1,247 @@
+/* eslint-disable max-statements */
+import { Coordinates, Utils as GeoUtils } from '@wemap/geo';
+
+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 '../Utils.js';
+import Constants from '../Constants.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('Tramway', Constants.ROUTING_MODE.TRAM);
+routingModeCorrespondance.set('walking', Constants.ROUTING_MODE.WALK);
+routingModeCorrespondance.set('bike', Constants.ROUTING_MODE.BIKE);
+
+/**
+ * @param {object} json
+ * @returns {Coordinates}
+ */
+export function jsonToCoordinates(json) {
+    return new Coordinates(Number(json.lat), Number(json.lon));
+}
+
+function getSectionCoords(section) {
+    const from = section.from.stop_point ? jsonToCoordinates(section.from.stop_point.coord) : jsonToCoordinates(section.from.address.coord);
+    const to = section.to.stop_point ? jsonToCoordinates(section.to.stop_point.coord) : jsonToCoordinates(section.to.address.coord);
+
+    return {
+        from,
+        to
+    };
+}
+
+/**
+ * Get last item of a given array
+ * @param {Array} array
+ * @returns {any}
+ */
+function last(array) {
+    return array[array.length - 1];
+}
+
+/**
+ * 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
+ */
+function 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 {
+            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}
+ */
+function 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}
+ */
+export function createRouterResponseFromJson(json) {
+
+    if (!json || !json.journeys) {
+        return null;
+    }
+
+    const routerResponse = new RouterResponse();
+    routerResponse.routerName = 'idfm';
+
+    routerResponse.from = getSectionCoords(json.journeys[0].sections[0]).from;
+    routerResponse.to = 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 = dateStringToTimestamp(jsonItinerary.departure_date_time, timeZone);
+        itinerary.endTime = 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 } = getSectionCoords(jsonSection);
+
+            leg.distance = 0;
+            leg.mode = routingModeCorrespondance.get(jsonSection.mode);
+            leg.duration = jsonSection.duration;
+            leg.startTime = dateStringToTimestamp(jsonSection.departure_date_time, timeZone);
+            leg.endTime = 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);
+                }
+
+                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;
+}
+
+

package/src/idfm/IdfmUtils.spec.js

@@ -0,0 +1,64 @@
+/* eslint-disable max-statements */
+import chai from 'chai';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import { Coordinates } from '@wemap/geo';
+
+import { createRouterResponseFromJson } from './IdfmUtils.js';
+
+import { verifyRouterResponseData } from '../model/RouterResponse.type.spec.js';
+
+
+const { expect } = chai;
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+describe('IdfmUtils - createRouterResponseFromJson', () => {
+
+    it('RouterResponse - 1', () => {
+
+        const filePath = path.resolve(__dirname, '../../assets/itinerary-paris-idfm.json');
+        const fileString = fs.readFileSync(filePath, 'utf8');
+        const json = JSON.parse(fileString);
+
+        const routerResponse = createRouterResponseFromJson(json);
+        verifyRouterResponseData(routerResponse);
+
+        expect(routerResponse.routerName).equal('idfm');
+        expect(routerResponse.itineraries.length).equal(5);
+        expect(routerResponse.from.equalsTo(new Coordinates(48.875877, 2.301357))).true;
+        expect(routerResponse.to.equalsTo(new Coordinates(48.877877, 2.351929))).true;
+
+        const itinerary1 = routerResponse.itineraries[0];
+        expect(itinerary1.distance).to.be.closeTo(1242, 1);
+        expect(itinerary1.duration).equal(1842);
+        expect(itinerary1.mode).equal('PT');
+        // Do not work because of the input time format
+        expect(itinerary1.startTime).equal(1637596640000);
+        expect(itinerary1.endTime).equal(1637598482000);
+        expect(itinerary1.legs.length).equal(3);
+
+        const itinerary1leg1 = itinerary1.legs[0];
+        // Do not work because of the input time format
+        expect(itinerary1leg1.startTime).equal(1637596640000);
+        expect(itinerary1leg1.endTime).equal(1637597040000);
+        expect(itinerary1leg1.distance).to.be.closeTo(468, 1);
+        expect(itinerary1leg1.mode).equal('WALK');
+        expect(itinerary1leg1.transportInfo).is.null;
+        expect(itinerary1leg1.from.name).equal('8 Avenue Bertie Albrecht (Paris)');
+        expect(itinerary1leg1.from.coords.equalsTo(new Coordinates(48.875877, 2.301357))).true;
+        expect(itinerary1leg1.to.name).equal('Ternes (Paris)');
+        expect(itinerary1leg1.to.coords.equalsTo(new Coordinates(48.878228, 2.298113))).true;
+
+        const itinerary1leg2 = itinerary1.legs[1];
+        expect(itinerary1leg2.mode).equal('METRO');
+        expect(itinerary1leg2.transportInfo).is.not.null;
+        expect(itinerary1leg2.transportInfo.name).equal('2');
+        expect(itinerary1leg2.transportInfo.routeColor).equal('003CA6');
+        expect(itinerary1leg2.transportInfo.routeTextColor).equal('FFFFFF');
+        expect(itinerary1leg2.transportInfo.directionName).equal('Nation (Paris)');
+    });
+});
+

package/src/model/Itinerary.js

@@ -2,6 +2,7 @@
 import { Coordinates, Network } from '@wemap/geo';
 import Leg from './Leg.js';
 import Step from './Step.js';
+import Constants from '../Constants.js';
 import { getDurationFromLength } from '../Utils.js';
 
 /**
@@ -78,9 +79,9 @@ class Itinerary {
             let isDriving;
 
             this.legs.forEach((leg) => {
-                isPublicTransport = isPublicTransport || ['BUS', 'FUNICULAR', 'TRAM', 'TRAIN'].includes(leg.mode);
-                isBicycle = isBicycle || ['BIKE', 'BICYCLE'].includes(leg.mode);
-                isDriving = isDriving || leg.mode === 'CAR';
+                isPublicTransport = isPublicTransport || Constants.PUBLIC_TRANSPORT.includes(leg.mode);
+                isBicycle = isBicycle || leg.mode === Constants.ROUTING_MODE.BIKE;
+                isDriving = isDriving || leg.mode === Constants.ROUTING_MODE.CAR;
             });
 
             if (isPublicTransport) {

package/src/model/Leg.js

@@ -1,10 +1,11 @@
 import { Coordinates, Network } from '@wemap/geo';
 
 import Step from './Step.js';
+import Constants from '../Constants.js';
 
 class Leg {
 
-    /** @type {!string} can be WALK, BIKE, BUS, TRAM, CAR, FUNICULAR */
+    /** @type {!string} can be values in Constants.ROUTING_MODE */
     mode;
 
     /** @type {!number} */
@@ -34,6 +35,10 @@ class Leg {
     /** @type {?(Step[])} */
     steps = null;
 
+    isPublicTransport() {
+        return Constants.PUBLIC_TRANSPORT.includes(this.mode);
+    }
+
     /**
      * @returns {Network}
      */