Merge pull request opentripplanner#6715 from HSLdevcom/stop-in-service

Check if stops have services running in the future

Author: optionsome

application/src/ext/java/org/opentripplanner/ext/vectortiles/layers/stops/DigitransitRealtimeStopPropertyMapper.java

@@ -39,13 +39,15 @@ protected Collection<KeyValue> map(RegularStop stop) {
       .findStopTimesInPattern(stop, serviceDate, ArrivalDeparture.BOTH, true)
       .stream()
       .anyMatch(stopTime -> stopTime.times.size() > 0);
+    var inService = transitService.hasScheduledServicesAfter(LocalDate.now(), stop);
 
     Collection<KeyValue> sharedKeyValues = getBaseKeyValues(stop, i18NStringMapper, transitService);
     return ListUtils.combine(
       sharedKeyValues,
       List.of(
         new KeyValue("closedByServiceAlert", noServiceAlert),
-        new KeyValue("servicesRunningOnServiceDate", stopTimesExist)
+        new KeyValue("servicesRunningOnServiceDate", stopTimesExist),
+        new KeyValue("servicesRunningInFuture", inService)
       )
     );
   }

application/src/main/java/org/opentripplanner/transit/service/DefaultTransitService.java

@@ -813,4 +813,9 @@ public int compare(TripOnServiceDate t1, TripOnServiceDate t2) {
       }
     }
   }
+
+  @Override
+  public boolean hasScheduledServicesAfter(LocalDate date, StopLocation stop) {
+    return timetableRepositoryIndex.hasScheduledServicesAfter(date, stop);
+  }
 }

application/src/main/java/org/opentripplanner/transit/service/TimetableRepositoryIndex.java

@@ -50,6 +50,7 @@ class TimetableRepositoryIndex {
   private final Multimap<Route, TripPattern> patternsForRoute = ArrayListMultimap.create();
   private final Multimap<StopLocation, TripPattern> patternsForStop = ArrayListMultimap.create();
 
+  private Map<StopLocation, LocalDate> endOfServiceDateForStop = new HashMap<>();
   private final Map<LocalDate, TIntSet> serviceCodesRunningForDate = new HashMap<>();
   private final Map<TripIdAndServiceDate, TripOnServiceDate> tripOnServiceDateForTripAndDay =
     new HashMap<>();
@@ -102,7 +103,7 @@ class TimetableRepositoryIndex {
       );
     }
 
