Filter routes and patterns by service date in GTFS GraphQL API

magidoc.mjs

@@ -37,14 +37,14 @@ To learn how to deactivate it, read the
         'Polyline': '<>',
         'GeoJson': '<>',
         'OffsetDateTime': '2024-02-05T18:04:23+01:00',
+        'LocalDate': '2024-05-24',
         'Duration': 'PT10M',
         'CoordinateValue': 19.24,
         'Reluctance': 3.1,
         'Speed': 3.4,
         'Cost': 100,
         'Ratio': 0.25,
         'Locale': 'en'
-
       },
     }
   },

src/main/java/org/opentripplanner/apis/gtfs/GraphQLScalars.java

@@ -18,6 +18,7 @@
 import java.util.Optional;
 import javax.annotation.Nonnull;
 import org.locationtech.jts.geom.Geometry;
+import org.opentripplanner.framework.graphql.scalar.DateScalarFactory;
 import org.opentripplanner.framework.graphql.scalar.DurationScalarFactory;
 import org.opentripplanner.framework.json.ObjectMappers;
 import org.opentripplanner.framework.model.Cost;
@@ -235,6 +236,8 @@ private static Optional<Cost> validateCost(int cost) {
     )
     .build();
 
+  public static final GraphQLScalarType LOCAL_DATE_SCALAR = DateScalarFactory.createGtfsDateScalar();
+
   public static final GraphQLScalarType GEOJSON_SCALAR = GraphQLScalarType
     .newScalar()
     .name("GeoJson")

src/main/java/org/opentripplanner/apis/gtfs/GtfsGraphQLIndex.java

@@ -22,8 +22,6 @@
 import java.util.Map;
 import java.util.Objects;
 import java.util.concurrent.ExecutionException;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import org.opentripplanner.apis.gtfs.datafetchers.AgencyImpl;
@@ -86,7 +84,6 @@
 import org.opentripplanner.apis.support.graphql.LoggingDataFetcherExceptionHandler;
 import org.opentripplanner.ext.actuator.MicrometerGraphQLInstrumentation;
 import org.opentripplanner.framework.application.OTPFeature;
-import org.opentripplanner.framework.concurrent.OtpRequestThreadFactory;
 import org.opentripplanner.framework.graphql.GraphQLResponseSerializer;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
