New vectortile layer for Digitransit realtime stops

src/ext-test/java/org/opentripplanner/ext/vectortiles/layers/stops/StopsLayerTest.java

@@ -1,15 +1,32 @@
 package org.opentripplanner.ext.vectortiles.layers.stops;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.opentripplanner.framework.time.TimeUtils.time;
+import static org.opentripplanner.model.plan.TestItineraryBuilder.newItinerary;
 
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.ZonedDateTime;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.opentripplanner._support.time.ZoneIds;
+import org.opentripplanner.ext.realtimeresolver.RealtimeResolver;
 import org.opentripplanner.framework.i18n.TranslatedString;
+import org.opentripplanner.model.plan.Place;
+import org.opentripplanner.routing.alertpatch.AlertEffect;
+import org.opentripplanner.routing.alertpatch.EntitySelector;
+import org.opentripplanner.routing.alertpatch.TimePeriod;
+import org.opentripplanner.routing.alertpatch.TransitAlert;
+import org.opentripplanner.routing.impl.TransitAlertServiceImpl;
+import org.opentripplanner.routing.services.TransitAlertService;
+import org.opentripplanner.transit.model._data.TransitModelForTest;
 import org.opentripplanner.transit.model.framework.Deduplicator;
 import org.opentripplanner.transit.model.framework.FeedScopedId;
+import org.opentripplanner.transit.model.network.Route;
 import org.opentripplanner.transit.model.site.RegularStop;
 import org.opentripplanner.transit.service.DefaultTransitService;
 import org.opentripplanner.transit.service.StopModel;
