@wemap/routers 12.8.9 → 12.8.10

package/index.ts

@@ -31,6 +31,7 @@ export { default as CustomGraphMapTester, type Report as CustomGraphMapTesterRep
 export { default as OsrmRemoteRouter } from './src/remote/osrm/OsrmRemoteRouter.js';
 export { default as OtpRemoteRouter } from './src/remote/otp/OtpRemoteRouter.js';
 export { default as CitywayRemoteRouter } from './src/remote/cityway/CitywayRemoteRouter.js';
+export { default as NavitiaRemoteRouter } from './src/remote/navitia/NavitiaRemoteRouter.js';
 export { default as DeutscheBahnRemoteRouter } from './src/remote/deutsche-bahn/DeutscheBahnRemoteRouter.js';
 export { default as IdfmRemoteRouter } from './src/remote/idfm/IdfmRemoteRouter.js';
 export { default as GeoveloRemoteRouter } from './src/remote/geovelo/GeoveloRemoteRouter.js';

package/package.json

@@ -12,7 +12,7 @@
         "directory": "packages/routers"
     },
     "name": "@wemap/routers",
-    "version": "12.8.9",
+    "version": "12.8.10",
     "bugs": {
         "url": "https://github.com/wemap/wemap-modules-js/issues"
     },
@@ -52,5 +52,5 @@
         },
         "./helpers/*": "./helpers/*"
     },
-    "gitHead": "653f93f7efb8585735ea406aac1ca96f89b4ee12"
+    "gitHead": "a9ac02840374bc97ddf8322f4f35d737ff49a379"
 }

package/src/RoutingError.ts

@@ -42,6 +42,10 @@ export class RemoteRoutingError extends RoutingError {
         return new RemoteRoutingError(StatusCode.NOT_FOUND, routerName, `Cannot found an itinerary with ${routerName}. Details: ${details}`)
     }
 
+    static missingApiKey(routerName: string, details?: string) {
+        return new RemoteRoutingError(StatusCode.UNAUTHENTICATED, routerName, `API key is missing for ${routerName}. Details: ${details}`)
+    }
+
     static unreachableServer(routerName: string, url: string) {
         return new RemoteRoutingError(StatusCode.NOT_FOUND, routerName, `Remote router server ${routerName} is unreachable. URL: ${url}`)
     }

package/src/StatusCode.ts

@@ -7,5 +7,6 @@ export enum StatusCode {
     NOT_FOUND = 5,
     UNIMPLEMENTED = 12,
     INTERNAL = 13,
-    UNAVAILABLE = 14
+    UNAVAILABLE = 14,
+    UNAUTHENTICATED = 16
 }

package/src/remote/RemoteRouterManager.ts

@@ -1,5 +1,6 @@
 import RemoteRouter from './RemoteRouter.js';
 import CitywayRemoteRouter from './cityway/CitywayRemoteRouter.js';
+import NavitiaRemoteRouter from './navitia/NavitiaRemoteRouter.js';
 import DeutscheBahnRemoteRouter from './deutsche-bahn/DeutscheBahnRemoteRouter.js';
 import IdfmRemoteRouter from './idfm/IdfmRemoteRouter.js';
 import OsrmRemoteRouter from './osrm/OsrmRemoteRouter.js';