@@ -97,10 +94,6 @@ class GtfsGraphQLIndex {
 
   private static final GraphQLSchema indexSchema = buildSchema();
 
-  static final ExecutorService threadPool = Executors.newCachedThreadPool(
-    OtpRequestThreadFactory.of("gtfs-api-%d")
-  );
-
   protected static GraphQLSchema buildSchema() {
     try {
       URL url = Objects.requireNonNull(GtfsGraphQLIndex.class.getResource("schema.graphqls"));
@@ -118,6 +111,7 @@ protected static GraphQLSchema buildSchema() {
         .scalar(GraphQLScalars.COORDINATE_VALUE_SCALAR)
         .scalar(GraphQLScalars.COST_SCALAR)
         .scalar(GraphQLScalars.RELUCTANCE_SCALAR)
+        .scalar(GraphQLScalars.LOCAL_DATE_SCALAR)
         .scalar(ExtendedScalars.GraphQLLong)
         .scalar(ExtendedScalars.Locale)
         .scalar(

src/main/java/org/opentripplanner/apis/gtfs/PatternByServiceDatesFilter.java

@@ -0,0 +1,97 @@
+package org.opentripplanner.apis.gtfs;
+
+import java.time.LocalDate;
+import java.util.Collection;
+import java.util.Objects;
+import java.util.function.Function;
+import java.util.stream.Stream;
+import org.opentripplanner.apis.gtfs.generated.GraphQLTypes;
+import org.opentripplanner.apis.gtfs.model.LocalDateRange;
+import org.opentripplanner.transit.model.network.Route;
+import org.opentripplanner.transit.model.network.TripPattern;
+import org.opentripplanner.transit.model.timetable.Trip;
+import org.opentripplanner.transit.service.TransitService;
+
+/**
+ * Encapsulates the logic to filter patterns by the service dates that they operate on. It also
+ * has a method to filter routes by checking if their patterns operate on the required days.
+ * <p>
+ * Once a more complete filtering engine is in place in the core data model, this code should be
+ * there rather than a separate class in the API package.
+ */
+public class PatternByServiceDatesFilter {
+
+  private final Function<Route, Collection<TripPattern>> getPatternsForRoute;
+  private final Function<Trip, Collection<LocalDate>> getServiceDatesForTrip;
+  private final LocalDateRange range;
+
+  /**
+   * This method is not private to enable unit testing.
+   * <p>
+   */
+  PatternByServiceDatesFilter(
+    LocalDateRange range,
+    Function<Route, Collection<TripPattern>> getPatternsForRoute,
+    Function<Trip, Collection<LocalDate>> getServiceDatesForTrip
+  ) {
+    this.getPatternsForRoute = Objects.requireNonNull(getPatternsForRoute);
+    this.getServiceDatesForTrip = Objects.requireNonNull(getServiceDatesForTrip);
+    this.range = range;
+
+    if (range.unlimited()) {
+      throw new IllegalArgumentException("start and end cannot be both null");
+    } else if (range.startBeforeEnd()) {
+      throw new IllegalArgumentException("start must be before end");
+    }
+  }
+
+  public PatternByServiceDatesFilter(
+    GraphQLTypes.GraphQLLocalDateRangeInput filterInput,
+    TransitService transitService
+  ) {
+    this(
+      new LocalDateRange(filterInput.getGraphQLStart(), filterInput.getGraphQLEnd()),
+      transitService::getPatternsForRoute,
+      trip -> transitService.getCalendarService().getServiceDatesForServiceId(trip.getServiceId())
+    );
+  }
+
+  /**
+   * Filter the patterns by the service dates that it operates on.
+   */
+  public Collection<TripPattern> filterPatterns(Collection<TripPattern> tripPatterns) {
+    return tripPatterns.stream().filter(this::hasServicesOnDate).toList();
+  }
+
+  /**
+   * Filter the routes by listing all their patterns' service dates and checking if they
+   * operate on the specified dates.
+   */
+  public Collection<Route> filterRoutes(Stream<Route> routeStream) {
+    return routeStream
+      .filter(r -> {
+        var patterns = getPatternsForRoute.apply(r);
+        return !this.filterPatterns(patterns).isEmpty();
+      })
+      .toList();
+  }
+
+  private boolean hasServicesOnDate(TripPattern pattern) {
+    return pattern
+      .scheduledTripsAsStream()
+      .anyMatch(trip -> {
+        var dates = getServiceDatesForTrip.apply(trip);
+
+        return dates
+          .stream()
+          .anyMatch(date ->
+            (
+              range.startInclusive() == null ||
+              date.isEqual(range.startInclusive()) ||
+              date.isAfter(range.startInclusive())
+            ) &&
+            (range.endExclusive() == null || date.isBefore(range.endExclusive()))
+          );
+      });
+  }
+}

src/main/java/org/opentripplanner/apis/gtfs/datafetchers/QueryTypeImpl.java

@@ -27,11 +27,13 @@
 import org.locationtech.jts.geom.Envelope;
 import org.opentripplanner.apis.gtfs.GraphQLRequestContext;
 import org.opentripplanner.apis.gtfs.GraphQLUtils;
+import org.opentripplanner.apis.gtfs.PatternByServiceDatesFilter;
 import org.opentripplanner.apis.gtfs.generated.GraphQLDataFetchers;
 import org.opentripplanner.apis.gtfs.generated.GraphQLTypes;
 import org.opentripplanner.apis.gtfs.generated.GraphQLTypes.GraphQLQueryTypeStopsByRadiusArgs;
 import org.opentripplanner.apis.gtfs.mapping.routerequest.LegacyRouteRequestMapper;
 import org.opentripplanner.apis.gtfs.mapping.routerequest.RouteRequestMapper;
+import org.opentripplanner.apis.gtfs.support.time.LocalDateRangeUtil;
 import org.opentripplanner.ext.fares.impl.DefaultFareService;
 import org.opentripplanner.ext.fares.impl.GtfsFaresService;
 import org.opentripplanner.ext.fares.model.FareRuleSet;
@@ -609,6 +611,11 @@ public DataFetcher<Iterable<Route>> routes() {
             GraphQLUtils.startsWith(route.getLongName(), name, environment.getLocale())
           );
       }
+
+      if (LocalDateRangeUtil.hasServiceDateFilter(args.getGraphQLServiceDates())) {
+        var filter = new PatternByServiceDatesFilter(args.getGraphQLServiceDates(), transitService);
+        routeStream = filter.filterRoutes(routeStream).stream();
+      }
       return routeStream.toList();
     };
   }

src/main/java/org/opentripplanner/apis/gtfs/datafetchers/RouteImpl.java

@@ -9,11 +9,13 @@
 import java.util.stream.Collectors;
 import org.opentripplanner.apis.gtfs.GraphQLRequestContext;
 import org.opentripplanner.apis.gtfs.GraphQLUtils;
+import org.opentripplanner.apis.gtfs.PatternByServiceDatesFilter;
 import org.opentripplanner.apis.gtfs.generated.GraphQLDataFetchers;
 import org.opentripplanner.apis.gtfs.generated.GraphQLTypes;
 import org.opentripplanner.apis.gtfs.generated.GraphQLTypes.GraphQLBikesAllowed;
 import org.opentripplanner.apis.gtfs.generated.GraphQLTypes.GraphQLTransitMode;
 import org.opentripplanner.apis.gtfs.mapping.BikesAllowedMapper;
+import org.opentripplanner.apis.gtfs.support.time.LocalDateRangeUtil;
 import org.opentripplanner.routing.alertpatch.EntitySelector;
 import org.opentripplanner.routing.alertpatch.TransitAlert;
 import org.opentripplanner.routing.services.TransitAlertService;
@@ -174,8 +176,19 @@ public DataFetcher<GraphQLTransitMode> mode() {
 
   @Override
   public DataFetcher<Iterable<TripPattern>> patterns() {
-    return environment ->
-      getTransitService(environment).getPatternsForRoute(getSource(environment));
+    return environment -> {
+      final TransitService transitService = getTransitService(environment);
+      var patterns = transitService.getPatternsForRoute(getSource(environment));
+
+      var args = new GraphQLTypes.GraphQLRoutePatternsArgs(environment.getArguments());
+
+      if (LocalDateRangeUtil.hasServiceDateFilter(args.getGraphQLServiceDates())) {
+        var filter = new PatternByServiceDatesFilter(args.getGraphQLServiceDates(), transitService);
+        return filter.filterPatterns(patterns);
+      } else {
+        return patterns;
+      }
+    };
   }
 
   @Override

src/main/java/org/opentripplanner/apis/gtfs/generated/GraphQLTypes.java

@@ -1268,6 +1268,35 @@ public void setGraphQLOriginModesWithParentStation(
     }
   }
 
+  public static class GraphQLLocalDateRangeInput {
+
+    private java.time.LocalDate end;
+    private java.time.LocalDate start;
+
+    public GraphQLLocalDateRangeInput(Map<String, Object> args) {
+      if (args != null) {
+        this.end = (java.time.LocalDate) args.get("end");
+        this.start = (java.time.LocalDate) args.get("start");
+      }
+    }
+
+    public java.time.LocalDate getGraphQLEnd() {
+      return this.end;
+    }
+
+    public java.time.LocalDate getGraphQLStart() {
+      return this.start;
+    }
+
+    public void setGraphQLEnd(java.time.LocalDate end) {
+      this.end = end;
+    }
+
+    public void setGraphQLStart(java.time.LocalDate start) {
+      this.start = start;
+    }
+  }
+
   /** Identifies whether this stop represents a stop or station. */
   public enum GraphQLLocationType {
     ENTRANCE,
@@ -3449,13 +3478,16 @@ public static class GraphQLQueryTypeRoutesArgs {
     private List<String> feeds;
     private List<String> ids;
     private String name;
+    private GraphQLLocalDateRangeInput serviceDates;
     private List<GraphQLMode> transportModes;
 
     public GraphQLQueryTypeRoutesArgs(Map<String, Object> args) {
       if (args != null) {
         this.feeds = (List<String>) args.get("feeds");
         this.ids = (List<String>) args.get("ids");
         this.name = (String) args.get("name");
+        this.serviceDates =
+          new GraphQLLocalDateRangeInput((Map<String, Object>) args.get("serviceDates"));
         if (args.get("transportModes") != null) {
           this.transportModes =
             ((List<Object>) args.get("transportModes")).stream()
@@ -3478,6 +3510,10 @@ public String getGraphQLName() {
       return this.name;
     }
 
+    public GraphQLLocalDateRangeInput getGraphQLServiceDates() {
+      return this.serviceDates;
+    }
+
     public List<GraphQLMode> getGraphQLTransportModes() {
       return this.transportModes;
     }
@@ -3494,6 +3530,10 @@ public void setGraphQLName(String name) {
       this.name = name;
     }
 
+    public void setGraphQLServiceDates(GraphQLLocalDateRangeInput serviceDates) {
+      this.serviceDates = serviceDates;
+    }
+
     public void setGraphQLTransportModes(List<GraphQLMode> transportModes) {
       this.transportModes = transportModes;
     }
@@ -3933,6 +3973,26 @@ public void setGraphQLLanguage(String language) {
     }
   }
 
+  public static class GraphQLRoutePatternsArgs {
+
+    private GraphQLLocalDateRangeInput serviceDates;
+
+    public GraphQLRoutePatternsArgs(Map<String, Object> args) {
+      if (args != null) {
+        this.serviceDates =
+          new GraphQLLocalDateRangeInput((Map<String, Object>) args.get("serviceDates"));
+      }
+    }
+
+    public GraphQLLocalDateRangeInput getGraphQLServiceDates() {
+      return this.serviceDates;
+    }
+
+    public void setGraphQLServiceDates(GraphQLLocalDateRangeInput serviceDates) {
+      this.serviceDates = serviceDates;
+    }
+  }
+
   /** Entities that are relevant for routes that can contain alerts */
   public enum GraphQLRouteAlertType {
     AGENCY,

src/main/java/org/opentripplanner/apis/gtfs/generated/graphql-codegen.yml

@@ -34,7 +34,7 @@ config:
     Speed: Double
     Reluctance: Double
     Ratio: Double
-
+    LocalDate: java.time.LocalDate
   mappers:
     AbsoluteDirection: org.opentripplanner.apis.gtfs.generated.GraphQLTypes.GraphQLAbsoluteDirection#GraphQLAbsoluteDirection
     Agency: org.opentripplanner.transit.model.organization.Agency#Agency

src/main/java/org/opentripplanner/apis/gtfs/model/LocalDateRange.java

@@ -0,0 +1,23 @@
+package org.opentripplanner.apis.gtfs.model;
+
+import java.time.LocalDate;
+import javax.annotation.Nullable;
+
+/**
+ * See the API documentation for a discussion of {@code startInclusive} and {@code endExclusive}.
+ */
+public record LocalDateRange(@Nullable LocalDate startInclusive, @Nullable LocalDate endExclusive) {
+  /**
+   * Does it actually define a limit or is the range unlimited?
+   */
+  public boolean unlimited() {
+    return startInclusive == null && endExclusive == null;
+  }
+
+  /**
+   * Is the start date before the end (
+   */
+  public boolean startBeforeEnd() {
+    return startInclusive != null && endExclusive != null && startInclusive.isAfter(endExclusive);
+  }
+}

src/main/java/org/opentripplanner/apis/gtfs/support/time/LocalDateRangeUtil.java

@@ -0,0 +1,18 @@
+package org.opentripplanner.apis.gtfs.support.time;
+
+import org.opentripplanner.apis.gtfs.generated.GraphQLTypes;
+import org.opentripplanner.apis.gtfs.model.LocalDateRange;
+
+public class LocalDateRangeUtil {
+
+  /**
+   * Checks if a service date filter input has at least one filter set. If both start and end are
+   * null then no filtering is necessary and this method returns null.
+   */
+  public static boolean hasServiceDateFilter(GraphQLTypes.GraphQLLocalDateRangeInput dateRange) {
+    return (
+      dateRange != null &&
+      !new LocalDateRange(dateRange.getGraphQLStart(), dateRange.getGraphQLEnd()).unlimited()
+    );
+  }
+}