@@ -18,6 +35,7 @@
 public class StopsLayerTest {
 
   private RegularStop stop;
+  private RegularStop stop2;
 
   @BeforeEach
   public void setUp() {
@@ -49,6 +67,14 @@ public void setUp() {
         .withDescription(descTranslations)
         .withCoordinate(50, 10)
         .build();
+    stop2 =
+      StopModel
+        .of()
+        .regularStop(new FeedScopedId("F", "name"))
+        .withName(nameTranslations)
+        .withDescription(descTranslations)
+        .withCoordinate(51, 10)
+        .build();
   }
 
   @Test
@@ -89,4 +115,49 @@ public void digitransitStopPropertyMapperTranslationTest() {
     assertEquals("nameDE", map.get("name"));
     assertEquals("descDE", map.get("desc"));
   }
+
+  @Test
+  public void digitransitRealtimeStopPropertyMapperTest() {
+    var deduplicator = new Deduplicator();
+    var transitModel = new TransitModel(new StopModel(), deduplicator);
+    transitModel.initTimeZone(ZoneIds.HELSINKI);
+    transitModel.index();
+    var alertService = new TransitAlertServiceImpl(transitModel);
+    var transitService = new DefaultTransitService(transitModel) {
+      @Override
+      public TransitAlertService getTransitAlertService() {
+        return alertService;
+      }
+    };
+
+    Route route = TransitModelForTest.route("route").build();
+    var itinerary = newItinerary(Place.forStop(stop), time("11:00"))
+      .bus(route, 1, time("11:05"), time("11:20"), Place.forStop(stop2))
+      .build();
+    var startDate = ZonedDateTime.now(ZoneIds.HELSINKI).minusDays(1).toEpochSecond();
+    var endDate = ZonedDateTime.now(ZoneIds.HELSINKI).plusDays(1).toEpochSecond();
+    var alert = TransitAlert
+      .of(stop.getId())
+      .addEntity(new EntitySelector.Stop(stop.getId()))
+      .addTimePeriod(new TimePeriod(startDate, endDate))
+      .withEffect(AlertEffect.NO_SERVICE)
+      .build();
+    transitService.getTransitAlertService().setAlerts(List.of(alert));
+
+    var itineraries = List.of(itinerary);
+    RealtimeResolver.populateLegsWithRealtime(itineraries, transitService);
+
+    DigitransitRealtimeStopPropertyMapper mapper = new DigitransitRealtimeStopPropertyMapper(
+      transitService,
+      new Locale("en-US")
+    );
+
+    Map<String, Object> map = new HashMap<>();
+    mapper.map(stop).forEach(o -> map.put(o.key(), o.value()));
+
+    assertEquals("F:name", map.get("gtfsId"));
+    assertEquals("name", map.get("name"));
+    assertEquals("desc", map.get("desc"));
+    assertEquals(true, map.get("closedByServiceAlert"));
+  }
 }

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

@@ -0,0 +1,50 @@
+package org.opentripplanner.ext.vectortiles.layers.stops;
+
+import static org.opentripplanner.ext.vectortiles.layers.stops.DigitransitStopPropertyMapper.getKeyValues;
+import static org.opentripplanner.ext.vectortiles.layers.stops.DigitransitStopPropertyMapper.getRoutes;
+import static org.opentripplanner.ext.vectortiles.layers.stops.DigitransitStopPropertyMapper.getType;
+
+import java.time.Instant;
+import java.util.Collection;
+import java.util.List;
+import java.util.Locale;
+import org.opentripplanner.apis.support.mapping.PropertyMapper;
+import org.opentripplanner.framework.collection.ListUtils;
+import org.opentripplanner.framework.i18n.I18NStringMapper;
+import org.opentripplanner.inspector.vector.KeyValue;
+import org.opentripplanner.transit.model.site.RegularStop;
+import org.opentripplanner.transit.service.TransitService;
+
+public class DigitransitRealtimeStopPropertyMapper extends PropertyMapper<RegularStop> {
+
+  private final TransitService transitService;
+  private final I18NStringMapper i18NStringMapper;
+
+  public DigitransitRealtimeStopPropertyMapper(TransitService transitService, Locale locale) {
+    this.transitService = transitService;
+    this.i18NStringMapper = new I18NStringMapper(locale);
+  }
+
+  @Override
+  protected Collection<KeyValue> map(RegularStop stop) {
+    Instant currentTime = Instant.now();
+    boolean noServiceAlert = transitService
+      .getTransitAlertService()
+      .getStopAlerts(stop.getId())
+      .stream()
+      .anyMatch(alert -> alert.noServiceOn(currentTime));
+
+    Collection<KeyValue> sharedKeyValues = getKeyValues(
+      stop,
+      i18NStringMapper.mapNonnullToApi(stop.getName()),
+      i18NStringMapper.mapToApi(stop.getDescription()),
+      getType(transitService, stop),
+      getRoutes(transitService, stop)
+    );
+    Collection<KeyValue> keyValues = ListUtils.combine(
+      sharedKeyValues,
+      List.of(new KeyValue("closedByServiceAlert", noServiceAlert))
+    );
+    return keyValues;
+  }
+}

src/ext/java/org/opentripplanner/ext/vectortiles/layers/stops/DigitransitStopPropertyMapper.java

@@ -20,7 +20,7 @@ public class DigitransitStopPropertyMapper extends PropertyMapper<RegularStop> {
   private final TransitService transitService;
   private final I18NStringMapper i18NStringMapper;
 
-  private DigitransitStopPropertyMapper(TransitService transitService, Locale locale) {
+  DigitransitStopPropertyMapper(TransitService transitService, Locale locale) {
     this.transitService = transitService;
     this.i18NStringMapper = new I18NStringMapper(locale);
   }
@@ -34,20 +34,39 @@ protected static DigitransitStopPropertyMapper create(
 
   @Override
   protected Collection<KeyValue> map(RegularStop stop) {
-    Collection<TripPattern> patternsForStop = transitService.getPatternsForStop(stop);
+    return getKeyValues(
+      stop,
+      i18NStringMapper.mapNonnullToApi(stop.getName()),
+      i18NStringMapper.mapToApi(stop.getDescription()),
+      getType(transitService, stop),
+      getRoutes(transitService, stop)
+    );
+  }
 
-    String type = patternsForStop
-      .stream()
-      .map(TripPattern::getMode)
-      .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
-      .entrySet()
-      .stream()
-      .max(Map.Entry.comparingByValue())
-      .map(Map.Entry::getKey)
-      .map(Enum::name)
-      .orElse(null);
+  protected static Collection<KeyValue> getKeyValues(
+    RegularStop stop,
+    String name,
+    String description,
+    String type,
+    String routes
+  ) {
+    return List.of(
+      new KeyValue("gtfsId", stop.getId().toString()),
+      new KeyValue("name", name),
+      new KeyValue("code", stop.getCode()),
+      new KeyValue("platform", stop.getPlatformCode()),
+      new KeyValue("desc", description),
+      new KeyValue(
+        "parentStation",
+        stop.getParentStation() != null ? stop.getParentStation().getId() : null
+      ),
+      new KeyValue("type", type),
+      new KeyValue("routes", routes)
+    );
+  }
 
-    String routes = JSONArray.toJSONString(
+  protected static String getRoutes(TransitService transitService, RegularStop stop) {
+    return JSONArray.toJSONString(
       transitService
         .getRoutesForStop(stop)
         .stream()
@@ -58,18 +77,20 @@ protected Collection<KeyValue> map(RegularStop stop) {
         })
         .toList()
     );
-    return List.of(
-      new KeyValue("gtfsId", stop.getId().toString()),
-      new KeyValue("name", i18NStringMapper.mapNonnullToApi(stop.getName())),
-      new KeyValue("code", stop.getCode()),
-      new KeyValue("platform", stop.getPlatformCode()),
-      new KeyValue("desc", i18NStringMapper.mapToApi(stop.getDescription())),
-      new KeyValue(
-        "parentStation",
-        stop.getParentStation() != null ? stop.getParentStation().getId() : "null"
-      ),
-      new KeyValue("type", type),
-      new KeyValue("routes", routes)
-    );
+  }
+
+  protected static String getType(TransitService transitService, RegularStop stop) {
+    Collection<TripPattern> patternsForStop = transitService.getPatternsForStop(stop);
+
+    return patternsForStop
+      .stream()
+      .map(TripPattern::getMode)
+      .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
+      .entrySet()
+      .stream()
+      .max(Map.Entry.comparingByValue())
+      .map(Map.Entry::getKey)
+      .map(Enum::name)
+      .orElse(null);
   }
 }

src/ext/java/org/opentripplanner/ext/vectortiles/layers/stops/StopsLayerBuilder.java

@@ -1,5 +1,7 @@
 package org.opentripplanner.ext.vectortiles.layers.stops;
 
+import static java.util.Map.entry;
+
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
@@ -14,7 +16,7 @@
 import org.opentripplanner.transit.model.site.RegularStop;
 import org.opentripplanner.transit.service.TransitService;
 
-public class StopsLayerBuilder extends LayerBuilder<RegularStop> {
+public class StopsLayerBuilder<T> extends LayerBuilder<T> {
 
   static Map<MapperType, BiFunction<TransitService, Locale, PropertyMapper<RegularStop>>> mappers = Map.of(
     MapperType.Digitransit,
@@ -28,7 +30,15 @@ public StopsLayerBuilder(
     Locale locale
   ) {
     super(
-      mappers.get(MapperType.valueOf(layerParameters.mapper())).apply(transitService, locale),
+      (PropertyMapper<T>) Map
+        .ofEntries(
+          entry(MapperType.Digitransit, new DigitransitStopPropertyMapper(transitService, locale)),
+          entry(
+            MapperType.DigitransitRealtime,
+            new DigitransitRealtimeStopPropertyMapper(transitService, locale)
+          )
+        )
+        .get(MapperType.valueOf(layerParameters.mapper())),
       layerParameters.name(),
       layerParameters.expansionFactor()
     );
@@ -51,5 +61,6 @@ protected List<Geometry> getGeometries(Envelope query) {
 
   enum MapperType {
     Digitransit,
+    DigitransitRealtime,
   }
 }

src/main/java/org/opentripplanner/routing/alertpatch/TransitAlert.java

@@ -191,6 +191,19 @@ public Instant getEffectiveEndDate() {
       .orElse(null);
   }
 
+  /**
+   * Checks if the alert has a NO_SERVICE alert active at the requested time.
+   * @param instant
+   * @return
+   */
+  public boolean noServiceOn(Instant instant) {
+    return (
+      effect.equals(AlertEffect.NO_SERVICE) &&
+      (getEffectiveStartDate() != null && getEffectiveStartDate().isBefore(instant)) &&
+      (getEffectiveEndDate() == null || getEffectiveEndDate().isAfter(instant))
+    );
+  }
+
   @Override
   public boolean sameAs(@Nonnull TransitAlert other) {
     return (