Added RAPTOR algorithm planner

Author: danae

package-lock.json

@@ -15,6 +15,7 @@
   },
   "dependencies": {
     "cors": "~2.8.5",
+    "dayjs": "~1.11.19",
     "express": "~5.2.1",
     "http-errors": "~2.0.1",
     "js-toml": "~1.0.2",

package.json

@@ -10,6 +10,7 @@ import { createRoutesRouter } from "./controllers/routes.js";
 import { createTransfersRouter } from "./controllers/transfers.js";
 import { createServicesRouter } from "./controllers/services.js";
 import { createNotificationsRouter } from "./controllers/notifications.js";
+import { createPlannerRouter } from './controllers/planner.js';
 
 
 // Create the Winston logger
@@ -49,6 +50,7 @@ export function createApp(logger, feed) {
   app.use('/timetable/transfers', createTransfersRouter(app));
   app.use('/timetable/services', createServicesRouter(app));
   app.use('/timetable/notifications', createNotificationsRouter(app));
+  app.use('/planner', createPlannerRouter(app));
 
   // Add the error middleware to the app
   app.use(respondWithError(logger));

src/app.js

@@ -1,3 +1,5 @@
+import dayjs from 'dayjs';
+import customParseFormat from 'dayjs/plugin/customParseFormat.js';
 import http from 'http';
 
 import { createApp, createLogger } from './app.js'
@@ -7,6 +9,9 @@ import { FeedError } from './model/exception.js';
 
 // Main function
 async function main() {
+  // Initialize Day.js
+  dayjs.extend(customParseFormat);
+
   // Create the logger
   const logger = createLogger();
 

src/main.js

@@ -0,0 +1,67 @@
+import { RouteLeg } from './routeLeg.js';
+import { TransferLeg } from './transferLeg.js';
+
+
+// Class that defines a journey
+export class Journey
+{
+  // Constructor
+  constructor(legs, departureTime) {
+    this.legs = legs;
+
+    this.departureTime = departureTime;
+    this.arrivalTime = departureTime.add(legs.at(-1).cumulativeTime, 'seconds');
+    this.duration = this.arrivalTime.diff(this.departureTime, 'seconds');
+
+    // Iterate over the legs
+    for (let leg of this.legs) {
+      // Check the type of the leg
+      if (leg instanceof RouteLeg) {
+        // Copy the route
+        leg.route = leg.route._copy();
+
+        // Iterate over the stops of the route and set the journey time
+        for (let stop of leg.route.stops)
+          stop._journeyTime = this.departureTime.add(stop._cumulativeTime, 'seconds');
+      } else if (leg instanceof TransferLeg) {
+        // Copy the transfer
+        leg.transfer = leg.transfer._copy();
+
+        // Set the journey time
+        leg.transfer._journeyTime = this.departureTime.add(leg.transfer.duration, 'seconds');
+      }
+    }
+  }
+
+  // Return the JSON representation of the route leg
+  toJSON(options) {
+    return {
+      from: this.from.toJSON(options),
+      to: this.to.toJSON(options),
+      departureTime: this.departureTime.format('YYYY-MM-DD[T]HH:mm:ss'),
+      formattedDepartureTime: this.departureTime.format('H:mm'),
+      arrivalTime: this.arrivalTime.format('YYYY-MM-DD[T]HH:mm:ss'),
+      formattedArrivalTime: this.arrivalTime.format('H:mm'),
+      duration: this.duration,
+      formattedDuration: `${Math.floor(this.duration / 3600)}:${Math.floor(this.duration % 3600 / 60).toString().padStart(2, '0')}`,
+      transfers: this.transfers,
+      legs: this.legs.map(leg => leg.toJSON(options)),
+    };
+  }
+
+
+  // Return the departure node of the journey
+  get from() {
+    return this.legs.at(0).from;
+  }
+
+  // Return the arrival node of the journey
+  get to() {
+    return this.legs.at(-1).to;
+  }
+
+  // Return the amount of transfers of the journey
+  get transfers() {
+    return this.legs.filter(l => l instanceof RouteLeg).length - 1;
+  }
+}

src/model/journey.js

@@ -72,10 +72,7 @@ export class Node extends Record
 
   // Add the stops to a route that stops at a node
   _addStopsToRoute(route) {
-    return route.getStopsAtNode(this).map(stop => {
-      const stopRoute = route._sliceBeginningAtSequence(stop.sequence);
-      stopRoute.stopAtNode = stop;
-      return stopRoute;
-    });
+    return route.getStopsAtNode(this)
+      .map(stop => route._sliceBeginningAtSequence(stop.sequence, {_stopAtNode: stop}));
   }
 }

src/model/node.js

@@ -11,12 +11,12 @@ export class Route extends Record
 
     if (!('name' in data))
       throw new FeedError(`Missing required field "name" in route with id "${this.id}"`);
+    if (!('headsign' in data))
+      throw new FeedError(`Missing required field "headsign" in route with id "${this.id}"`);
     if (!('agency' in data))
       throw new FeedError(`Missing required field "agency" in route with id "${this.id}"`);
     if (!('modality' in data))
       throw new FeedError(`Missing required field "modality" in route with id "${this.id}"`);
-    if (!('headsign' in data))
-      throw new FeedError(`Missing required field "modality" in route with id "${this.id}"`);
     if (!('stops' in data))
       throw new FeedError(`Missing required field "stops" in route with id "${this.id}"`);
 
@@ -32,8 +32,8 @@ export class Route extends Record
     this.stops = data.stops;
     this.visible = data.visible ?? true;
 
-    this.stopAtNode = undefined;
-    this.initialTime = data.initialTime ?? 0;
+    this._stopAtNode = data._stopAtNode ?? undefined;
+    this._initialTime = data._initialTime ?? 0;
   }
 
   // Finalize loading the route
@@ -42,22 +42,16 @@ export class Route extends Record
     this.stops = this.stops.map(s => s._copy());
 
     // Calculate cumulative time for the stops of the route
-    let lastHeadsignSequence = null;
+    let lastHeadsignStopSequence = null;
     for (let [index, stop] of this.stops.entries()) {
-      // Set the flags of the first and last stops
-      stop.first = index === 0;
-      stop.last = index === this.stops.length - 1;
-
-      // Set the time of the first stop
-      stop.time = index > 0 ? stop.time : 0;
+      // Set the duration and cumulative time of the stop
+      stop.duration = index > 0 ? stop.duration : 0;
+      stop._cumulativeTime = (index > 0 ? this.stops[index - 1]._cumulativeTime : this._initialTime) + stop.duration;
 
-      // Calculate cumulative time for the stop
-      stop.cumulativeTime = (index > 0 ? this.stops[index - 1].cumulativeTime : this.initialTime) + stop.time;
-
-      // Set the actual headsign sequence of the stop
+      // Set the headsign stop sequence of the stop
       if (stop.headsign !== null)
-        lastHeadsignSequence = stop.sequence;
-      stop._actualHeadsignSequence = lastHeadsignSequence;
+        lastHeadsignStopSequence = stop.sequence;
+      stop._headsignStopSequence = lastHeadsignStopSequence;
     }
   }
 