@@ -10,6 +11,7 @@ import { RemoteRoutingError } from '../RoutingError.js';
 
 const remoteRouters = [
     CitywayRemoteRouter,
+    NavitiaRemoteRouter,
     DeutscheBahnRemoteRouter,
     IdfmRemoteRouter,
     OsrmRemoteRouter,

package/src/remote/geovelo/GeoveloRemoteRouter.spec.ts

@@ -15,7 +15,7 @@ const { expect } = chai;
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const assetsPath = path.resolve(__dirname, '../../../assets');
 
-describe.only('GeoveloRouter - parseResponse', () => {
+describe('GeoveloRouter - parseResponse', () => {
 
     it('Itineraries - 1', () => {
 

package/src/remote/navitia/NavitiaRemoteRouter.spec.ts

@@ -0,0 +1,116 @@
+/* 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 NavitiaRemoteRouter from './NavitiaRemoteRouter.js';
+import { verifyStepsCoherence } from '../../model/Itinerary.spec.js';
+import { areTransitAndTravelModeConsistent } from '../../model/TransitMode.js';
+
+const { expect } = chai;
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const assetsPath = path.resolve(__dirname, '../../../assets');
+
+describe('NavitiaRouter - parseResponse', () => {
+
+    it('Itineraries - 1', () => {
+
+        const filePath = path.resolve(assetsPath, 'itinerary-lemans-navitia.json');
+        const fileString = fs.readFileSync(filePath, 'utf8');
+        const json = JSON.parse(fileString);
+
+        const itineraries = NavitiaRemoteRouter.parseResponse(json);
+        itineraries.forEach(verifyStepsCoherence);
+
+        expect(itineraries.length).equal(5);
+
+        const itinerary1 = itineraries[0];
+        expect(itinerary1.origin.equals(new Coordinates(48.007274, 0.187574))).true;
+        expect(itinerary1.destination.equals(new Coordinates(48.005228, 0.205664))).true;
+        expect(itinerary1.distance).to.be.closeTo(1710, 1);
+        expect(itinerary1.duration).equal(1140);
+        expect(itinerary1.transitMode).equal('TRAM');
+        // Do not work because of the input time format
+        expect(itinerary1.startTime).equal(1722854691000);
+        expect(itinerary1.endTime).equal(1722855831000);
+        expect(itinerary1.legs.length).equal(3);
+
+        expect(areTransitAndTravelModeConsistent(itinerary1.transitMode, 'TRANSIT')).is.true;
+
+        const itinerary1leg1 = itinerary1.legs[0];
+        // Do not work because of the input time format
+        expect(itinerary1leg1.startTime).equal(1722854691000);
+        expect(itinerary1leg1.endTime).equal(1722854885000);
+        expect(itinerary1leg1.distance).to.be.closeTo(224, 1);
+        expect(itinerary1leg1.transitMode).equal('WALK');
+        expect(itinerary1leg1.transportInfo).is.null;
+        expect(itinerary1leg1.start.name).equal('33 Rue Saint-Pavin des Champs (Le Mans)');
+        expect(itinerary1leg1.start.coords.distanceTo(new Coordinates(48.007274, 0.187574))).to.be.closeTo(0, 1);
+        expect(itinerary1leg1.end.name).equal('Lafayette (Le Mans)');
+        expect(itinerary1leg1.end.coords.distanceTo(new Coordinates(48.006794, 0.190226))).to.be.closeTo(0, 1);
+
+        const itinerary1leg2 = itinerary1.legs[1];
+        expect(itinerary1leg2.transitMode).equal('TRAM');
+        expect(itinerary1leg2.transportInfo).is.not.null;
+        expect(itinerary1leg2.transportInfo?.name).equal('T1');
+        expect(itinerary1leg2.transportInfo?.routeColor).equal('E5261D');
+        expect(itinerary1leg2.transportInfo?.routeTextColor).equal('FFFFFF');
+        expect(itinerary1leg2.transportInfo?.directionName).equal('Antarès - Stade Marie Marvingt (Le Mans)');
+    });
+    
+    it('Itineraries - 2', () => {
+
+        const filePath = path.resolve(assetsPath, 'itinerary-lemans-navitia.json');
+        const fileString = fs.readFileSync(filePath, 'utf8');
+        const json = JSON.parse(fileString);
+
+        const itineraries = NavitiaRemoteRouter.parseResponse(json);
+        itineraries.forEach(verifyStepsCoherence);
+
+
+        const itinerary2 = itineraries[1];
+        expect(itinerary2.origin.equals(new Coordinates(48.007274, 0.187574))).true;
+        expect(itinerary2.destination.equals(new Coordinates(48.005228, 0.205664))).true;
+        expect(itinerary2.distance).to.be.closeTo(1995, 1);
+        expect(itinerary2.duration).equal(1452);
+        expect(itinerary2.transitMode).equal('MULTI');
+        // Do not work because of the input time format
+        expect(itinerary2.startTime).equal(1722854691000);
+        expect(itinerary2.endTime).equal(1722856143000);
+        expect(itinerary2.legs.length).equal(4);
+
+        expect(areTransitAndTravelModeConsistent(itinerary2.transitMode, 'TRANSIT')).is.true;
+
+        const itinerary2leg1 = itinerary2.legs[0];
+        // Do not work because of the input time format
+        expect(itinerary2leg1.startTime).equal(1722854691000);
+        expect(itinerary2leg1.endTime).equal(1722854885000);
+        expect(itinerary2leg1.distance).to.be.closeTo(224, 1);
+        expect(itinerary2leg1.transitMode).equal('WALK');
+        expect(itinerary2leg1.transportInfo).is.null;
+        expect(itinerary2leg1.start.name).equal('33 Rue Saint-Pavin des Champs (Le Mans)');
+        expect(itinerary2leg1.start.coords.distanceTo(new Coordinates(48.007274, 0.187574))).to.be.closeTo(0, 1);
+        expect(itinerary2leg1.end.name).equal('Lafayette (Le Mans)');
+        expect(itinerary2leg1.end.coords.distanceTo(new Coordinates(48.006794, 0.190226))).to.be.closeTo(0, 1);
+
+        const itinerary2leg2 = itinerary2.legs[1];
+        expect(itinerary2leg2.transitMode).equal('TRAM');
+        expect(itinerary2leg2.transportInfo).is.not.null;
+        expect(itinerary2leg2.transportInfo?.name).equal('T1');
+        expect(itinerary2leg2.transportInfo?.routeColor).equal('E5261D');
+        expect(itinerary2leg2.transportInfo?.routeTextColor).equal('FFFFFF');
+        expect(itinerary2leg2.transportInfo?.directionName).equal('Antarès - Stade Marie Marvingt (Le Mans)');
+        
+        const itinerary2leg3 = itinerary2.legs[2];
+        expect(itinerary2leg3.transitMode).equal('BUS');
+        expect(itinerary2leg3.transportInfo).is.not.null;
+        expect(itinerary2leg3.transportInfo?.name).equal('6');
+        expect(itinerary2leg3.transportInfo?.routeColor).equal('C3057F');
+        expect(itinerary2leg3.transportInfo?.routeTextColor).equal('FFFFFF');
+        expect(itinerary2leg3.transportInfo?.directionName).equal('St-Martin (Le Mans)');
+    });
+});

package/src/remote/navitia/NavitiaRemoteRouter.ts

@@ -0,0 +1,445 @@
+import { Coordinates, Utils as GeoUtils } from '@wemap/geo';
+import Logger from '@wemap/logger';
+
+import RemoteRouter from '../RemoteRouter.js';
+import Itinerary from '../../model/Itinerary.js';
+import Leg, { TransportInfo } from '../../model/Leg.js';
+import { dateWithTimeZone } from '../RemoteRouterUtils.js';
+import { TransitMode, areTransitAndTravelModeConsistent } from '../../model/TransitMode.js';
+import StepsBuilder from '../../model/StepsBuilder.js';
+import { type MinStepInfo } from '../../model/Step.js';
+import { type RouterRequest } from '../../model/RouterRequest.js';
+import { RemoteRoutingError } from '../../RoutingError.js';
+import { NavitiaJson, NavitiaCoordinates, NavitiaSection, NavitiaIntermediateStep } from './types';
+
+/**
+ * List of all modes supported by the API
+ * http://doc.navitia.io/#physical-mode
+ */
+
+const transitModeCorrespondance = new Map<string, TransitMode>();
+transitModeCorrespondance.set('Air', 'AIRPLANE');
+transitModeCorrespondance.set('Boat', 'BOAT');
+transitModeCorrespondance.set('Bus', 'BUS');
+transitModeCorrespondance.set('BusRapidTransit', 'BUS');
+transitModeCorrespondance.set('Coach', 'BUS');
+transitModeCorrespondance.set('Ferry', 'FERRY');
+transitModeCorrespondance.set('Funicular', 'FUNICULAR');
+transitModeCorrespondance.set('LocalTrain', 'TRAIN');
+transitModeCorrespondance.set('LongDistanceTrain', 'TRAIN');
+transitModeCorrespondance.set('Metro', 'METRO');
+transitModeCorrespondance.set('Métro', 'METRO');
+transitModeCorrespondance.set('RailShuttle', 'TRAIN');
+transitModeCorrespondance.set('RapidTransit', 'BUS');
+transitModeCorrespondance.set('Shuttle', 'BUS');
+transitModeCorrespondance.set('SuspendedCableCar', 'FUNICULAR');
+transitModeCorrespondance.set('Taxi', 'TAXI');
+transitModeCorrespondance.set('Train', 'TRAIN');
+transitModeCorrespondance.set('RER', 'TRAIN');
+transitModeCorrespondance.set('Tramway', 'TRAM');
+transitModeCorrespondance.set('walking', 'WALK');
+transitModeCorrespondance.set('bike', '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'
+];
+
+function jsonToCoordinates(json: NavitiaCoordinates) {
+    return new Coordinates(Number(json.lat), Number(json.lon));
+}
+
+function last<T>(array: T[]) {
+    return array[array.length - 1];
+}
+
+/**
+ * stringDate (e.g. 20211117T104516)
+ */
+function dateStringToTimestamp(stringDate: string, timeZone: string) {
+    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();
+}
+
+// The api key should be defined in the routingurl as api_key=XXXXXXXX
+
+/**
+ * Singleton.
+ */
+class NavitiaRemoteRouter extends RemoteRouter {
+
+    get rname() { return 'navitia' as const; }
+
+    async getItineraries(endpointUrl: string, routerRequest: RouterRequest) {
+        const url = this.getURL(endpointUrl, routerRequest);
+
+        // The api key should be defined in the routingurl as api_key=XXXXXXXX
+        const api_key = url.searchParams.get('api_key');
+        if (!api_key) {
+            throw RemoteRoutingError.missingApiKey(this.rname);
+        }
+
+        const res = await (fetch(url, {
+            method: 'GET',
+            headers: { 
+                'Authorization': api_key,
+             }
+        }).catch(() => {
+            throw RemoteRoutingError.unreachableServer(this.rname, url.toString());
+        }));
+
+
+        const jsonResponse: NavitiaJson = await res.json().catch(() => {
+            throw RemoteRoutingError.responseNotParsing(this.rname, url.toString());
+        });
+
+        // When Navitia failed to calculate an itinerary (ie. start or end
+        // point is far from network), it respond a 404 with an error message
+        // or a 200 with an error message
+        if (jsonResponse && jsonResponse.error) {
+            throw RemoteRoutingError.notFound(this.rname, jsonResponse.error.message);
+        }
+
+        const itineraries = this.parseResponse(jsonResponse);
+
+        const sameModeFound = itineraries.some((itinerary) => areTransitAndTravelModeConsistent(itinerary.transitMode, routerRequest.travelMode));
+
+        if (!sameModeFound) {
+            throw RemoteRoutingError.notFound(
+                this.rname,
+                'Selected mode of transport was not found for this itinerary.'
+            )
+        }
+
+        return itineraries;
+    }
+
+    getURL(endpointUrl: string, routerRequest: RouterRequest) {
+        const { origin, destination, waypoints, travelMode } = routerRequest;
+
+        if ((waypoints || []).length > 0) {
+            Logger.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints?.length})`);
+        }
+
+        const url = new URL(endpointUrl);
+
+        const coreParams = new URLSearchParams();
+        coreParams.set('from', `${origin.longitude};${origin.latitude}`);
+        coreParams.set('to', `${destination.longitude};${destination.latitude}`);
+        coreParams.set('data_freshness', 'realtime');
+
+        if (routerRequest.itineraryModifiers?.avoidStairs) {
+            coreParams.set('wheelchair', 'true')
+        }
+
+        let queryParams: URLSearchParams = new URLSearchParams();
+        switch (travelMode) {
+            case 'WALK':
+                queryParams = this.getWalkingQuery();
+                break;
+            case 'BIKE':
+                queryParams = this.getBikeQuery();
+                break;
+            case 'CAR':
+                queryParams = this.getCarQuery();
+                break;
+            default:
+                break;
+        }
+
+        [coreParams, queryParams].map(params => {
+            for (const pair of params.entries()) {
+                url.searchParams.append(pair[0], pair[1]);
+            }
+        });
+
+        return url;
+    }
+
+    getCarQuery() {
+        const urlSearchParams = new URLSearchParams();
+
+        TRANSPORT_IDS.forEach((id) => {
+            urlSearchParams.append('forbidden_uris[]', id);
+        });
+
+        urlSearchParams.append('first_section_mode[]', 'walking');
+        urlSearchParams.append('first_section_mode[]', 'car');
+        urlSearchParams.append('last_section_mode[]', 'walking');
+        urlSearchParams.append('last_section_mode[]', 'car');
+
+        return urlSearchParams;
+    }
+
+    getWalkingQuery() {
+        const urlSearchParams = new URLSearchParams();
+
+        TRANSPORT_IDS.forEach((id) => {
+            urlSearchParams.append('forbidden_uris[]', id);
+        });
+
+        urlSearchParams.append('first_section_mode[]', 'walking');
+        urlSearchParams.append('last_section_mode[]', 'walking');
+
+        return urlSearchParams;
+    }
+
+    getBikeQuery() {
+        const urlSearchParams = new URLSearchParams();
+
+        TRANSPORT_IDS.forEach((id) => {
+            urlSearchParams.append('forbidden_uris[]', id);
+        });
+
+        urlSearchParams.append('first_section_mode[]', 'bike');
+        urlSearchParams.append('last_section_mode[]', 'bike');
+
+        return urlSearchParams;
+    }
+
+
+    getSectionCoords(section: NavitiaSection) {
+        let from: NavitiaCoordinates | undefined;
+        let to: NavitiaCoordinates | undefined;
+
+        if ('stop_point' in section.from) {
+            from = section.from.stop_point.coord;
+        } else if ('address' in section.from) {
+            from = section.from.address.coord;
+        } else {
+            from = section.from.poi.coord;
+        }
+
+        if ('stop_point' in section.to) {
+            to = section.to.stop_point.coord;
+        } else if ('address' in section.to) {
+            to = section.to.address.coord;
+        } else {
+            to = section.to.poi.coord;
+        }
+
+        return {
+            from: jsonToCoordinates(from),
+            to: jsonToCoordinates(to)
+        };
+    }
+
+    /**
+     * Since the navitia 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(legCoords: Coordinates[], steps: NavitiaIntermediateStep[]) {
+        const coords = legCoords;
+
+        const duplicatedCoords = [...coords];
+        let previousStep = steps[0];
+        let accumulatedIndex = 0;
+        const outputSteps = [];
+
+        for (const [idx, step] of steps.entries()) {
+            let newCoords: Coordinates;
+
+            let _idCoordsInLeg;
+
+            if (idx === 0) {
+                _idCoordsInLeg = 0;
+                newCoords = coords[0];
+            } else if (idx === steps.length - 1) {
+                _idCoordsInLeg = coords.length - 1;
+                newCoords = last(coords);
+            } else if (duplicatedCoords.length === 1) {
+                accumulatedIndex++;
+
+                _idCoordsInLeg = accumulatedIndex;
+
+                newCoords = duplicatedCoords[0];
+
+                coords[_idCoordsInLeg] = newCoords;
+            } else {
+                const result = GeoUtils.trimRoute(duplicatedCoords, duplicatedCoords[0], previousStep.distance);
+                accumulatedIndex += result.length - 1;
+
+                duplicatedCoords.splice(0, result.length - 1);
+
+                _idCoordsInLeg = accumulatedIndex;
+
+                newCoords = last(result);
+
+                coords[_idCoordsInLeg] = newCoords;
+            }
+
+            outputSteps.push({
+                ...step,
+                coords: newCoords
+            });
+
+            previousStep = step;
+        }
+
+        return outputSteps;
+    }
+
+    findStepCoords(step: NavitiaSection['path'][number], section: NavitiaSection) {
+        if ('instruction_start_coordinate' in step) {
+            return jsonToCoordinates(step.instruction_start_coordinate);
+        }
+
+        const via = section.vias?.find(via => via.id === step.via_uri);
+        if (via) {
+            return jsonToCoordinates(via.access_point.coord);
+        }
+    }
+
+    parseResponse(json: NavitiaJson) {
+
+        if (!json || !json.journeys) {
+            throw RemoteRoutingError.notFound(this.rname, json.error?.message);
+        }
+
+        const itineraries = [];
+
+        const timeZone = json.context.timezone;
+
+        for (const jsonItinerary of json.journeys) {
+
+            const legs = [];
+
+            for (const jsonSection of jsonItinerary.sections) {
+
+                if (jsonSection.type === 'waiting' || jsonSection.type === 'transfer') {
+                    continue;
+                }
+
+                const { from: startSection, to: endSection } = this.getSectionCoords(jsonSection);
+
+                // A section can have multiple same coordinates, we need to remove them
+                let existingCoords: string[] = [];
+                const legCoords = 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;
+                }, [] as Coordinates[]);
+
+                const stepsBuilder = new StepsBuilder().setStart(startSection).setEnd(endSection).setPathCoords(legCoords);
+                let transportInfo: TransportInfo | undefined;
+                let transitMode = transitModeCorrespondance.get(jsonSection.mode) as TransitMode;
+
+                if (jsonSection.path) {
+                    const useNavitiaSteps = jsonSection.path.every(step => 'instruction_start_coordinate' in step || step.via_uri);
+                    const navitiaIntermediateSteps = [];
+
+                    for (const jsonPathLink of jsonSection.path) {
+                        let coords: Coordinates;
+                        if (useNavitiaSteps) {
+                            coords = this.findStepCoords(jsonPathLink, jsonSection)!;
+
+                            const intermediateStep = {
+                                name: jsonPathLink.name,
+                                distance: jsonPathLink.length,
+                                coords
+                            };
+
+                            stepsBuilder.addStepInfo(intermediateStep);
+                        } else {
+                            navitiaIntermediateSteps.push({
+                                name: jsonPathLink.name,
+                                distance: jsonPathLink.length,
+                            });
+                        }
+                    }
+
+                    if (!useNavitiaSteps) {
+                        stepsBuilder.setStepsInfo(this.findStepsCoord(legCoords, navitiaIntermediateSteps));
+                    }
+                }
+
+                if (jsonSection.type === 'public_transport') {
+                    transportInfo = {
+                        name: jsonSection.display_informations.code,
+                        routeColor: jsonSection.display_informations.color,
+                        routeTextColor: jsonSection.display_informations.text_color,
+                        directionName: jsonSection.display_informations.direction
+                    };
+
+                    transitMode = transitModeCorrespondance.get(jsonSection.display_informations.physical_mode) as TransitMode;
+
+                    const legStep: MinStepInfo = {
+                        coords: legCoords[0],
+                        name: transportInfo.directionName,
+                        distance: jsonSection.geojson.properties[0].length
+                    };
+                    stepsBuilder.setStepsInfo([legStep]);
+                }
+
+                const leg = new Leg({
+                    transitMode,
+                    duration: jsonSection.duration,
+                    startTime: dateStringToTimestamp(jsonSection.departure_date_time, timeZone),
+                    endTime: dateStringToTimestamp(jsonSection.arrival_date_time, timeZone),
+                    start: {
+                        name: jsonSection.from.name,
+                        coords: startSection
+                    },
+                    end: {
+                        name: jsonSection.to.name,
+                        coords: endSection
+                    },
+                    coords: legCoords,
+                    transportInfo,
+                    steps: stepsBuilder.build()
+                });
+                legs.push(leg);
+            }
+
+            const itinerary = new Itinerary({
+                duration: jsonItinerary.duration,
+                startTime: dateStringToTimestamp(jsonItinerary.departure_date_time, timeZone),
+                endTime: dateStringToTimestamp(jsonItinerary.arrival_date_time, timeZone),
+                origin: this.getSectionCoords(jsonItinerary.sections[0]).from,
+                destination: this.getSectionCoords(last(jsonItinerary.sections)).to,
+                legs
+            });
+
+            itineraries.push(itinerary);
+        }
+
+        return itineraries;
+    }
+}
+
+export default new NavitiaRemoteRouter();