@wemap/routers 6.2.2 → 7.0.0

package/src/model/Step.type.spec.js

@@ -0,0 +1,52 @@
+import chai from 'chai';
+
+import { Coordinates } from '@wemap/geo';
+
+import LevelChange from './LevelChange.js';
+import Step from './Step.js';
+import checkLevelChangeType from './LevelChange.type.spec.js';
+
+const { expect } = chai;
+
+
+const isNullOrNumber = val => val === null || typeof val === 'number';
+const isNullOrString = val => val === null || typeof val === 'string';
+const isNullOrObject = val => val === null || typeof val === 'object';
+const isNullOrLevelChange = val => val === null || val instanceof LevelChange;
+
+const isUndefinedOrBoolean = val => typeof val === 'undefined' || typeof val === 'boolean';
+const isUndefinedOrString = val => typeof val === 'undefined' || typeof val === 'string';
+
+const stepExtraProperties = ['subwayEntrance', 'subwayEntranceRef'];
+
+/**
+ * @param {Step} step
+ */
+export default function checkStepType(step) {
+
+    expect(step).instanceOf(Step);
+    expect(step.firstStep).be.a('boolean');
+    expect(step.lastStep).be.a('boolean');
+    expect(step.number).be.a('number');
+    expect(step.coords).instanceOf(Coordinates);
+    expect(step.angle).be.a('number');
+    expect(step.previousBearing).be.a('number');
+    expect(step.nextBearing).be.a('number');
+    expect(step.distance).be.a('number');
+    expect(step.duration).satisfies(isNullOrNumber);
+    expect(step.name).satisfies(isNullOrString);
+    expect(step.levelChange).satisfies(isNullOrLevelChange);
+    if (step.levelChange) {
+        checkLevelChangeType(step.levelChange);
+    }
+    expect(step._idCoordsInLeg).be.a('number');
+
+    expect(step.extras).satisfies(isNullOrObject);
+    if (step.extras !== null) {
+        for (const key of Object.keys(step.extras)) {
+            expect(stepExtraProperties).includes(key);
+        }
+        expect(step.extras.subwayEntrance).satisfies(isUndefinedOrBoolean);
+        expect(step.extras.subwayEntranceRef).satisfies(isUndefinedOrString);
+    }
+}

package/src/remote/RemoteRouter.js

@@ -0,0 +1,31 @@
+import { Coordinates } from '@wemap/geo';
+
+import RouterResponse from '../model/RouterResponse.js';
+import RemoteRouterOptions from './RemoteRouterOptions.js';
+
+class RemoteRouter {
+
+    /**
+     * Get the router name
+     * @type {string} the router name
+     */
+    get rname() {
+        return 'Unknown';
+    }
+
+    /**
+     * @abstract
+     * @param {string} endpointUrl
+     * @param {string} mode see Constants.ROUTING_MODE
+     * @param {Array<Coordinates>} waypoints
+     * @param {RemoteRouterOptions} options
+     * @returns {!RouterResponse}
+     */
+    // eslint-disable-next-line no-unused-vars
+    async getItineraries(endpointUrl, mode, waypoints, options = new RemoteRouterOptions()) {
+        throw new Error('RemoteRouter "' + this.rname + '" does not @override getItineraries()');
+    }
+
+}
+
+export default RemoteRouter;

package/src/remote/RemoteRouterManager.js