-    initalizeServiceCodesForDate(timetableRepository);
+    initializeServiceData(timetableRepository);
 
     if (OTPFeature.FlexRouting.isOn()) {
       flexIndex = new FlexIndex(timetableRepository);
@@ -150,6 +151,21 @@ Collection<Trip> getTripsForStop(StopLocation stop) {
       .collect(Collectors.toList());
   }
 
+  /**
+   * Checks if the last scheduled service date for the stop is on or after the given date.
+   * This does not include real-time updates, so it only checks the scheduled service dates.
+   *
+   * @param date the date to check against
+   * @param stop the stop to check
+   * @return true if the stop has scheduled services after the given date, false otherwise
+   */
+  boolean hasScheduledServicesAfter(LocalDate date, StopLocation stop) {
+    LocalDate endOfServiceDate = endOfServiceDateForStop.get(stop);
+    return (
+      endOfServiceDate != null && (endOfServiceDate.isAfter(date) || endOfServiceDate.isEqual(date))
+    );
+  }
+
   Operator getOperatorForId(FeedScopedId operatorId) {
     return operatorForId.get(operatorId);
   }
@@ -196,7 +212,7 @@ FlexIndex getFlexIndex() {
     return flexIndex;
   }
 
-  private void initalizeServiceCodesForDate(TimetableRepository timetableRepository) {
+  private void initializeServiceData(TimetableRepository timetableRepository) {
     CalendarService calendarService = timetableRepository.getCalendarService();
 
     if (calendarService == null) {
@@ -215,13 +231,22 @@ private void initalizeServiceCodesForDate(TimetableRepository timetableRepositor
     // Reconstruct set of all dates where service is defined, keeping track of which services
     // run on which days.
     Multimap<LocalDate, FeedScopedId> serviceIdsForServiceDate = HashMultimap.create();
+    Map<FeedScopedId, LocalDate> endOfServiceDateForService = new HashMap<>();
 
     for (FeedScopedId serviceId : calendarService.getServiceIds()) {
       Set<LocalDate> serviceDatesForService = calendarService.getServiceDatesForServiceId(
         serviceId
       );
       for (LocalDate serviceDate : serviceDatesForService) {
         serviceIdsForServiceDate.put(serviceDate, serviceId);
+
+        // Save the last service date for each service.
+        if (
+          endOfServiceDateForService.get(serviceId) == null ||
+          (serviceDate != null && serviceDate.isAfter(endOfServiceDateForService.get(serviceId)))
+        ) {
+          endOfServiceDateForService.put(serviceId, serviceDate);
+        }
       }
     }
     for (LocalDate serviceDate : serviceIdsForServiceDate.keySet()) {
@@ -231,6 +256,31 @@ private void initalizeServiceCodesForDate(TimetableRepository timetableRepositor
       }
       serviceCodesRunningForDate.put(serviceDate, serviceCodesRunning);
     }
+
+    initializeTheEndOfServiceDateForStop(endOfServiceDateForService);
+  }
+
+  private void initializeTheEndOfServiceDateForStop(
+    Map<FeedScopedId, LocalDate> endOfServiceDateForService
+  ) {
+    Map<StopLocation, LocalDate> endOfServiceDates = new HashMap<>();
+    for (StopLocation stop : patternsForStop.keySet()) {
+      for (TripPattern pattern : patternsForStop.get(stop)) {
+        pattern
+          .scheduledTripsAsStream()
+          .forEach(trip -> {
+            LocalDate tripEndDate = endOfServiceDateForService.get(trip.getServiceId());
+            LocalDate endOfServiceDate = endOfServiceDates.get(stop);
+            if (
+              tripEndDate != null &&
+              (endOfServiceDate == null || tripEndDate.isAfter(endOfServiceDate))
+            ) {
+              endOfServiceDates.put(stop, tripEndDate);
+            }
+          });
+      }
+    }
+    endOfServiceDateForStop = Map.copyOf(endOfServiceDates);
   }
 
   Collection<GroupOfRoutes> getAllGroupOfRoutes() {

application/src/main/java/org/opentripplanner/transit/service/TransitService.java

@@ -418,4 +418,10 @@ Collection<RegularStop> findRegularStopsByBoundingBox(
    * Returns a list of {@link StopLocation}s that match the filtering defined in the request.
    */
   Collection<StopLocation> findStopLocations(FindStopLocationsRequest request);
+
+  /**
+   * Returns boolean indicating if there are scheduled services on or after the given date.
+   * This does not include real-time updates, so it only checks the scheduled service dates.
+   */
+  boolean hasScheduledServicesAfter(LocalDate date, StopLocation stop);
 }

application/src/test/java/org/opentripplanner/transit/service/DefaultTransitServiceTest.java

@@ -2,6 +2,7 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.opentripplanner.transit.model.basic.TransitMode.BUS;
 import static org.opentripplanner.transit.model.basic.TransitMode.FERRY;
 import static org.opentripplanner.transit.model.basic.TransitMode.RAIL;
@@ -47,7 +48,10 @@ class DefaultTransitServiceTest {
     .withParentStation(STATION)
     .build();
   private static final RegularStop STOP_B = TEST_MODEL.stop("B").withParentStation(STATION).build();
-
+  private static final RegularStop STOP_C = TEST_MODEL.stop("C").withVehicleType(BUS).build();
+  private static final RegularStop STOP_ONE = TEST_MODEL.stop("Stop_1")
+    .withVehicleType(TRAM)
+    .build();
   private static final FeedScopedId SERVICE_ID = new FeedScopedId("FEED", "SERVICE");
   private static final int SERVICE_CODE = 0;
   private static final TripPattern FERRY_PATTERN = TEST_MODEL.pattern(FERRY).build();
@@ -90,6 +94,22 @@ class DefaultTransitServiceTest {
     .withServiceCode(SERVICE_CODE)
     .build();
 
+  static FeedScopedId CALENDAR_ID_TWO = TimetableRepositoryForTest.id("CAL_2");
+  static Trip TRIP_TODAY = TimetableRepositoryForTest.trip("12345")
+    .withHeadsign(I18NString.of("Trip Headsign"))
+    .withServiceId(CALENDAR_ID_TWO)
+    .build();
+  private static final ScheduledTripTimes SCHEDULED_TRIP_TIMES_TODAY = ScheduledTripTimes.of()
+    .withTrip(TRIP_TODAY)
+    .withArrivalTimes(new int[] { 0, 1 })
+    .withDepartureTimes(new int[] { 0, 1 })
+    .withServiceCode(SERVICE_CODE)
+    .build();
+  private static final TripPattern BUS_PATTERN_TODAY = TEST_MODEL.pattern(BUS)
+    .withStopPattern(REAL_TIME_STOP_PATTERN)
+    .withScheduledTimeTableBuilder(builder -> builder.addTripTimes(SCHEDULED_TRIP_TIMES_TODAY))
+    .build();
+
   private static final LocalDate SERVICE_DATE = LocalDate.of(2024, 1, 1);
   private static final LocalDate NO_SERVICE_DATE = LocalDate.of(2024, 1, 2);
 
@@ -107,43 +127,57 @@ static void setup() {
     var siteRepository = TEST_MODEL.siteRepositoryBuilder()
       .withRegularStop(STOP_A)
       .withRegularStop(STOP_B)
+      .withRegularStop(STOP_C)
+      .withRegularStop(STOP_ONE)
       .withStation(STATION)
       .build();
 
     var deduplicator = new Deduplicator();
-    var transitModel = new TimetableRepository(siteRepository, deduplicator);
+    var timetableRepository = new TimetableRepository(siteRepository, new Deduplicator());
     var canceledStopTimes = TEST_MODEL.stopTimesEvery5Minutes(3, TRIP, "11:30");
     var canceledTripTimes = TripTimesFactory.tripTimes(TRIP, canceledStopTimes, deduplicator)
       .createRealTimeFromScheduledTimes()
       .cancelTrip()
       .build();
-    transitModel.addTripPattern(RAIL_PATTERN.getId(), RAIL_PATTERN);
+    timetableRepository.addTripPattern(RAIL_PATTERN.getId(), RAIL_PATTERN);
 
     // Crate a calendar (needed for testing cancelled trips)
     CalendarServiceData calendarServiceData = new CalendarServiceData();
     var firstDate = LocalDate.of(2024, 8, 8);
     var secondDate = LocalDate.of(2024, 8, 9);
+    var thirdDate = LocalDate.of(2025, 7, 2);
+
     calendarServiceData.putServiceDatesForServiceId(
       CALENDAR_ID,
-      List.of(firstDate, secondDate, SERVICE_DATE)
+      List.of(firstDate, secondDate, thirdDate, SERVICE_DATE)
+    );
+    calendarServiceData.putServiceDatesForServiceId(
+      CALENDAR_ID_TWO,
+      List.of(firstDate, secondDate)
     );
-    transitModel.getServiceCodes().put(CALENDAR_ID, 0);
-    transitModel.updateCalendarServiceData(true, calendarServiceData, DataImportIssueStore.NOOP);
 
-    transitModel.index();
-    var timetableRepository = new TimetableRepository(siteRepository, new Deduplicator());
-    var calendar = new CalendarServiceData();
-    calendar.putServiceDatesForServiceId(SERVICE_ID, List.of(SERVICE_DATE));
     var serviceCodes = timetableRepository.getServiceCodes();
     serviceCodes.put(SERVICE_ID, SERVICE_CODE);
-    timetableRepository.updateCalendarServiceData(true, calendar, DataImportIssueStore.NOOP);
+    serviceCodes.put(CALENDAR_ID, SERVICE_CODE);
+    serviceCodes.put(CALENDAR_ID_TWO, 1);
+
     timetableRepository.addTripPattern(RAIL_PATTERN.getId(), RAIL_PATTERN);
+    timetableRepository.addTripPattern(BUS_PATTERN.getId(), BUS_PATTERN);
+    timetableRepository.addTripPattern(BUS_PATTERN_TODAY.getId(), BUS_PATTERN_TODAY);
+
+    timetableRepository.updateCalendarServiceData(
+      true,
+      calendarServiceData,
+      DataImportIssueStore.NOOP
+    );
+
     timetableRepository.index();
 
     TimetableSnapshot timetableSnapshot = new TimetableSnapshot();
     TripTimes tripTimes = ScheduledTripTimes.of()
       .withTrip(TimetableRepositoryForTest.trip("123").build())
       .withDepartureTimes(new int[] { 0, 1 })
+      .withServiceCode(SERVICE_CODE)
       .build();
     timetableSnapshot.update(new RealTimeTripUpdate(REAL_TIME_PATTERN, tripTimes, firstDate));
     timetableSnapshot.update(new RealTimeTripUpdate(RAIL_PATTERN, canceledTripTimes, firstDate));
@@ -273,4 +307,12 @@ void getRealtimeTripTimesForAddedTrip() {
   void getRealtimeTripTimesForAddedTripOnNoServiceDay() {
     assertEquals(Optional.empty(), service.getTripTimeOnDates(ADDED_TRIP, NO_SERVICE_DATE));
   }
+
+  @Test
+  void hasTripsForStop() {
+    assertTrue(service.hasScheduledServicesAfter(LocalDate.of(2025, 7, 1), STOP_ONE));
+    assertTrue(service.hasScheduledServicesAfter(LocalDate.of(2025, 7, 2), STOP_ONE));
+    assertFalse(service.hasScheduledServicesAfter(LocalDate.of(2025, 7, 3), STOP_ONE));
+    assertFalse(service.hasScheduledServicesAfter(LocalDate.of(2025, 7, 1), STOP_C));
+  }
 }