@transportme/load-ptv-gtfs 1.3.5 → 1.3.7

package/lib/gtfs-parser/GTFSStop.mjs

@@ -27,7 +27,7 @@ export class GTFSStop {
   #isInterstate = false
   #suburbInFrontMatch
 
-  constructor({ stopGTFSID, stopName, stopLat, stopLon, locationType, parentStopGTFSID }, suburbs) {
+  constructor({ stopGTFSID, stopName, stopLat, stopLon, locationType, parentStopGTFSID }, suburbs, suburbHook) {
     this.stopGTFSID = stopGTFSID
     this.originalName = stopName.replace(/ \(\w+\.\.\. #/, ' #').replace(/  +/g, ' ').trim()
 
@@ -39,7 +39,7 @@ export class GTFSStop {
       coordinates: [parseFloat(stopLon), parseFloat(stopLat)]
     }
 
-    this.#setSuburb(suburbs)
+    this.#setSuburb(suburbs, suburbHook)
     this.#setStopNumber()
 
     this.fullStopName = this.getFullStopName()
@@ -105,8 +105,11 @@ export class GTFSStop {
     return this.#expandSuburb(this.originalName.slice(suburbIndex + 1, -1))
   }
 
-  #setSuburb(suburbs) {
-    if (this.requiresSuburb()) {
+  #setSuburb(suburbs, suburbHook) {
+    let output
+    if (suburbHook && (output = suburbHook(this))) {
+      this.suburb = output
+    } else if (this.requiresSuburb()) {
       this.suburb = this.getSuburbFromLocation(suburbs)
     } else {
       this.suburb = this.getSuburbFromName()
@@ -206,10 +209,10 @@ export class GTFSStop {
     return true
   }
 
-  static create(data, suburbs) {
+  static create(data, suburbs, suburbHook) {
     let types = [ GTFSRRBStop, GTFSPlatformStop, GTFSStop ]
     for (let type of types) {
-      if (type.canProcess(data)) return new type(data, suburbs)
+      if (type.canProcess(data)) return new type(data, suburbs, suburbHook)
     }
   }
 }
@@ -218,8 +221,8 @@ export class GTFSPlatformStop extends GTFSStop {
 
   platform
 
-  constructor(data, suburbs) {
-    super(data, suburbs)
+  constructor(data, suburbs, suburbHook) {
+    super(data, suburbs, suburbHook)
     this.platform = data.platform
   }
 
@@ -238,9 +241,9 @@ export class GTFSPlatformStop extends GTFSStop {
 
 export class GTFSRRBStop extends GTFSPlatformStop {
 
-  constructor(data, suburbs) {
+  constructor(data, suburbs, suburbHook) {
     data.stopName = data.stopName.replace('Rail Replacement Bus Stop', 'Railway Station')
-    super(data, suburbs)
+    super(data, suburbs, suburbHook)
     this.platform = 'RRB'
   }
 

package/lib/gtfs-parser/readers/GTFSStopsReader.mjs

@@ -4,10 +4,12 @@ import GTFSReader from './GTFSReader.mjs'
 export default class GTFSStopsReader extends GTFSReader {
  
   #suburbData
+  #suburbHook
 
-  constructor(file, suburbData) {
+  constructor(file, suburbData, suburbHook) {
     super(file)
     this.#suburbData = suburbData
+    this.#suburbHook = suburbHook
   }
 
   /**
@@ -33,6 +35,6 @@ export default class GTFSStopsReader extends GTFSReader {
       parentStopGTFSID: data.parent_station
     }
 
-    return GTFSStop.create(stopData, this.#suburbData)
+    return GTFSStop.create(stopData, this.#suburbData, this.#suburbHook)
   }
 }

package/lib/loader/StopsLoader.mjs

@@ -19,11 +19,12 @@ export default class StopsLoader {
    * @param {FeatureCollection} suburbs A GeoJSON FeatureCollection containing a list of all suburbs located within Victoria
    * @param {string} mode The transit mode being loaded
    * @param {DatabaseConnection} database A database connection
+   * @param {function} [suburbHook] A hook that returns the stop's suburb, or null if unavailable. This function is called before processing from the stop's name or location
    */
-  constructor(stopsFile, suburbs, mode, database) {
+  constructor(stopsFile, suburbs, mode, database, suburbHook) {
     this.#stops = database.getCollection('stops')
     this.#mode = mode
-    this.#stopsReader = new GTFSStopsReader(stopsFile, suburbs)
+    this.#stopsReader = new GTFSStopsReader(stopsFile, suburbs, suburbHook)
   }
 
   getMergeName(stop) {

package/lib/loader/TripLoader.mjs

@@ -28,6 +28,7 @@ export default class TripLoader {
 
   #shapeIDMap = {}
   #directionIDMap = {}
+  #stopServicesMap = {}
 
   #tripsToLoad = []
 
@@ -172,9 +173,27 @@ export default class TripLoader {
     if (!this.#directionIDMap[tripData.routeGTFSID]) this.#directionIDMap[tripData.routeGTFSID] = {}
     this.#directionIDMap[tripData.routeGTFSID][rawTripData.getHeadsign()] = rawTripData.getGTFSDirection()
     
+    this.updateStopServices(processedData)
+    
     this.#tripsToLoad.push(processedData)
   }
 
+  updateStopServices(trip) {
+    let { gtfsDirection, routeGTFSID, routeNumber } = trip
+    trip.stopTimings.forEach(stop => {
+      let { stopGTFSID } = stop
+      let serviceID = `${routeGTFSID}-${gtfsDirection}-${routeNumber}`
+      if (!this.#stopServicesMap[stopGTFSID]) this.#stopServicesMap[stopGTFSID] = { services: {}, screenServices: {} }
+      if (!this.#stopServicesMap[stopGTFSID].services[serviceID]) {
+        this.#stopServicesMap[stopGTFSID].services[serviceID] = { routeGTFSID, gtfsDirection, routeNumber }
+      }
+
+      if (stop.stopConditions.pickup === 0 && !this.#stopServicesMap[stopGTFSID].screenServices[serviceID]) {
+        this.#stopServicesMap[stopGTFSID].screenServices[serviceID] = { routeGTFSID, gtfsDirection, routeNumber }
+      }
+    })
+  }
+
   /**
    * Loads the trip data into the database.
    * 
@@ -222,4 +241,16 @@ export default class TripLoader {
   getDirectionIDMap() {
     return this.#directionIDMap
   }
+
+  getStopServicesMap() {
+    let output = {}
+    for (let stopGTFSID of Object.keys(this.#stopServicesMap)) {
+      let stopServices = this.#stopServicesMap[stopGTFSID]
+      output[stopGTFSID] = {
+        services: Object.values(stopServices.services),
+        screenServices: Object.values(stopServices.screenServices)
+      }
+    }
+    return output
+  }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@transportme/load-ptv-gtfs",
-  "version": "1.3.5",
+  "version": "1.3.7",
   "description": "",
   "main": "index.mjs",
   "scripts": {

package/test/gtfs-stop-loader.test.mjs

@@ -197,6 +197,22 @@ describe('The GTFS Stops Loader', () => {
     expect(gumRd.stopName).to.equal('Gum Road/Main Road West')
   })
 
+  it('Should allow for a custom suburb hook', async () => {
+    let database = new LokiDatabaseConnection('test-db')
+    let stops = await database.createCollection('stops')
+
+    let testSuburbs = ['A', 'B', 'C', null, 'D']
+
+    let loader = new StopsLoader(stopsFile, suburbs, TRANSIT_MODES.bus, database, () => testSuburbs.shift())
+    await loader.loadStops()
+
+    expect((await stops.findDocument({ 'bays.stopGTFSID': '1000' })).suburb[0]).to.equal('A')
+    expect((await stops.findDocument({ 'bays.stopGTFSID': '10001' })).suburb[0]).to.equal('B')
+    expect((await stops.findDocument({ 'bays.stopGTFSID': '10002' })).suburb[0]).to.equal('C')
+    expect((await stops.findDocument({ 'bays.stopGTFSID': '10009' })).suburb[0]).to.equal('Albanvale') // Null so not used
+    expect((await stops.findDocument({ 'bays.stopGTFSID': '1001' })).suburb[0]).to.equal('D')
+  })
+
   it('Should allow for individual stops to be loaded in', async () => {
     let database = new LokiDatabaseConnection('test-db')
     let stops = await database.createCollection('stops')

package/test/gtfs-stops.test.mjs

@@ -64,6 +64,15 @@ describe('The GTFSStopReader class', () => {
       expect(stopData.stopGTFSID).to.equal('14330')
       expect(stopData.parentStopGTFSID).to.equal('vic:rail:CHL')
     })
+
+    it('Should allow a custom stop suburb hook', async () => {
+      let stopReader = new GTFSStopsReader(parentStopsFile, suburbs, () => 'Test')
+      await stopReader.open()
+
+      let stopData = await stopReader.getNextEntity()
+      expect(stopData.rawStopName).to.equal('Clifton Hill Station')
+      expect(stopData.suburb).to.equal('Test')
+    })
   })
 
   describe('The getNextEntity function', () => {

package/test/gtfs-trip-loader.test.mjs

@@ -139,4 +139,50 @@ describe('The TripLoader class', () => {
       '2-ALM': { 'Alamein': 0, 'Camberwell': 1 }
     })
   })
+
+  it('Should return a mapping stop services', async () => {
+    let database = new LokiDatabaseConnection('test-db')
+    let stops = await database.createCollection('stops')
+    let routes = await database.createCollection('routes')
+    let trips = await database.createCollection('gtfs timetables')
+
+    let stopLoader = new StopsLoader(stopsFile, suburbs, TRANSIT_MODES.metroTrain, database)
+    await stopLoader.loadStops()
+
+    let routeLoader = new RouteLoader(routesFile, agencyFile, TRANSIT_MODES.metroTrain, database)
+    await routeLoader.loadRoutes()
+
+    let routeIDMap = routeLoader.getRouteIDMap()
+
+    let tripLoader = new TripLoader({
+      tripsFile, stopTimesFile,
+      calendarFile, calendarDatesFile
+    }, TRANSIT_MODES.metroTrain, database)
+    
+    await tripLoader.loadTrips({ routeIDMap })
+
+    let stopServicesMap = tripLoader.getStopServicesMap()
+
+    expect(stopServicesMap['vic:rail:ALM'].services).to.deep.equal([{
+      routeGTFSID: '2-ALM',
+      gtfsDirection: 1,
+      routeNumber: null
+    }, {
+      routeGTFSID: '2-ALM',
+      gtfsDirection: 0,
+      routeNumber: null
+    }])
+
+    expect(stopServicesMap['vic:rail:ALM'].screenServices).to.deep.equal([{
+      routeGTFSID: '2-ALM',
+      gtfsDirection: 1,
+      routeNumber: null
+    }])
+
+    expect(stopServicesMap['vic:rail:CAM'].screenServices).to.deep.equal([{
+      routeGTFSID: '2-ALM',
+      gtfsDirection: 0,
+      routeNumber: null
+    }])
+  })
 })