@@ -0,0 +1,84 @@
+import { Coordinates } from '@wemap/geo';
+
+import RouterResponse from '../model/RouterResponse.js';
+import RemoteRouter from './RemoteRouter.js';
+import CitywayRemoteRouter from './cityway/CitywayRemoteRouter.js';
+import DeutscheBahnRemoteRouter from './deutsche-bahn/DeutscheBahnRemoteRouter.js';
+import IdfmRemoteRouter from './idfm/IdfmRemoteRouter.js';
+import OsrmRemoteRouter from './osrm/OsrmRemoteRouter.js';
+import OtpRemoteRouter from './otp/OtpRemoteRouter.js';
+import RemoteRouterOptions from './RemoteRouterOptions.js';
+import RemoteRouterServerUnreachable from './RemoteRouterServerUnreachable.js';
+import RoutingModeCorrespondanceNotFound from './RoutingModeCorrespondanceNotFound.js';
+import IdfmRemoteRouterTokenError from './idfm/IdfmRemoteRouterTokenError.js';
+
+/**
+ * Singleton
+ */
+class RemoteRouterManager {
+
+    /** @type {RemoteRouter[]} */
+    remoteRouters = [
+        CitywayRemoteRouter,
+        DeutscheBahnRemoteRouter,
+        IdfmRemoteRouter,
+        OsrmRemoteRouter,
+        OtpRemoteRouter
+    ];
+
+    /**
+     * @param {string} name
+     * @returns {RemoteRouter}
+     */
+    getRouterByName(name) {
+        return this.remoteRouters.find(remoteRouter => remoteRouter.rname === name);
+    }
+
+    /**
+     * @param {!string} endpointUrl
+     * @param {!string} mode see Constants.ROUTING_MODE
+     * @param {Array<Coordinates>} waypoints
+     * @param {?RemoteRouterOptions} options
+     * @returns {!RouterResponse}
+     * @throws {RemoteRouterServerUnreachable}
+     * @throws {RoutingModeCorrespondanceNotFound}
+     * @throws {IdfmRemoteRouterTokenError}
+     */
+    async getItineraries(name, endpointUrl, mode, waypoints, options = new RemoteRouterOptions()) {
+        const router = this.getRouterByName(name);
+        if (!router) {
+            throw new Error(`Unknown "${this.rname}" remote router`);
+        }
+        return router.getItineraries(endpointUrl, mode, waypoints, options);
+    }
+
+
+    /**
+     * @param {!{name: string, endpointUrl: string}[]} remoteRouters
+     * @param {!string} mode see Constants.ROUTING_MODE
+     * @param {!Array<Coordinates>} waypoints
+     * @param {?RemoteRouterOptions} options
+     * @returns {!RouterResponse}
+     * @throws {RemoteRouterServerUnreachable}
+     * @throws {RoutingModeCorrespondanceNotFound}
+     * @throws {IdfmRemoteRouterTokenError}
+     */
+    async getItinerariesWithFallback(remoteRouters, mode, waypoints, options = new RemoteRouterOptions()) {
+        let routerResponse;
+        for (const { name, endpointUrl } of remoteRouters) {
+            routerResponse = await this.getItineraries(name, endpointUrl, mode, waypoints, options);
+            if (routerResponse.itineraries.length) {
+                return routerResponse;
+            }
+        }
+        if (!routerResponse) {
+            routerResponse = new RouterResponse();
+            routerResponse.from = waypoints[0];
+            routerResponse.to = waypoints[waypoints.length];
+        }
+        return routerResponse;
+    }
+
+}
+
+export default new RemoteRouterManager();

package/src/remote/RemoteRouterOptions.js

@@ -0,0 +1,25 @@
+class RemoteRouterOptions {
+
+    /** @type {boolean} */
+    useStairs = true;
+
+    /**
+     * @returns {object}
+     */
+    toJson() {
+        return { useStairs: this.useStairs };
+    }
+
+    /**
+     * @param {object}
+     * @returns {RemoteRouterOptions}
+     */
+    static fromJson(json) {
+        const obj = new RemoteRouterOptions();
+        obj.useStairs = json.useStairs;
+        return obj;
+    }
+
+}
+
+export default RemoteRouterOptions;

package/src/remote/RemoteRouterServerUnreachable.js

@@ -0,0 +1,10 @@
+export default class RemoteRouterServerUnreachable extends Error {
+
+    /**
+     * @param {!string} name
+     * @param {!string} endpointUrl
+     */
+    constructor(name, endpointUrl) {
+        super(`Remote router server ${name} is unreachable. URL: ${endpointUrl}`);
+    }
+}

