@wemap/osm 5.2.0 → 5.4.1

package/src/routers/cityway/CitywayUtils.js

@@ -0,0 +1,227 @@
+/* eslint-disable max-depth */
+/* eslint-disable max-statements */
+import { Coordinates } from '@wemap/geo';
+
+import Itinerary from '../Itinerary.js';
+import Leg from '../Leg.js';
+import RouterResponse from '../RouterResponse.js';
+import Step from '../Step.js';
+import { generateStepsMetadata } from '../Utils.js';
+
+/**
+ * @param {object} json
+ * @returns {Coordinates}
+ */
+export function jsonToCoordinates(json) {
+    return new Coordinates(json.Lat, json.Long);
+}
+
+/**
+ * @param {string} jsonDate
+ * @returns {number}
+ */
+function jsonDateToTimestamp(jsonDate) {
+    const [dateStr, timeStr] = jsonDate.split(' ');
+    const [dayStr, monthStr, yearStr] = dateStr.split('/');
+    const [hoursStr, minutesStr, secondsStr] = timeStr.split(':');
+    const date = new Date(
+        Number(yearStr), Number(monthStr) - 1, Number(dayStr),
+        Number(hoursStr), Number(minutesStr), Number(secondsStr)
+    );
+    return date.getTime();
+}
+
+/**
+ * @param {string} wktGeometry
+ * @returns {Coordinates[]}
+ */
+function parseWKTGeometry(wktGeometry) {
+    const tmpCoordsStr = wktGeometry.match(/LINESTRING \((.*)\)/i);
+    if (!tmpCoordsStr) {
+        return null;
+    }
+    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
+ */
+function 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);
+}
+
+/**
+ * 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
+ */
+export function createRouterResponseFromJson(json) {
+
+    if (json.StatusCode !== 200 || !json.Data || !json.Data.length) {
+        return null;
+    }
+
+    const routerResponse = new RouterResponse();
+    routerResponse.routerName = 'cityway';
+
+
+    // For the moment, take the first of the Data array.
+    const jsonResponse = json.Data[0].response;
+
+    for (const trip of jsonResponse.trips.Trip) {
+
+        const itinerary = new Itinerary();
+
+        itinerary.duration = parseDuration(trip.Duration);
+        itinerary.startTime = jsonDateToTimestamp(trip.Departure.Time);
+        itinerary.from = jsonToCoordinates(trip.Departure.Site.Position);
+        itinerary.endTime = jsonDateToTimestamp(trip.Arrival.Time);
+        itinerary.to = jsonToCoordinates(trip.Arrival.Site.Position);
+        routerResponse.itineraries.push(itinerary);
+
+        for (const jsonSection of trip.sections.Section) {
+
+            const jsonLeg = jsonSection.Leg ? jsonSection.Leg : jsonSection.PTRide;
+
+            const leg = new Leg();
+
+            leg.mode = jsonLeg.TransportMode;
+            leg.duration = parseDuration(jsonLeg.Duration);
+            leg.startTime = jsonDateToTimestamp(jsonLeg.Departure.Time);
+            leg.endTime = jsonDateToTimestamp(jsonLeg.Arrival.Time);
+            leg.coords = [];
+
+            if (leg.mode === 'WALK') {
+
+                leg.from = {
+                    name: jsonLeg.Departure.Site.Name,
+                    coords: jsonToCoordinates(jsonLeg.Departure.Site.Position)
+                };
+                leg.to = {
+                    name: jsonLeg.Arrival.Site.Name,
+                    coords: jsonToCoordinates(jsonLeg.Arrival.Site.Position)
+                };
+
+                leg.steps = [];
+                for (const jsonPathLink of jsonLeg.pathLinks.PathLink) {
+                    const step = new Step();
+                    let stepCoords;
+                    if (jsonPathLink.Geometry) {
+                        stepCoords = 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 (leg.mode === 'BUS' || leg.mode === 'TRAM') {
+
+                leg.from = {
+                    name: jsonLeg.Departure.StopPlace.Name,
+                    coords: jsonToCoordinates(jsonLeg.Departure.StopPlace.Position)
+                };
+                leg.to = {
+                    name: jsonLeg.Arrival.StopPlace.Name,
+                    coords: jsonToCoordinates(jsonLeg.Arrival.StopPlace.Position)
+                };
+
+                leg.transportInfo = {
+                    name: jsonLeg.Line.Number,
+                    routeColor: jsonLeg.Line.Color,
+                    routeTextColor: jsonLeg.Line.TextColor,
+                    directionName: jsonLeg.Destination
+                };
+
+                for (const jsonStep of jsonLeg.steps.Step) {
+                    const stepCoords = 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];
+            }
+
+            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);
+
+        }
+
+        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;
+}
+
+

package/src/routers/cityway/CitywayUtils.spec.js

@@ -0,0 +1,65 @@
+/* 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 './CitywayUtils.js';
+
+import { verifyRouterResponseData } from '../RouterResponse.type.spec.js';
+
+
+const { expect } = chai;
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+describe('CitywayUtils - createRouterResponseFromJson', () => {
+
+    it('RouterResponse - 1', () => {
+
+        const filePath = path.resolve(__dirname, '../../../assets/itinerary-lehavre-cityway.json');
+        const fileString = fs.readFileSync(filePath, 'utf8');
+        const json = JSON.parse(fileString);
+
+        const routerResponse = createRouterResponseFromJson(json);
+        verifyRouterResponseData(routerResponse);
+
+        expect(routerResponse.routerName).equal('cityway');
+        expect(routerResponse.itineraries.length).equal(3);
+        expect(routerResponse.from.equalsTo(new Coordinates(49.515093882362159, 0.093417496193663158))).true;
+        expect(routerResponse.to.equalsTo(new Coordinates(49.5067090188444, 0.16948421154178309))).true;
+
+        const itinerary1 = routerResponse.itineraries[0];
+        expect(itinerary1.distance).to.be.closeTo(6887, 1);
+        expect(itinerary1.duration).equal(2379);
+        // Do not work because of the input time format
+        // expect(itinerary1.startTime).equal(1620659156000);
+        // expect(itinerary1.endTime).equal(1620661535000);
+        expect(itinerary1.legs.length).equal(5);
+
+        const itinerary1leg1 = itinerary1.legs[0];
+        // Do not work because of the input time format
+        // expect(itinerary1leg1.startTime).equal(1620659156000);
+        // expect(itinerary1leg1.endTime).equal(1620659340000);
+        expect(itinerary1leg1.distance).to.be.closeTo(200.14, 0.1);
+        expect(itinerary1leg1.mode).equal('WALK');
+        expect(itinerary1leg1.transportInfo).is.null;
+        expect(itinerary1leg1.from.name).equal('RUE DU QUARTIER NEUF');
+        expect(itinerary1leg1.from.coords.equalsTo(new Coordinates(49.515093882362159, 0.093417496193663158))).true;
+        expect(itinerary1leg1.to.name).equal('T. Gautier');
+        expect(itinerary1leg1.to.coords.equalsTo(new Coordinates(49.5147550229, 0.0911025378))).true;
+
+        const itinerary1leg2 = itinerary1.legs[1];
+        expect(itinerary1leg2.mode).equal('BUS');
+        expect(itinerary1leg2.transportInfo).is.not.null;
+        expect(itinerary1leg2.transportInfo.name).equal('03');
+        expect(itinerary1leg2.transportInfo.routeColor).equal('3FA435');
+        expect(itinerary1leg2.transportInfo.routeTextColor).is.null;
+        expect(itinerary1leg2.transportInfo.directionName).equal('Graville');
+    });
+
+
+});
+