@@ -66,7 +60,7 @@ export class Route extends Record
     return {
       id: this.id,
       name: this._feed.applyTranslation(this, 'name', options?.language),
-      headsign: this._feed.applyTranslation(this, ['stops', this.stopAtNode?._actualHeadsignSequence, 'headsign'], options?.language)
+      headsign: this._feed.applyTranslation(this, ['stops', this._stopAtNode?._actualHeadsignSequence, 'headsign'], options?.language)
         ?? this._feed.applyTranslation(this, 'headsign', options?.language),
       abbr: this._feed.applyTranslation(this, 'abbr', options?.language),
       description: this._feed.applyTranslation(this, 'description', options?.language),
@@ -76,8 +70,9 @@ export class Route extends Record
       modality: this.modality.toJSON(options),
       icon: this.icon,
       stops: this.stops.map(stop => stop.toJSON(options)),
-      stopAtNode: this.stopAtNode?.toJSON(options),
       visible: this.visible,
+
+      stopAtNode: this._stopAtNode?.toJSON(options),
     };
   }
 
@@ -122,31 +117,26 @@ export class Route extends Record
   }
 
   // Slice the route to begin at the specified sequence
-  _sliceBeginningAtSequence(seqence) {
+  _sliceBeginningAtSequence(seqence, modifiedProps = {}) {
     let index = this.getStopIndexWithSequence(seqence);
-    return index > -1 ? this._copy({stops: this.stops.slice(index)}) : this._copy();
+    return index > -1 ? this._copy({...modifiedProps, stops: this.stops.slice(index)}) : this._copy(modifiedProps);
   }
 
   // Slice the route to end at the specified sequence
-  _sliceEndingAtSequence(seqence) {
+  _sliceEndingAtSequence(seqence, modifiedProps = {}) {
     let index = this.getStopIndexWithSequence(seqence);
-    return index > -1 ? this._copy({stops: this.stops.slice(0, index + 1)}) : this._copy();
+    return index > -1 ? this._copy({...modifiedProps, stops: this.stops.slice(0, index + 1)}) : this._copy(modifiedProps);
   }
 
   // Slice the route to begin at the specified node
-  _sliceBeginningAtNode(node) {
+  _sliceBeginningAtNode(node, modifiedProps = {}) {
     let index = this.getStopIndexAtNode(node);
-    return index > -1 ? this._copy({stops: this.stops.slice(index)}) : this._copy();
+    return index > -1 ? this._copy({...modifiedProps, stops: this.stops.slice(index)}) : this._copy(modifiedProps);
   }
 
   // Slice the route to end at the specified node
-  _sliceEndingAtNode(node) {
+  _sliceEndingAtNode(node, modifiedProps = {}) {
     let index = this.getStopIndexAtNode(node);
-    return index > -1 ? this._copy({stops: this.stops.slice(0, index + 1)}) : this._copy();
-  }
-
-  // Apply an initial time to the route
-  _withInitialTime(initialTime) {
-    return this._copy({initialTime});
+    return index > -1 ? this._copy({...modifiedProps, stops: this.stops.slice(0, index + 1)}) : this._copy(modifiedProps);
   }
 }

src/model/route.js

@@ -0,0 +1,34 @@
+// Class that defines a route leg of a journey
+export class RouteLeg
+{
+  // Constructor
+  constructor(route) {
+    this.route = route;
+  }
+
+  // Return the JSON representation of the route leg
+  toJSON(options) {
+    return {
+      type: 'route',
+      from: this.from,
+      to: this.to,
+      route: this.route.toJSON(options),
+    };
+  }
+  
+
+  // Return the departure node of the route
+  get from() {
+    return this.route.stops.at(0).node;
+  }
+
+  // Return the arrival node of the route
+  get to() {
+    return this.route.stops.at(-1).node;
+  }
+
+  // Return the cumulative time of the route
+  get cumulativeTime() {
+    return this.route.stops.at(-1)._cumulativeTime;
+  }
+}

src/model/routeLeg.js

@@ -8,39 +8,63 @@ export class RouteStop
     this.sequence = parseInt(sequence);
 
     if (!('node' in data))
-      throw new FeedError(`Missing required field "node" in route stop with sequence ${this.sequence}`);
+      throw new FeedError(`Missing required field "node" in route stop with sequence ${this.sequence} in route with id "${this._route.id}"`);
+    if (!('duration' in data))
+      throw new FeedError(`Missing required field "duration" in route stop with sequence ${this.sequence} in route with id "${this._route.id}"`);
 
     this.node = data.node;
-    this.time = data.time ?? 0;
+    this.duration = data.duration;
     this.halts = data.halts ?? true;
     this.platform = data.platform ?? null;
     this.headsign = data.headsign ?? null;
     this.alightDirection = data.alightDirection ?? null;
     this.status = data.status ?? null;
 
-    this.first = false;
-    this.last = false;
-    this.cumulativeTime = 0;
-    this.actualHeadsignSequence = undefined;
+    this._headsignStopSequence = undefined;
+    this._cumulativeTime = 0;
+    this._journeyTime = undefined;
   }
 
   // Return the JSON representation of the route stop
   toJSON(options) {
     return {
       sequence: this.sequence,
       node: this.node.toJSON(options),
-      time: this.time,
+      duration: this.duration,
+      formattedDuration: `${Math.floor(this.duration / 3600)}:${Math.floor(this.duration % 3600 / 60).toString().padStart(2, '0')}`,
       halts: this.halts,
       platform: this.platform,
-      headsign: this.actualHeadsignSequence !== undefined
-        ? this._feed.applyTranslation(this._route.getStopWithSequence(this.actualHeadsignSequence), 'headsign', options?.language)
-        : this._feed.applyTranslation(this._route, 'headsign', options?.language),
+      headsign: this._feed.applyTranslation(this._headsignStopSequence !== undefined ? this.headsignStop : this._route, 'headsign', options?.language),
       alightDirection: this.alightDirection,
       status: this.status ?? null,
+      
+      journeyTime: this._journeyTime?.format('YYYY-MM-DD[T]HH:mm:ss'),
+      formattedJourneyTime: this._journeyTime?.format('H:mm'),
     };
   }
 
 
+  // Return if this stop is the first stop of the route
+  get isFirstStop() {
+    return this === this._route.stops.at(0);
+  }
+
+  // Return if this stop is the first stop of the route
+  get isLastStop() {
+    return this === this._route.stops.at(-1);
+  }
+
+  // Return the stop that contains the headsign for this stop
+  get headsignStop() {
+    if (this._headsignStopSequence === undefined)
+      return undefined;
+    else if (this._headsignStopSequence === this.sequence)
+      return this;
+    else
+      return this._route.getStopWithSequence(this._headsignStopSequence);
+  }
+
+
   // Copy the stop
   _copy(modifiedProps = {}) {
     return new RouteStop(this._feed, this._route, this.sequence, {...this, modifiedProps});