package/src/remote/RemoteRouterUtils.js

@@ -0,0 +1,78 @@
+import { diffAngle } from '@wemap/maths';
+
+import Itinerary from '../model/Itinerary.js';
+
+
+/**
+ * @param {Itinerary} itinerary
+ */
+export function generateStepsMetadata(itinerary) {
+
+    let counter = 1;
+
+    itinerary.legs.forEach((leg, legId) => {
+        leg.steps.forEach((step, stepId) => {
+
+            if (counter === 1) {
+                step.firstStep = true;
+            }
+            if (legId === itinerary.legs.length - 1
+                && stepId === leg.steps.length - 1) {
+                step.lastStep = true;
+            }
+
+            step.number = counter++;
+
+
+            /*
+             * Generate previousBearing, nextBearing and angle
+             */
+
+            let coordsBeforeStep;
+            if (step._idCoordsInLeg > 0) {
+                coordsBeforeStep = leg.coords[step._idCoordsInLeg - 1];
+            } else if (legId === 0) {
+                coordsBeforeStep = itinerary.from;
+            } else {
+                coordsBeforeStep = itinerary.legs[legId - 1].to.coords;
+            }
+
+            let coordsAfterStep;
+            if (step._idCoordsInLeg !== leg.coords.length - 1) {
+                coordsAfterStep = leg.coords[step._idCoordsInLeg + 1];
+            } else if (legId === itinerary.legs.length - 1) {
+                coordsAfterStep = itinerary.to;
+            } else {
+                coordsAfterStep = itinerary.legs[legId + 1].from.coords;
+            }
+
+            step.previousBearing = coordsBeforeStep.bearingTo(step.coords);
+            step.nextBearing = step.coords.bearingTo(coordsAfterStep);
+            step.angle = diffAngle(step.previousBearing, step.nextBearing + Math.PI);
+
+        });
+    });
+}
+
+
+/**
+ * Create and return a date with a given timezone
+ * @param {number} year
+ * @param {number} month
+ * @param {number} day
+ * @param {number} hours
+ * @param {number} minutes
+ * @param {number} seconds
+ * @param {string} timeZone - timezone name (e.g. 'Europe/Paris')
+ */
+export function dateWithTimeZone(year, month, day, hour, minute, second, timeZone = 'Europe/Paris') {
+    const date = new Date(Date.UTC(year, month, day, hour, minute, second));
+
+    const utcDate = new Date(date.toLocaleString('en-US', { timeZone: 'UTC' }));
+    const tzDate = new Date(date.toLocaleString('en-US', { timeZone: timeZone }));
+    const offset = utcDate.getTime() - tzDate.getTime();
+
+    date.setTime(date.getTime() + offset);
+
+    return date;
+}

package/src/remote/RoutingModeCorrespondanceNotFound.js

@@ -0,0 +1,18 @@
+export default class RoutingModeCorrespondanceNotFound extends Error {
+
+    /** @type {!string} */
+    routerName;
+
+    /** @type {!string} */
+    routingMode;
+
+    /**
+     * @param {!string} routerName
+     * @param {!string} routingMode
+     */
+    constructor(routerName, routingMode) {
+        this.routerName = routerName;
+        this.routingMode = routingMode;
+        super(`routing mode "${routingMode}" correspondance not found for router "${routerName}"`);
+    }
+}

package/src/remote/cityway/CitywayRemoteRouter.js

@@ -0,0 +1,386 @@
+/* eslint-disable max-depth */
+/* eslint-disable max-statements */
+import { Coordinates } from '@wemap/geo';
+import Logger from '@wemap/logger';
+
+import RemoteRouter from '../RemoteRouter.js';
+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 RemoteRouterServerUnreachable from '../RemoteRouterServerUnreachable.js';
+import RoutingModeCorrespondanceNotFound from '../RoutingModeCorrespondanceNotFound.js';
+
+/**
+ * Input mode correspondance
+ */
+const inputModeCorrespondance = new Map();
+inputModeCorrespondance.set(Constants.ROUTING_MODE.CAR, 'Car');
+inputModeCorrespondance.set(Constants.ROUTING_MODE.WALK, 'Walk');
+inputModeCorrespondance.set(Constants.ROUTING_MODE.BIKE, 'Bike');
+inputModeCorrespondance.set(Constants.ROUTING_MODE.BUS, 'PT');
+inputModeCorrespondance.set(Constants.ROUTING_MODE.MULTI, 'PT');
+
+
+/**
+ * List of all routing modes supported by the API
+ */
+const routingModeCorrespondance = new Map();
+routingModeCorrespondance.set('WALK', Constants.ROUTING_MODE.WALK);
+routingModeCorrespondance.set('BICYCLE', Constants.ROUTING_MODE.BIKE);
+routingModeCorrespondance.set('TRAMWAY', Constants.ROUTING_MODE.TRAM);
+routingModeCorrespondance.set('METRO', Constants.ROUTING_MODE.METRO);
+routingModeCorrespondance.set('FUNICULAR', Constants.ROUTING_MODE.FUNICULAR);
+routingModeCorrespondance.set('BUS', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('COACH', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('SCHOOL', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('BUS_PMR', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('MINIBUS', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('TROLLEY_BUS', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('TAXIBUS', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('SHUTTLE', Constants.ROUTING_MODE.BUS);
+routingModeCorrespondance.set('TRAIN', Constants.ROUTING_MODE.TRAIN);
+routingModeCorrespondance.set('HST', Constants.ROUTING_MODE.TRAIN);
+routingModeCorrespondance.set('LOCAL_TRAIN', Constants.ROUTING_MODE.TRAIN);
+routingModeCorrespondance.set('AIR', Constants.ROUTING_MODE.AIRPLANE);
+routingModeCorrespondance.set('FERRY', Constants.ROUTING_MODE.BOAT);
+routingModeCorrespondance.set('TAXI', Constants.ROUTING_MODE.UNKNOWN);
+routingModeCorrespondance.set('CAR_POOL', Constants.ROUTING_MODE.UNKNOWN);
+routingModeCorrespondance.set('PRIVATE_VEHICLE', Constants.ROUTING_MODE.CAR);
+routingModeCorrespondance.set('SCOOTER', Constants.ROUTING_MODE.MOTO);
+
+/**
+ * List of all plan trip supported by the API
+ * Routing mode UNKNOWN means that the itinerary will not be parsed by the router
+ */
+const planTripType = new Map();
+planTripType.set(0, Constants.ROUTING_MODE.BUS);
+planTripType.set(1, Constants.ROUTING_MODE.WALK);
+planTripType.set(2, Constants.ROUTING_MODE.BIKE);
+planTripType.set(3, Constants.ROUTING_MODE.CAR);
+planTripType.set(4, Constants.ROUTING_MODE.UNKNOWN);
+planTripType.set(5, Constants.ROUTING_MODE.UNKNOWN);
+planTripType.set(6, Constants.ROUTING_MODE.UNKNOWN);
+planTripType.set(7, Constants.ROUTING_MODE.UNKNOWN);
+planTripType.set(8, Constants.ROUTING_MODE.UNKNOWN);
+planTripType.set(9, Constants.ROUTING_MODE.UNKNOWN);
+planTripType.set(10, Constants.ROUTING_MODE.UNKNOWN);
+planTripType.set(11, Constants.ROUTING_MODE.UNKNOWN);
+planTripType.set(12, Constants.ROUTING_MODE.UNKNOWN);
+planTripType.set(13, Constants.ROUTING_MODE.UNKNOWN);
+planTripType.set(14, Constants.ROUTING_MODE.UNKNOWN);
+
+
+/**
+ * Singleton.
+ */
+class CitywayRemoteRouter extends RemoteRouter {
+
+    /**
+     * @override
+     */
+    get rname() {
+        return 'cityway';
+    }
+
+
+    /**
+     * @override
+     * @throws {RoutingModeCorrespondanceNotFound}
+     * @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);
+    }
+
+
+    /**
+     * @param {string} endpointUrl
+     * @param {string} mode
+     * @param {Array<Coordinates>} waypoints
+     * @throws {RoutingModeCorrespondanceNotFound}
+     */
+    getURL(endpointUrl, mode, waypoints) {
+        const citywayMode = inputModeCorrespondance.get(mode);
+        if (!citywayMode) {
+            throw new RoutingModeCorrespondanceNotFound(this.rname, mode);
+        }
+        if (waypoints.length > 2) {
+            Logger.warn(`${this.rname} router uses only the first 2 waypoints (asked ${waypoints.length})`);
+        }
+        const fromPlace = `DepartureLatitude=${waypoints[0].latitude}&DepartureLongitude=${waypoints[0].longitude}`;
+        const toPlace = `ArrivalLatitude=${waypoints[1].latitude}&ArrivalLongitude=${waypoints[1].longitude}`;
+        const queryMode = `TripModes=${citywayMode}`;
+
+        const url = new URL(endpointUrl);
+        let { search } = url;
+        search = (search ? `${search}&` : '?') + `${fromPlace}&${toPlace}&${queryMode}`;
+
+        return `${url.origin}${url.pathname}${search}`;
+    }
+
+    /**
+     * Generate multi itineraries from Cityway JSON
+     * @param {object} json JSON file provided by Cityway.
+     * @returns {?RouterResponse}
+     * @example https://preprod.api.lia2.cityway.fr/journeyplanner/api/opt/PlanTrips/json?DepartureLatitude=49.51509388236216&DepartureLongitude=0.09341749619366316&ArrivalLatitude=49.5067090188444&ArrivalLongitude=0.1694842115417831&DepartureType=COORDINATES&ArrivalType=COORDINATES
+     */
+    createRouterResponseFromJson(json) {
+
+        if (json.StatusCode !== 200 || !json.Data || !json.Data.length) {
+            return null;
+        }
+
+        const routerResponse = new RouterResponse();
+        routerResponse.routerName = this.rname;
+
+
+        // Do not know if it the best approach, but it works...
+        const allJsonTrips = json.Data.reduce((acc, dataObj) => {
+            acc.push(...dataObj.response.trips.Trip.map(trip => ({
+                ...trip,
+                ...(dataObj.hasOwnProperty('PlanTripType') ? { PlanTripType: dataObj.PlanTripType } : {})
+            })));
+            return acc;
+        }, []);
+
+        // eslint-disable-next-line no-labels
+        itineraryLoop:
+        for (const trip of allJsonTrips) {
+
+            if (trip.hasOwnProperty('PlanTripType') && planTripType.get(trip.PlanTripType) === Constants.ROUTING_MODE.UNKNOWN) {
+                continue;
+            }
+
+            const itinerary = new Itinerary();
+
+            itinerary.duration = this.parseDuration(trip.Duration);
+            itinerary.startTime = this.jsonDateToTimestamp(trip.Departure.Time);
+            itinerary.from = this.jsonToCoordinates(trip.Departure.Site.Position);
+            itinerary.endTime = this.jsonDateToTimestamp(trip.Arrival.Time);
+            itinerary.to = this.jsonToCoordinates(trip.Arrival.Site.Position);
+
+            for (const jsonSection of trip.sections.Section) {
+
+                const jsonLeg = jsonSection.Leg ? jsonSection.Leg : jsonSection.PTRide;
+
+                const leg = new Leg();
+
+                leg.mode = routingModeCorrespondance.get(jsonLeg.TransportMode);
+                leg.duration = this.parseDuration(jsonLeg.Duration);
+                leg.startTime = this.jsonDateToTimestamp(jsonLeg.Departure.Time);
+                leg.endTime = this.jsonDateToTimestamp(jsonLeg.Arrival.Time);
+                leg.coords = [];
+
+                if (leg.mode === Constants.ROUTING_MODE.UNKNOWN) {
+                    // eslint-disable-next-line
+                    continue itineraryLoop;
+                }
+
+                if (leg.mode === Constants.ROUTING_MODE.WALK
+                    || leg.mode === Constants.ROUTING_MODE.BIKE
+                    || leg.mode === Constants.ROUTING_MODE.CAR) {
+
+                    leg.from = {
+                        name: jsonLeg.Departure.Site.Name,
+                        coords: this.jsonToCoordinates(jsonLeg.Departure.Site.Position)
+                    };
+                    leg.to = {
+                        name: jsonLeg.Arrival.Site.Name,
+                        coords: this.jsonToCoordinates(jsonLeg.Arrival.Site.Position)
+                    };
+
+                    leg.steps = [];
+                    for (const jsonPathLink of jsonLeg.pathLinks.PathLink) {
+                        const step = new Step();
+                        let stepCoords;
+                        if (jsonPathLink.Geometry) {
+                            stepCoords = this.parseWKTGeometry(jsonPathLink.Geometry);
+                        } else {
+                            stepCoords = [leg.from.coords, leg.to.coords];
+                        }
+                        step.coords = stepCoords[0];
+                        step._idCoordsInLeg = leg.coords.length;
+                        stepCoords.forEach((coords, idx) => {
+                            if (
+                                idx !== 0
+                                || leg.coords.length === 0
+                                || !leg.coords[leg.coords.length - 1].equalsTo(coords)
+                            ) {
+                                leg.coords.push(coords);
+                            }
+                        });
+
+
+                        step.name = jsonPathLink.Departure.Site.Name;
+                        step.levelChange = null;
+
+                        step.distance = jsonPathLink.Distance;
+
+                        leg.steps.push(step);
+                    }
+
+                } else if (Constants.PUBLIC_TRANSPORT.includes(leg.mode)) {
+
+                    leg.from = {
+                        name: jsonLeg.Departure.StopPlace.Name,
+                        coords: this.jsonToCoordinates(jsonLeg.Departure.StopPlace.Position)
+                    };
+                    leg.to = {
+                        name: jsonLeg.Arrival.StopPlace.Name,
+                        coords: this.jsonToCoordinates(jsonLeg.Arrival.StopPlace.Position)
+                    };
+
+                    let transportName = jsonLeg.Line.Number;
+                    if (leg.mode === Constants.ROUTING_MODE.TRAM && transportName.toLowerCase().includes('tram')) {
+                        // In order to remove the "TRAM " prefix.
+                        transportName = transportName.substr(5);
+                    }
+
+                    leg.transportInfo = {
+                        name: transportName,
+                        routeColor: jsonLeg.Line.Color,
+                        routeTextColor: jsonLeg.Line.TextColor,
+                        directionName: jsonLeg.Destination
+                    };
+
+                    for (const jsonStep of jsonLeg.steps.Step) {
+                        const stepCoords = this.parseWKTGeometry(jsonStep.Geometry);
+                        stepCoords.forEach((coords, idx) => {
+                            if (
+                                idx !== 0
+                                || leg.coords.length === 0
+                                || !leg.coords[leg.coords.length - 1].equalsTo(coords)
+                            ) {
+                                leg.coords.push(coords);
+                            }
+                        });
+                    }
+
+                    const legStep = new Step();
+                    legStep.coords = leg.coords[0];
+                    legStep._idCoordsInLeg = 0;
+                    legStep.name = jsonLeg.Line.Name;
+                    legStep.levelChange = null;
+                    legStep.distance = jsonLeg.Distance;
+                    leg.steps = [legStep];
+                } else {
+                    Logger.warn(`[CitywayParser] Unknown leg mode: ${jsonLeg.TransportMode}`);
+                }
+
+                leg.distance = leg.coords.reduce((acc, coords, idx, arr) => {
+                    if (idx === 0) {
+                        return acc;
+                    }
+                    return acc + arr[idx - 1].distanceTo(coords);
+                }, 0);
+
+                itinerary.legs.push(leg);
+
+            }
+
+            routerResponse.itineraries.push(itinerary);
+
+            itinerary.distance = itinerary.coords.reduce((acc, coords, idx, arr) => {
+                if (idx === 0) {
+                    return acc;
+                }
+                return acc + arr[idx - 1].distanceTo(coords);
+            }, 0);
+
+            // All legs have to be parsed before computing steps metadata
+            generateStepsMetadata(itinerary);
+        }
+
+        routerResponse.from = routerResponse.itineraries[0].from;
+        routerResponse.to = routerResponse.itineraries[routerResponse.itineraries.length - 1].to;
+
+        return routerResponse;
+    }
+
+    /**
+     * @param {object} json
+     * @returns {Coordinates}
+     */
+    jsonToCoordinates(json) {
+        return new Coordinates(json.Lat, json.Long);
+    }
+
+    /**
+     * @param {string} jsonDate
+     * @returns {number}
+     */
+    jsonDateToTimestamp(jsonDate) {
+        const [dateStr, timeStr] = jsonDate.split(' ');
+        const [dayStr, monthStr, yearStr] = dateStr.split('/');
+        const [hoursStr, minutesStr, secondsStr] = timeStr.split(':');
+
+        return dateWithTimeZone(
+            Number(yearStr),
+            Number(monthStr) - 1,
+            Number(dayStr),
+            Number(hoursStr),
+            Number(minutesStr),
+            Number(secondsStr)
+        ).getTime();
+    }
+
+    /**
+     * @param {string} wktGeometry
+     * @returns {Coordinates[]}
+     */
+    parseWKTGeometry(wktGeometry) {
+        const tmpCoordsStr = wktGeometry.match(/LINESTRING \((.*)\)/i);
+        const tmpCoordsPt = wktGeometry.match(/POINT \((.*)\)/i);
+        if (!tmpCoordsStr && !tmpCoordsPt) {
+            return null;
+        }
+
+        if (tmpCoordsPt) {
+            const [lng, lat] = tmpCoordsPt[1].split(' ');
+            return [new Coordinates(Number(lat), Number(lng))];
+        }
+
+        return tmpCoordsStr[1].split(',').map(str => {
+            const sp = str.trim().split(' ');
+            return new Coordinates(Number(sp[1]), Number(sp[0]));
+        });
+    }
+
+    /**
+     * @param {string} iso8601Duration
+     * @see https://stackoverflow.com/a/29153059/2239938
+     */
+    parseDuration(iso8601Duration) {
+        const iso8601DurationRegex = /(-)?P(?:([.,\d]+)Y)?(?:([.,\d]+)M)?(?:([.,\d]+)W)?(?:([.,\d]+)D)?T(?:([.,\d]+)H)?(?:([.,\d]+)M)?(?:([.,\d]+)S)?/;
+
+        var matches = iso8601Duration.match(iso8601DurationRegex);
+
+        // const sign = typeof matches[1] === 'undefined' ? '+' : '-',
+        const years = typeof matches[2] === 'undefined' ? 0 : Number(matches[2]);
+        const months = typeof matches[3] === 'undefined' ? 0 : Number(matches[3]);
+        const weeks = typeof matches[4] === 'undefined' ? 0 : Number(matches[4]);
+        const days = typeof matches[5] === 'undefined' ? 0 : Number(matches[5]);
+        const hours = typeof matches[6] === 'undefined' ? 0 : Number(matches[6]);
+        const minutes = typeof matches[7] === 'undefined' ? 0 : Number(matches[7]);
+        const seconds = typeof matches[8] === 'undefined' ? 0 : Number(matches[8]);
+
+        return seconds
+            + minutes * 60
+            + hours * 3600
+            + days * 86400
+            + weeks * (86400 * 7)
+            + months * (86400 * 30)
+            + years * (86400 * 365.25);
+    }
+}
+
+export default new CitywayRemoteRouter();